¿Cómo redondeas a 1 decimal en Javascript?

Respuestas:

729

Math.round(num * 10) / 10 funciona, aquí hay un ejemplo ...

var number = 12.3456789
var rounded = Math.round(number * 10) / 10
// rounded is 12.3

si desea que tenga un lugar decimal, incluso cuando eso sería un 0, entonces agregue ...

var fixed = rounded.toFixed(1)
// fixed is always to 1 d.p.
// NOTE: .toFixed() returns a string!

// To convert back to number format
parseFloat(number.toFixed(2))
// 12.34
// but that will not retain any trailing zeros

// So, just make sure it is the last step before output,
// and use a number format during calculations!

EDITAR: Agregar ronda con función de precisión ...

Usando este principio, como referencia, aquí hay una pequeña y práctica función redonda que requiere precisión ...

function round(value, precision) {
    var multiplier = Math.pow(10, precision || 0);
    return Math.round(value * multiplier) / multiplier;
}

... uso ...

round(12345.6789, 2) // 12345.68
round(12345.6789, 1) // 12345.7

... se redondea al número entero más cercano (precisión 0) ...

round(12345.6789) // 12346

... y se puede usar para redondear a los 10 o 100 más cercanos, etc.

round(12345.6789, -1) // 12350
round(12345.6789, -2) // 12300

... y manejo correcto de números negativos ...

round(-123.45, 1) // -123.4
round(123.45, 1) // 123.5

... y se puede combinar con toFixed para formatear consistentemente como cadena ...

round(456.7, 2).toFixed(2) // "456.70"
Billy Moon
fuente
45
Tenga cuidado al usarlo, .toFixed()ya que devuelve una cadena cuando tal vez desee un número.
Cobby
1
Genial, obviamente usar parseFloateliminará los decimales que quedan .toFixed()si es un número entero (ceros). En general, si quieres hacer los cálculos, es mejor seguir tu primer ejemplo. Si desea mostrar un número en su IU, use .toFixed().
Cobby
Hmmm ... eso tiene sentido, cualquier forma de convertir a número siempre debe quitar los ceros erróneos, por lo que tiene que permanecer como una cadena. Supongo que siempre debería ser el último paso antes de la visualización, y no usarlo en los cálculos.
Billy Moon
2
Tenga cuidado al usarlo, .toFixed()ya que podría devolver diferentes resultados de redondeo para diferentes navegadores. ¡Lea esta publicación para obtener detalles sobre el tema!
Wilt
1
¿Puedo agregar un cero si no hay DP presente?
Nick
102
var number = 123.456;

console.log(number.toFixed(1)); // should round to 123.5
Pablo Fernández
fuente
44
A veces toFixed()tiene fallas: lo he visto en un navegador Chrome donde llamo toFixed(), luego lo convierto en una cadena, y muestra algo como 10.00000000068: extraño. Sin embargo, no puedo reproducir esto de manera confiable.
Hamish Grubijan
Sí, conté problemas técnicos con toFixed () incluso con solo unos pocos decimales. Redondeó la fracción 4 al siguiente número más alto en lugar de menor, si mal no recuerdo.
Dalibor
1
como mencionó @cobby arriba: tenga cuidado al usarlo, .toFixed()ya que devuelve un Stringcuando tal vez desee unNumber
Ricardo
28

Si lo usa Math.round(5.01), obtendrá en 5lugar de 5.0.

Si usas toFixedte encuentras con problemas de redondeo .

Si quieres lo mejor de ambos mundos combina los dos:

(Math.round(5.01 * 10) / 10).toFixed(1)

Es posible que desee crear una función para esto:

function roundedToFixed(_float, _digits){
  var rounded = Math.pow(10, _digits);
  return (Math.round(_float * rounded) / rounded).toFixed(_digits);
}
Jasper de Vries
fuente
¿Por qué los guiones bajos para los parámetros es decir (_float, _digits)? Siéntase libre de publicar un enlace donde pueda encontrar la respuesta por mí mismo. Gracias
Shark Lasers
23

lodashtiene un roundmétodo:

_.round(4.006);
// => 4

_.round(4.006, 2);
// => 4.01

_.round(4060, -2);
// => 4100

