Redondear a lo más 2 decimales (solo si es necesario)

Me gustaría redondear como máximo 2 decimales, pero solo si es necesario .

Entrada:

10
1.7777777
9.1

Salida:

10
1.78
9.1

¿Cómo puedo hacer esto en JavaScript?

Utilizar Math.round(num * 100) / 100

Editar: para garantizar que cosas como 1.005 redondeen correctamente, utilizamos

Math.round((num + Number.EPSILON) * 100) / 100

Si el valor es un tipo de texto:

parseFloat("123.456").toFixed(2);

Si el valor es un número:

var numb = 123.23454;
numb = numb.toFixed(2);

Hay una desventaja de que valores como 1.5 darán "1.50" como salida. Una solución sugerida por @minitech:

var numb = 1.5;
numb = +numb.toFixed(2);
// Note the plus sign that drops any "extra" zeroes at the end.
// It changes the result (which is a string) into a number again (think "0 + foo"),
// which means that it uses only as many digits as necessary.

Parece que Math.roundes una mejor solución. ¡Pero no lo es! En algunos casos NO se redondeará correctamente:

Math.round(1.005 * 1000)/1000 // Returns 1 instead of expected 1.01!

toFixed () también NO ronda correctamente en algunos casos (probado en Chrome v.55.0.2883.87)!

Ejemplos:

parseFloat("1.555").toFixed(2); // Returns 1.55 instead of 1.56.
parseFloat("1.5550").toFixed(2); // Returns 1.55 instead of 1.56.
// However, it will return correct result if you round 1.5551.
parseFloat("1.5551").toFixed(2); // Returns 1.56 as expected.

1.3555.toFixed(3) // Returns 1.355 instead of expected 1.356.
// However, it will return correct result if you round 1.35551.
1.35551.toFixed(2); // Returns 1.36 as expected.

Supongo que esto se debe a que 1.555 es en realidad algo así como flotante 1.55499994 detrás de escena.

La solución 1 es usar un script con el algoritmo de redondeo requerido, por ejemplo:

function roundNumber(num, scale) {
  if(!("" + num).includes("e")) {
    return +(Math.round(num + "e+" + scale)  + "e-" + scale);
  } else {
    var arr = ("" + num).split("e");
    var sig = ""
    if(+arr[1] + scale > 0) {
      sig = "+";
    }
    return +(Math.round(+arr[0] + "e" + sig + (+arr[1] + scale)) + "e-" + scale);
  }
}

https://plnkr.co/edit/uau8BlS1cqbvWPCHJeOy?p=preview

NOTA: Esta no es una solución universal para todos. Existen varios algoritmos de redondeo diferentes, su implementación puede ser diferente, depende de sus requisitos. https://en.wikipedia.org/wiki/Rounding

La solución 2 es evitar los cálculos frontales y extraer valores redondeados del servidor de fondo.

Puedes usar

function roundToTwo(num) {    
    return +(Math.round(num + "e+2")  + "e-2");
}

Encontré esto en MDN . Su manera evita el problema con 1.005 que se mencionó .

roundToTwo(1.005)
1.01
roundToTwo(10)
10
roundToTwo(1.7777777)
1.78
roundToTwo(9.1)
9.1
roundToTwo(1234.5678)
1234.57

La respuesta de MarkG es la correcta. Aquí hay una extensión genérica para cualquier número de decimales.

Number.prototype.round = function(places) {
  return +(Math.round(this + "e+" + places)  + "e-" + places);
}

Uso:

var n = 1.7777;    
n.round(2); // 1.78

Prueba de unidad:

it.only('should round floats to 2 places', function() {

  var cases = [
    { n: 10,      e: 10,    p:2 },
    { n: 1.7777,  e: 1.78,  p:2 },
    { n: 1.005,   e: 1.01,  p:2 },
    { n: 1.005,   e: 1,     p:0 },
    { n: 1.77777, e: 1.8,   p:1 }
  ]

  cases.forEach(function(testCase) {
    var r = testCase.n.round(testCase.p);
    assert.equal(r, testCase.e, 'didn\'t get right number');
  });
})

Deberías usar:

