Javascript: formatear un número redondeado a N decimales

en JavaScript, la forma típica de redondear un número a N posiciones decimales es algo como:

function roundNumber(num, dec) {
  return Math.round(num * Math.pow(10, dec)) / Math.pow(10, dec);
}

function roundNumber(num, dec) {
  return Math.round(num * Math.pow(10, dec)) / Math.pow(10, dec);
}

console.log(roundNumber(0.1 + 0.2, 2));
console.log(roundNumber(2.1234, 2));

Sin embargo, este enfoque se redondeará a un máximo de N lugares decimales, mientras que yo siempre quiero redondear a N lugares decimales. Por ejemplo, "2.0" se redondearía a "2".

¿Algunas ideas?

Eso no es un problema de redondeo, es un problema de visualización. Un número no contiene información sobre dígitos significativos; el valor 2 es igual a 2.0000000000000. Es cuando convierte el valor redondeado en una cadena que hace que muestre una cierta cantidad de dígitos.

Puede agregar ceros después del número, algo como:

var s = number.toString();
if (s.indexOf('.') == -1) s += '.';
while (s.length < s.indexOf('.') + 4) s += '0';

(Tenga en cuenta que esto supone que la configuración regional del cliente usa un punto como separador decimal, el código necesita más trabajo para funcionar para otras configuraciones).

Creo que hay un enfoque más simple para todos aquí, y es el método Number.toFixed()ya implementado en JavaScript.

simplemente escribe:

var myNumber = 2;

myNumber.toFixed(2); //returns "2.00"
myNumber.toFixed(1); //returns "2.0"

etc ...

Encontre un camino. Este es el código de Christoph con una solución:

function toFixed(value, precision) {
    var precision = precision || 0,
        power = Math.pow(10, precision),
        absValue = Math.abs(Math.round(value * power)),
        result = (value < 0 ? '-' : '') + String(Math.floor(absValue / power));

    if (precision > 0) {
        var fraction = String(absValue % power),
            padding = new Array(Math.max(precision - fraction.length, 0) + 1).join('0');
        result += '.' + padding + fraction;
    }
    return result;
}

Lea los detalles de la repetición de un carácter usando un constructor de matriz aquí si tiene curiosidad por saber por qué agregué el "+ 1".

Siempre hay una mejor manera de hacer las cosas.

var number = 51.93999999999761;

Me gustaría obtener una precisión de cuatro dígitos: 51,94

solo haz:

number.toPrecision(4);

el resultado será: 51,94

Método de redondeo similar a PHP

El siguiente código se puede usar para agregar su propia versión de Math.round a su propio espacio de nombres que toma un parámetro de precisión. A diferencia del redondeo decimal en el ejemplo anterior, este no realiza conversión hacia y desde cadenas, y el parámetro de precisión funciona de la misma manera que PHP y Excel, por lo que un 1 positivo se redondearía a 1 lugar decimal y -1 se redondearía a las decenas.

var myNamespace = {};
myNamespace.round = function(number, precision) {
    var factor = Math.pow(10, precision);
    var tempNumber = number * factor;
    var roundedTempNumber = Math.round(tempNumber);
    return roundedTempNumber / factor;
};

myNamespace.round(1234.5678, 1); // 1234.6
myNamespace.round(1234.5678, -1); // 1230

de la referencia de desarrollador de Mozilla para Math.round ()

Con suerte, código de trabajo (no hice muchas pruebas):

function toFixed(value, precision) {
    var precision = precision || 0,
        neg = value < 0,
        power = Math.pow(10, precision),
        value = Math.round(value * power),
        integral = String((neg ? Math.ceil : Math.floor)(value / power)),
        fraction = String((neg ? -value : value) % power),
        padding = new Array(Math.max(precision - fraction.length, 0) + 1).join('0');

    return precision ? integral + '.' +  padding + fraction : integral;
}

Creo que la siguiente función puede ayudar

function roundOff(value,round) {
   return (parseInt(value * (10 ** (round + 1))) - parseInt(value * (10 ** round)) * 10) > 4 ? (((parseFloat(parseInt((value + parseFloat(1 / (10 ** round))) * (10 ** round))))) / (10 ** round)) : (parseFloat(parseInt(value * (10 ** round))) / ( 10 ** round));
}

uso: roundOff(600.23458,2);volverá600.23

Esto funciona para redondear a N dígitos (si solo desea truncar a N dígitos, elimine la llamada Math.round y use la Math.trunc):

function roundN(value, digits) {
   var tenToN = 10 ** digits;
   return /*Math.trunc*/(Math.round(value * tenToN)) / tenToN;
}

Tuve que recurrir a esa lógica en Java en el pasado cuando estaba creando componentes de E-Slate de manipulación de datos . Eso es porque descubrí que agregando 0.1 muchas veces a 0 terminaría con una parte decimal inesperadamente larga (esto se debe a la aritmética de punto flotante).

Un comentario de usuario en Número de formato para mostrar siempre 2 lugares decimales llama a esta técnica escalado.

Algunos mencionan que hay casos que no se redondean como se esperaba y en http://www.jacklmoore.com/notes/rounding-in-javascript/ esto se sugiere en su lugar:

function round(value, decimals) {
  return Number(Math.round(value+'e'+decimals)+'e-'+decimals);
}

Si realmente no le importa el redondeo, simplemente agregue un toFixed (x) y luego elimine los ceros finales y el punto si es necesario. No es una solución rápida.

function format(value, decimals) {
    if (value) {
        value = value.toFixed(decimals);            
    } else {
        value = "0";
    }
    if (value.indexOf(".") < 0) { value += "."; }
    var dotIdx = value.indexOf(".");
    while (value.length - dotIdx <= decimals) { value += "0"; } // add 0's

    return value;
}