Doc .

Fuente .

Kevin Leary
fuente
11

Voto por toFixed(), pero, para el registro, aquí hay otra forma que utiliza el desplazamiento de bits para emitir el número a un int. Por lo tanto, siempre se redondea hacia cero (hacia abajo para números positivos, hacia arriba para negativos).

var rounded = ((num * 10) << 0) * 0.1;

Pero bueno, como no hay llamadas a funciones, es muy rápido. :)

Y aquí hay uno que usa la coincidencia de cadenas:

var rounded = (num + '').replace(/(^.*?\d+)(\.\d)?.*/, '$1$2');

No recomiendo usar la variante de cadena, solo sayin.

jimbo
fuente
7

Prueba con esto:

var original=28.453

// 1.- round "original" to two decimals
var result = Math.round (original * 100) / 100  //returns 28.45

// 2.- round "original" to 1 decimal
var result = Math.round (original * 10) / 10  //returns 28.5

// 3.- round 8.111111 to 3 decimals
var result = Math.round (8.111111 * 1000) / 1000  //returns 8.111

menos complicado y más fácil de implementar ...

con esto, puede crear una función para hacer:

function RoundAndFix (n, d) {
    var m = Math.pow (10, d);
    return Math.round (n * m) / m;
}

EDITAR : vea esto Cómo redondear usando REDONDEAR MEDIA ARRIBA. Modo de redondeo que a la mayoría de nosotros nos enseñaron en la escuela primaria

atiruz
fuente
No: RoundAndFix (1.005, 2).
Noyo
4

x = número, n = decimales:

function round(x, n) {
    return Math.round(x * Math.pow(10, n)) / Math.pow(10, n)
}
súper
fuente
No: redondo (1.005, 2).
Noyo
4

¿Por qué no solo

let myNumber = 213.27321;
+myNumber.toFixed(1); // => 213.3
  1. toFixed : devuelve una cadena que representa el número dado usando notación de punto fijo.
  2. Unario más (+) : el operador unario más precede a su operando y evalúa a su operando pero intenta convertirlo en un número, si aún no lo está.
goulashsoup
fuente
3
var num = 34.7654;

num = Math.round(num * 10) / 10;

console.log(num); // Logs: 34.8
Joseph Silber
fuente
3

Para completar la mejor respuesta:

var round = function ( number, precision )
{
    precision = precision || 0;
    return parseFloat( parseFloat( number ).toFixed( precision ) );
}

El número del parámetro de entrada puede "no" ser siempre un número, en este caso .toFixed no existe.

klodoma
fuente
3

Versión ES 6 de la respuesta aceptada:

function round(value, precision) {
    const multiplier = 10 ** (precision || 0);
    return Math.round(value * multiplier) / multiplier;
}
Rayo Koustav
fuente
3

Usando el método toPrecision:

var a = 1.2345
a.toPrecision(2)

// result "1.2"
EZ
fuente
Con mucho, la mejor respuesta que he probado. Gracias.
Ste
Pero hay que tener cuidado porque 12.345.toPrecision( 2 )es así "12".
Joshua Pinter
2

Si su método no funciona, por favor publique su código.

Sin embargo, puede realizar la tarea de redondeo como:

var value = Math.round(234.567*100)/100

Te dará 234.56

similar

 var value = Math.round(234.567*10)/10

Dará 234.5

De esta manera, puede usar una variable en lugar de la constante como se usó anteriormente.

jagbandhuster
fuente
1

Pequeño filtro angular si alguien lo quiere:

angular.module('filters').filter('decimalPlace', function() {
    return function(num, precision) {
        var multiplier = Math.pow(10, precision || 0);
        return Math.round(num * multiplier) / multiplier;
    };
});

usar si a través de:

{{model.value| decimalPlace}}
{{model.value| decimalPlace:1}}
{{model.value| decimalPlace:2}}

:)

sidonaldson
fuente
1

En general, el redondeo se realiza escalando: round(num / p) * p

El uso de la notación exponencial maneja el redondeo de los números + ve, correctamente. Sin embargo, este método no logra redondear los casos de borde correctamente.