Math.round( num * 100 + Number.EPSILON ) / 100

Nadie parece ser consciente de Number.EPSILON .

También vale la pena señalar que esto no es una rareza de JavaScript como algunas personas declararon.

Esa es simplemente la forma en que los números de coma flotante funcionan en una computadora. Como el 99% de los lenguajes de programación, JavaScript no tiene números de coma flotante hechos en casa ; para eso depende de la CPU / FPU. Una computadora usa binario, y en binario, no hay números como0.1 , sino una mera aproximación binaria para eso. ¿Por qué? Por la misma razón que 1/3 no puede escribirse en decimal: su valor es 0.33333333 ... con un infinito de tres.

Aquí vienen Number.EPSILON. Ese número es la diferencia entre 1 y el siguiente número existente en los números de coma flotante de doble precisión. Eso es todo: no hay un número entre 1y 1 + Number.EPSILON.

EDITAR:

Como se preguntó en los comentarios, aclaremos una cosa: agregar Number.EPSILONes relevante solo cuando el valor a redondear es el resultado de una operación aritmética, ya que puede tragar algún error de coma flotante delta.

No es útil cuando el valor proviene de una fuente directa (por ejemplo, literal, entrada del usuario o sensor).

EDITAR (2019):

Como @maganap y algunas personas han señalado, es mejor agregar Number.EPSILONantes de multiplicar:

Math.round( ( num + Number.EPSILON ) * 100 ) / 100

EDITAR (diciembre de 2019):

Últimamente, utilizo una función similar a esta para comparar números con epsilon:

const ESPILON_RATE = 1 + Number.EPSILON ;
const ESPILON_ZERO = Number.MIN_VALUE ;

function epsilonEquals( a , b ) {
  if ( Number.isNaN( a ) || Number.isNaN( b ) ) {
    return false ;
  }
  if ( a === 0 || b === 0 ) {
    return a <= b + EPSILON_ZERO && b <= a + EPSILON_ZERO ;
  }
  return a <= b * EPSILON_RATE && b <= a * EPSILON_RATE ;
}

Mi caso de uso es una afirmación + validación de datos lib que estoy desarrollando durante muchos años.

De hecho, en el código que estoy usando ESPILON_RATE = 1 + 4 * Number.EPSILONy EPSILON_ZERO = 4 * Number.MIN_VALUE(cuatro veces el épsilon), porque quiero un verificador de igualdad lo suficientemente suelto como para acumular un error de coma flotante.

Hasta ahora, se ve perfecto para mí. Espero que sea de ayuda.

Se puede usar .toFixed(NumberOfDecimalPlaces).

var str = 10.234.toFixed(2); // => '10.23'
var number = Number(str); // => 10.23

Esta pregunta es complicada.

Supongamos que tenemos una función, roundTo2DP(num)que toma un flotador como argumento y devuelve un valor redondeado a 2 decimales. ¿Qué debe evaluar cada una de estas expresiones?

• roundTo2DP(0.014999999999999999)
• roundTo2DP(0.0150000000000000001)
• roundTo2DP(0.015)

La respuesta 'obvia' es que el primer ejemplo debería redondear a 0.01 (porque está más cerca de 0.01 que a 0.02) mientras que los otros dos deberían redondear a 0.02 (porque 0.0150000000000000001 está más cerca de 0.02 que a 0.01, y porque 0.015 está exactamente a mitad de camino entre ellos y hay una convención matemática de que tales números se redondean).

El problema, que puede haber adivinado, es que roundTo2DP no se puede implementar para dar esas respuestas obvias, porque los tres números que se le pasan son el mismo número . Los números de punto flotante binario IEEE 754 (el tipo utilizado por JavaScript) no pueden representar exactamente la mayoría de los números no enteros, por lo que los tres literales numéricos anteriores se redondean a un número de punto flotante válido cercano. Este número, como sucede, es exactamente

0.01499999999999999944488848768742172978818416595458984375

que está más cerca de 0.01 que de 0.02.

Puede ver que los tres números son iguales en la consola de su navegador, en el shell de nodo u otro intérprete de JavaScript. Solo compáralos:

> 0.014999999999999999 === 0.0150000000000000001
true

