redondeo - Javascript: formatear un número redondeado a N decimales

redondeo decimal javascript

Question

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

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

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

¿Algunas ideas?

Answer 1

Método de redondeo similar al PHP

El siguiente código se puede usar para agregar su propia versión de Math.round a su propio espacio de nombres, el cual toma un parámetro de precisión. A diferencia del redondeo decimal en el ejemplo anterior, esto no realiza conversiones 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 redondearía a 1 lugar decimal y -1 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 Mozilla Developer reference para Math.round ()

Answer 2

Aquí hay un enlace a un sprintf de Javascript,

http://www.webtoolkit.info/javascript-sprintf.html

Una llamada a sprintf () es una metodología de redondeo en perl, pero javascript no tiene esa función de forma nativa.

http://perldoc.perl.org/functions/sprintf.html

¿Eso ayuda?

Answer 3

Creo que debajo de la 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); devolverá 600.23

Answer 4

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 ...

Answer 5

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;
}

Lee los detalles de repetir un personaje usando un constructor de matriz here si tienes curiosidad sobre por qué agregué el "+1".

Answer 6

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 el mismo que 2.0000000000000. Es cuando convierte el valor redondeado en una cadena que tiene que mostrar una cierta cantidad de dígitos.

Podrías simplemente agregar ceros después del número, algo así 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 utiliza el período como separador decimal, el código necesita más trabajo para funcionar para otras configuraciones).

Answer 7

Esperemos que funcione el código (no hizo 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;
}

Answer 8

Si realmente no le interesa el redondeo, simplemente agregue una a Fija (x) y luego elimine los puntos 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;
}

Answer 9

Siempre hay una mejor manera de hacer las cosas.

var number = 51.93999999999761;

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

solo haz:

number.toPrecision(4);

el resultado será: 51.94