function round(num, precision = 2) {
	var scaled = Math.round(num + "e" + precision);
	return Number(scaled + "e" + -precision);
}

// testing some edge cases
console.log( round(1.005, 2) );  // 1.01 correct
console.log( round(2.175, 2) );  // 2.18 correct
console.log( round(5.015, 2) );  // 5.02 correct

console.log( round(-1.005, 2) );  // -1    wrong
console.log( round(-2.175, 2) );  // -2.17 wrong
console.log( round(-5.015, 2) );  // -5.01 wrong

Aquí, también hay una función que escribí para hacer redondeo aritmético, puede probarlo usted mismo.

/**
 * MidpointRounding away from zero ('arithmetic' rounding)
 * Uses a half-epsilon for correction. (This offsets IEEE-754
 * half-to-even rounding that was applied at the edge cases).
 */

function RoundCorrect(num, precision = 2) {
	// half epsilon to correct edge cases.
	var c = 0.5 * Number.EPSILON * num;
//	var p = Math.pow(10, precision); //slow
	var p = 1; while (precision--> 0) p *= 10;
	if (num < 0)
		p *= -1;
	return Math.round((num + c) * p) / p;
}

// testing some edge cases
console.log(RoundCorrect(1.005, 2));  // 1.01 correct
console.log(RoundCorrect(2.175, 2));  // 2.18 correct
console.log(RoundCorrect(5.015, 2));  // 5.02 correct

console.log(RoundCorrect(-1.005, 2));  // -1.01 correct
console.log(RoundCorrect(-2.175, 2));  // -2.18 correct
console.log(RoundCorrect(-5.015, 2));  // -5.02 correct

Amr Ali
fuente
0

Esto parece funcionar de manera confiable en todo lo que le arrojo:

function round(val, multiplesOf) {
  var s = 1 / multiplesOf;
  var res = Math.ceil(val*s)/s;
  res = res < val ? res + multiplesOf: res;
  var afterZero = multiplesOf.toString().split(".")[1];
  return parseFloat(res.toFixed(afterZero ? afterZero.length : 0));
}

Se redondea, por lo que es posible que deba modificarlo según el caso de uso. Esto debería funcionar:

console.log(round(10.01, 1)); //outputs 11
console.log(round(10.01, 0.1)); //outputs 10.1
Ege Özcan
fuente
0

Si le interesa el redondeo correcto, entonces:

function roundNumericStrings(str , numOfDecPlacesRequired){ 
     var roundFactor = Math.pow(10, numOfDecPlacesRequired);  
     return (Math.round(parseFloat(str)*roundFactor)/roundFactor).toString();  }

Si no, entonces ya tienes una respuesta de publicaciones anteriores.

str.slice(0, -1)
jsNovice
fuente
0

Math.round( num * 10) / 10 no funciona

Por ejemplo, 1455581777.8-145558160.4te da 1310023617.3999999.

Así que solo usa num.toFixed(1)

PW
fuente
0

Hice uno que devuelve el tipo de número y también coloca decimales solo si son necesarios (sin relleno de 0).

Ejemplos:

roundWithMaxPrecision(11.234, 2); //11.23
roundWithMaxPrecision(11.234, 1); //11.2
roundWithMaxPrecision(11.234, 4); //11.23
roundWithMaxPrecision(11.234, -1); //10

roundWithMaxPrecision(4.2, 2); //4.2
roundWithMaxPrecision(4.88, 1); //4.9

El código:

function roundWithMaxPrecision (n, precision) {
    return Math.round(n * Math.pow(10, precision)) / Math.pow(10, precision);
}
Alberto
fuente
0

Encontré una manera de evitar los problemas de precisión:

function badRound (num, precision) {
    const x = 10 ** precision;
    return Math.round(num * x) / x
}
// badRound(1.005, 2) --> 1

function round (num, precision) {
    const x = 10 ** (precision + 1);
    const y = 10 ** precision;
    return Math.round(Math.round(num * x) / 10) / y
}
// round(1.005, 2) --> 1.01
Lucas Montenegro
fuente
0
Math.round( mul/count * 10 ) / 10

Math.round(Math.sqrt(sqD/y) * 10 ) / 10

Gracias

Roy neo
fuente