Entonces, cuando escribo m = 0.0150000000000000001, el valor exacto con elm que termino está más cerca de 0.01lo que está 0.02. Y sin embargo, si me convierto men una cadena ...

> var m = 0.0150000000000000001;
> console.log(String(m));
0.015
> var m = 0.014999999999999999;
> console.log(String(m));
0.015

... obtengo 0.015, que debería redondear a 0.02, y que notablemente no es el número de 56 decimales que dije anteriormente que todos estos números eran exactamente iguales. Entonces, ¿qué magia oscura es esta?

La respuesta se puede encontrar en la especificación ECMAScript, en la sección 7.1.12.1: ToString aplicado al tipo Number . Aquí se establecen las reglas para convertir un número m en una cadena. La parte clave es el punto 5, en el que se genera un número entero s cuyos dígitos se utilizarán en la representación de cadena de m :

supongamos que n , k y s son números enteros tales que k ≥ 1, 10 ^{k -1} ≤ s <10 ^k , el valor de Número para s × 10 ^{n - k} es m , y k es lo más pequeño posible. Tenga en cuenta que k es el número de dígitos en la representación decimal de s , que s no es divisible por 10, y que el dígito menos significativo de s no está necesariamente determinado únicamente por estos criterios.

La parte clave aquí es el requisito de que " k es lo más pequeño posible". Lo que equivale a ese requisito es un requisito que, dado un Número m, el valor de String(m)debe tener el menor número posible de dígitos sin dejar de cumplir el requisito de que Number(String(m)) === m. Como ya sabemos eso 0.015 === 0.0150000000000000001, ahora está claro por quéString(0.0150000000000000001) === '0.015' debe ser cierto.

Por supuesto, nada de esta discusión ha respondido directamente lo que roundTo2DP(m) debería regresar. Si mel valor exacto es 0.01499999999999999944488848768742172978818416595458984375, pero su representación de cadena es '0.015', entonces cuál es el correcto respuesta , matemática, práctica, filosófica o lo que sea, cuando redondeamos a dos decimales?

No hay una única respuesta correcta a esto. Depende de su caso de uso. Probablemente desee respetar la representación de cadena y redondear hacia arriba cuando:

• El valor que se representa es intrínsecamente discreto, por ejemplo, una cantidad de moneda en una moneda de 3 decimales, como los dinares. En este caso, el valor verdadero de un Número como 0.015 es 0.015, y la representación 0.0149999999 ... que obtiene en coma flotante binaria es un error de redondeo. (Por supuesto, muchos argumentarán, razonablemente, que debe usar una biblioteca decimal para manejar dichos valores y nunca representarlos como números binarios de coma flotante en primer lugar).
• El valor fue escrito por un usuario. En este caso, nuevamente, el número decimal exacto ingresado es más 'verdadero' que la representación de punto flotante binario más cercano.

Por otro lado, es probable que desee respetar el valor de punto flotante binario y redondear hacia abajo cuando su valor proviene de una escala inherentemente continua, por ejemplo, si es una lectura de un sensor.

Estos dos enfoques requieren un código diferente. Para respetar la representación de la cadena del número, podemos (con un poco de código razonablemente sutil) implementar nuestro propio redondeo que actúa directamente sobre la representación de la cadena, dígito a dígito, utilizando el mismo algoritmo que hubiera utilizado en la escuela cuando se les enseñó a redondear números. A continuación se muestra un ejemplo que respeta el requisito del OP de representar el número a 2 decimales "solo cuando sea necesario" quitando los ceros finales después del punto decimal; puede, por supuesto, necesitar ajustarlo a sus necesidades precisas.

/**
 * Converts num to a decimal string (if it isn't one already) and then rounds it
 * to at most dp decimal places.
 *
 * For explanation of why you'd want to perform rounding operations on a String
 * rather than a Number, see http://stackoverflow.com/a/38676273/1709587
 *
 * @param {(number|string)} num
 * @param {number} dp
 * @return {string}
 */
function roundStringNumberWithoutTrailingZeroes (num, dp) {
    if (arguments.length != 2) throw new Error("2 arguments required");

    num = String(num);
    if (num.indexOf('e+') != -1) {
        // Can't round numbers this large because their string representation
        // contains an exponent, like 9.99e+37
        throw new Error("num too large");
    }
    if (num.indexOf('.') == -1) {
        // Nothing to do
        return num;
    }

    var parts = num.split('.'),
        beforePoint = parts[0],
        afterPoint = parts[1],
        shouldRoundUp = afterPoint[dp] >= 5,
        finalNumber;

    afterPoint = afterPoint.slice(0, dp);
    if (!shouldRoundUp) {
        finalNumber = beforePoint + '.' + afterPoint;
    } else if (/^9+$/.test(afterPoint)) {
        // If we need to round up a number like 1.9999, increment the integer
        // before the decimal point and discard the fractional part.
        finalNumber = Number(beforePoint)+1;
    } else {
        // Starting from the last digit, increment digits until we find one
        // that is not 9, then stop
        var i = dp-1;
        while (true) {
            if (afterPoint[i] == '9') {
                afterPoint = afterPoint.substr(0, i) +
                             '0' +
                             afterPoint.substr(i+1);
                i--;
            } else {
                afterPoint = afterPoint.substr(0, i) +
                             (Number(afterPoint[i]) + 1) +
                             afterPoint.substr(i+1);
                break;
            }
        }

        finalNumber = beforePoint + '.' + afterPoint;
    }

    // Remove trailing zeroes from fractional part before returning
    return finalNumber.replace(/0+$/, '')
}

Ejemplo de uso:

> roundStringNumberWithoutTrailingZeroes(1.6, 2)
'1.6'
> roundStringNumberWithoutTrailingZeroes(10000, 2)
'10000'
> roundStringNumberWithoutTrailingZeroes(0.015, 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes('0.015000', 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes(1, 1)
'1'
> roundStringNumberWithoutTrailingZeroes('0.015', 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes(0.01499999999999999944488848768742172978818416595458984375, 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes('0.01499999999999999944488848768742172978818416595458984375', 2)
'0.01'

La función anterior es probablemente lo que desea usar para evitar que los usuarios sean testigos de que los números que ingresaron se redondearon incorrectamente.

(Como alternativa, también puede probar la biblioteca round10 que proporciona una función de comportamiento similar con una implementación muy diferente).

Pero, ¿qué sucede si tiene el segundo tipo de Número, un valor tomado de una escala continua, donde no hay razón para pensar que las representaciones decimales aproximadas con menos decimales son más precisas que las que tienen más? En ese caso, no queremos respetar la representación de cadena, porque esa representación (como se explica en la especificación) ya está redondeada; no queremos cometer el error de decir "0.014999999 ... 375 redondea a 0.015, que redondea a 0.02, entonces 0.014999999 ... 375 redondea a 0.02".

Aquí podemos simplemente usar el toFixedmétodo incorporado . Tenga en cuenta que al invocar Number()la Cadena devuelta por toFixed, obtenemos un Número cuya representación de Cadena no tiene ceros finales (gracias a la forma en que JavaScript calcula la representación de Cadena de un Número, discutido anteriormente en esta respuesta).

/**
 * Takes a float and rounds it to at most dp decimal places. For example
 *
 *     roundFloatNumberWithoutTrailingZeroes(1.2345, 3)
 *
 * returns 1.234
 *
 * Note that since this treats the value passed to it as a floating point
 * number, it will have counterintuitive results in some cases. For instance,
 * 
 *     roundFloatNumberWithoutTrailingZeroes(0.015, 2)
 *
 * gives 0.01 where 0.02 might be expected. For an explanation of why, see
 * http://stackoverflow.com/a/38676273/1709587. You may want to consider using the
 * roundStringNumberWithoutTrailingZeroes function there instead.
 *
 * @param {number} num
 * @param {number} dp
 * @return {number}
 */
function roundFloatNumberWithoutTrailingZeroes (num, dp) {
    var numToFixedDp = Number(num).toFixed(dp);
    return Number(numToFixedDp);
}

Considere .toFixed()y .toPrecision():

http://www.javascriptkit.com/javatutors/formatnumber.shtml

Un método de redondeo preciso. Fuente: Mozilla.

(function(){

    /**
     * Decimal adjustment of a number.
     *
     * @param   {String}    type    The type of adjustment.
     * @param   {Number}    value   The number.
     * @param   {Integer}   exp     The exponent (the 10 logarithm of the adjustment base).
     * @returns {Number}            The adjusted value.
     */
    function decimalAdjust(type, value, exp) {
        // If the exp is undefined or zero...
        if (typeof exp === 'undefined' || +exp === 0) {
            return Math[type](value);
        }
        value = +value;
        exp = +exp;
        // If the value is not a number or the exp is not an integer...
        if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {
            return NaN;
        }
        // Shift
        value = value.toString().split('e');
        value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp)));
        // Shift back
        value = value.toString().split('e');
        return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp));
    }

    // Decimal round
    if (!Math.round10) {
        Math.round10 = function(value, exp) {
            return decimalAdjust('round', value, exp);
        };
    }
    // Decimal floor
    if (!Math.floor10) {
        Math.floor10 = function(value, exp) {
            return decimalAdjust('floor', value, exp);
        };
    }
    // Decimal ceil
    if (!Math.ceil10) {
        Math.ceil10 = function(value, exp) {
            return decimalAdjust('ceil', value, exp);
        };
    }
})();

Ejemplos:

// Round
Math.round10(55.55, -1); // 55.6
Math.round10(55.549, -1); // 55.5
Math.round10(55, 1); // 60
Math.round10(54.9, 1); // 50
Math.round10(-55.55, -1); // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1); // -50
Math.round10(-55.1, 1); // -60
Math.round10(1.005, -2); // 1.01 -- compare this with Math.round(1.005*100)/100 above
// Floor
Math.floor10(55.59, -1); // 55.5
Math.floor10(59, 1); // 50
Math.floor10(-55.51, -1); // -55.6
Math.floor10(-51, 1); // -60
// Ceil
Math.ceil10(55.51, -1); // 55.6
Math.ceil10(51, 1); // 60
Math.ceil10(-55.59, -1); // -55.5
Math.ceil10(-59, 1); // -50

Ninguna de las respuestas encontradas aquí es correcta . @stinkycheeseman pidió redondear , todos redondearon el número.

Para redondear, use esto:

Math.ceil(num * 100)/100;

Aquí hay una manera simple de hacerlo:

Math.round(value * 100) / 100

Sin embargo, es posible que desee seguir adelante y hacer una función separada para hacerlo por usted:

function roundToTwo(value) {
    return(Math.round(value * 100) / 100);
}

Entonces simplemente pasarías el valor.

Puede mejorarlo para redondear a cualquier número arbitrario de decimales agregando un segundo parámetro.

function myRound(value, places) {
    var multiplier = Math.pow(10, places);

    return (Math.round(value * multiplier) / multiplier);
}

+(10).toFixed(2); // = 10
+(10.12345).toFixed(2); // = 10.12

(10).toFixed(2); // = 10.00
(10.12345).toFixed(2); // = 10.12

Para mí Math.round () no estaba dando la respuesta correcta. Descubrí que toFixed (2) funciona mejor. A continuación hay ejemplos de ambos:

console.log(Math.round(43000 / 80000) * 100); // wrong answer

console.log(((43000 / 80000) * 100).toFixed(2)); // correct answer

Usa esta función Number(x).toFixed(2);

2017
Solo usa código nativo.toFixed()

number = 1.2345;
number.toFixed(2) // "1.23"

Si necesita ser estricto y agregar dígitos solo si es necesario, puede usar replace

number = 1; // "1"
number.toFixed(5).replace(/\.?0*$/g,'');

Prueba este peso ligero solución :

function round(x, digits){
  return parseFloat(x.toFixed(digits))
}

 round(1.222,  2) ;
 // 1.22
 round(1.222, 10) ;
 // 1.222

Hay un par de formas de hacerlo. Para personas como yo, la variante de Lodash

function round(number, precision) {
    var pair = (number + 'e').split('e')
    var value = Math.round(pair[0] + 'e' + (+pair[1] + precision))
    pair = (value + 'e').split('e')
    return +(pair[0] + 'e' + (+pair[1] - precision))
}

Uso:

round(0.015, 2) // 0.02
round(1.005, 2) // 1.01

Si su proyecto usa jQuery o lodash, también puede encontrar el roundmétodo adecuado en las bibliotecas.

Actualización 1

Eliminé la variante n.toFixed(2)porque no es correcta. Gracias @ avalanche1

Si está usando la biblioteca lodash, puede usar el método redondo de lodash como el siguiente.

_.round(number, precision)

P.ej:

_.round(1.7777777, 2) = 1.78

Desde ES6 hay una forma 'adecuada' (sin anular las estadísticas y crear soluciones) para hacer esto usando toPrecision

var x = 1.49999999999;
console.log(x.toPrecision(4));
console.log(x.toPrecision(3));
console.log(x.toPrecision(2));

var y = Math.PI;
console.log(y.toPrecision(6));
console.log(y.toPrecision(5));
console.log(y.toPrecision(4));

var z = 222.987654
console.log(z.toPrecision(6));
console.log(z.toPrecision(5));
console.log(z.toPrecision(4));

entonces puedes simplemente parseFloaty los ceros 'desaparecerán'.

console.log(parseFloat((1.4999).toPrecision(3)));
console.log(parseFloat((1.005).toPrecision(3)));
console.log(parseFloat((1.0051).toPrecision(3)));

Sin embargo, no resuelve el 'problema de redondeo 1.005', ya que es intrínseco a cómo se procesan las fracciones flotantes .

console.log(1.005 - 0.005);

Si está abierto a las bibliotecas, puede usar bignumber.js

console.log(1.005 - 0.005);
console.log(new BigNumber(1.005).minus(0.005));

console.log(new BigNumber(1.005).round(4));
console.log(new BigNumber(1.005).round(3));
console.log(new BigNumber(1.005).round(2));
console.log(new BigNumber(1.005).round(1));

<script src="https://cdnjs.cloudflare.com/ajax/libs/bignumber.js/2.3.0/bignumber.min.js"></script>

MarkG y Lavamantis ofrecieron una solución mucho mejor que la que ha sido aceptada. ¡Es una pena que no reciban más votos!

Aquí está la función que uso para resolver los problemas de decimales de punto flotante también basados ​​en MDN . Es aún más genérico (pero menos conciso) que la solución de Lavamantis:

function round(value, exp) {
  if (typeof exp === 'undefined' || +exp === 0)
    return Math.round(value);

  value = +value;
  exp  = +exp;

  if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0))
    return NaN;

  // Shift
  value = value.toString().split('e');
  value = Math.round(+(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp)));

  // Shift back
  value = value.toString().split('e');
  return +(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp));
}

Úselo con:

round(10.8034, 2);      // Returns 10.8
round(1.275, 2);        // Returns 1.28
round(1.27499, 2);      // Returns 1.27
round(1.2345678e+2, 2); // Returns 123.46

En comparación con la solución de Lavamantis, podemos hacer ...

round(1234.5678, -2); // Returns 1200
round("123.45");      // Returns 123

Esto puede ayudarlo a:

var result = Math.round(input*100)/100;

para más información, puedes echar un vistazo a este enlace

Math.round (num) vs num.toFixed (0) e inconsistencias del navegador

El enfoque más fácil sería usar toFixed y luego eliminar los ceros finales con la función Number:

const number = 15.5;
Number(number.toFixed(2)); // 15.5

const number = 1.7777777;
Number(number.toFixed(2)); // 1.78

var roundUpto = function(number, upto){
    return Number(number.toFixed(upto));
}
roundUpto(0.1464676, 2);

toFixed(2) aquí 2 es el número de dígitos hasta el que queremos redondear este número.

Puede funcionar para ti

Math.round(num * 100)/100;

para saber la diferencia entre toFixed y round. Puede echar un vistazo a Math.round (num) vs num.toFixed (0) y las inconsistencias del navegador .

La manera más fácil:

+num.toFixed(2)

Lo convierte en una cadena y luego de nuevo en un entero / flotante.

Aquí hay un método prototipo:

Number.prototype.round = function(places){
    places = Math.pow(10, places); 
    return Math.round(this * places)/places;
}

var yournum = 10.55555;
yournum = yournum.round(2);

Use algo como esto "parseFloat (parseFloat (value) .toFixed (2))"

parseFloat(parseFloat("1.7777777").toFixed(2))-->1.78 
parseFloat(parseFloat("10").toFixed(2))-->10 
parseFloat(parseFloat("9.1").toFixed(2))-->9.1

Una forma de lograr dicho redondeo solo si es necesario es usar Number.prototype.toLocaleString () :

myNumber.toLocaleString('en', {maximumFractionDigits:2, useGrouping:false})

Esto proporcionará exactamente el resultado que espera, pero como cadenas. Todavía puede convertirlos de nuevo en números si ese no es el tipo de datos que espera.

Después de ejecutar varias iteraciones de todas las formas posibles para lograr una precisión de redondeo decimal verdadera y precisa, está claro que la solución más precisa y eficiente es usar Number.EPSILON. Esto proporciona una verdadera solución matemática al problema de la precisión matemática de coma flotante. Se puede rellenar fácilmente como se muestra aquí: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/EPSILON para admitir a todos los últimos usuarios restantes de IE (quizás nuevamente debería dejar de hacer eso).

Adaptado de la solución proporcionada aquí: https://stackoverflow.com/a/48850944/6910392

Una solución simple de caída que proporciona redondeo decimal preciso, piso y techo, con una variable de precisión opcional sin agregar una biblioteca completa.

ACTUALIZACIÓN: Como Sergey señaló en los comentarios, hay una limitación para este (o cualquier) método que valga la pena señalar. En el caso de números como 0.014999999999999999, seguirá experimentando imprecisiones que son el resultado de alcanzar el límite absoluto de las limitaciones de precisión para el almacenamiento de valores de coma flotante. No hay matemática u otra solución que se pueda aplicar para dar cuenta de eso, ya que el valor en sí mismo se evalúa inmediatamente como 0.015. Puede confirmar esto simplemente invocando ese valor por sí mismo en la consola. Debido a esta limitación, ni siquiera sería posible utilizar la manipulación de cadenas para reducir este valor, ya que su representación de cadenas es simplemente "0.015". Cualquier solución para explicar esto debería aplicarse lógicamente en la fuente de los datos antes de aceptar el valor en un script,

var DecimalPrecision = (function(){
        if (Number.EPSILON === undefined) {
            Number.EPSILON = Math.pow(2, -52);
        }
        this.round = function(n, p=2){
            let r = 0.5 * Number.EPSILON * n;
            let o = 1; while(p-- > 0) o *= 10;
            if(n < 0)
                o *= -1;
            return Math.round((n + r) * o) / o;
        }
        this.ceil = function(n, p=2){
            let r = 0.5 * Number.EPSILON * n;
            let o = 1; while(p-- > 0) o *= 10;
            if(n < 0)
                o *= -1;
            return Math.ceil((n + r) * o) / o;
        }
        this.floor = function(n, p=2){
            let r = 0.5 * Number.EPSILON * n;
            let o = 1; while(p-- > 0) o *= 10;
            if(n < 0)
                o *= -1;
            return Math.floor((n + r) * o) / o;
        }
        return this;
    })();
    console.log(DecimalPrecision.round(1.005));
    console.log(DecimalPrecision.ceil(1.005));
    console.log(DecimalPrecision.floor(1.005));
    console.log(DecimalPrecision.round(1.0049999));
    console.log(DecimalPrecision.ceil(1.0049999));
    console.log(DecimalPrecision.floor(1.0049999));
    console.log(DecimalPrecision.round(2.175495134384,7));
    console.log(DecimalPrecision.round(2.1753543549,8));
    console.log(DecimalPrecision.round(2.1755465135353,4));

Esta es la solución más simple y elegante (y yo soy el mejor del mundo):

function roundToX(num, X) {    
    return +(Math.round(num + "e+"+X)  + "e-"+X);
}
//roundToX(66.66666666,2) => 66.67
//roundToX(10,2) => 10
//roundToX(10.904,2) => 10.9