Formatee el número para mostrar siempre 2 lugares decimales

Me gustaría formatear mis números para que siempre muestren 2 decimales, redondeando donde corresponda.

Ejemplos:

number     display
------     -------
1          1.00
1.341      1.34
1.345      1.35

He estado usando esto:

parseFloat(num).toFixed(2);

Pero se muestra 1como 1, en lugar de 1.00.

(Math.round(num * 100) / 100).toFixed(2);

Demo en vivo

var num1 = "1";
document.getElementById('num1').innerHTML = (Math.round(num1 * 100) / 100).toFixed(2);

var num2 = "1.341";
document.getElementById('num2').innerHTML = (Math.round(num2 * 100) / 100).toFixed(2);

var num3 = "1.345";
document.getElementById('num3').innerHTML = (Math.round(num3 * 100) / 100).toFixed(2);

span {
    border: 1px solid #000;
    margin: 5px;
    padding: 5px;
}

<span id="num1"></span>
<span id="num2"></span>
<span id="num3"></span>

Tenga en cuenta que se redondeará a 2 decimales, por lo que la entrada 1.346volverá 1.35.

Number(1).toFixed(2);         // 1.00
Number(1.341).toFixed(2);     // 1.34
Number(1.345).toFixed(2);     // 1.34 NOTE: See andy's comment below.
Number(1.3450001).toFixed(2); // 1.35

document.getElementById('line1').innerHTML = Number(1).toFixed(2);
document.getElementById('line2').innerHTML = Number(1.341).toFixed(2);
document.getElementById('line3').innerHTML = Number(1.345).toFixed(2);
document.getElementById('line4').innerHTML = Number(1.3450001).toFixed(2);

<span id="line1"></span>
<br/>
<span id="line2"></span>
<br/>
<span id="line3"></span>
<br/>
<span id="line4"></span>

Esta respuesta fallará sivalue = 1.005 .

Como una mejor solución, el problema de redondeo se puede evitar utilizando números representados en notación exponencial:

Number(Math.round(1.005+'e2')+'e-2'); // 1.01

Código más limpio como lo sugiere @Kon, y el autor original:

Number(Math.round(parseFloat(value + 'e' + decimalPlaces)) + 'e-' + decimalPlaces)

Puede agregar toFixed()al final para retener el punto decimal, por ejemplo: 1.00pero tenga en cuenta que volverá como una cadena.

Number(Math.round(parseFloat(value + 'e' + decimalPlaces)) + 'e-' + decimalPlaces).toFixed(decimalPlaces)

Crédito: redondeando decimales en JavaScript

var num = new Number(14.12);
console.log(num.toPrecision(2));//outputs 14
console.log(num.toPrecision(3));//outputs 14.1
console.log(num.toPrecision(4));//outputs 14.12
console.log(num.toPrecision(5));//outputs 14.120

Para el redondeo más preciso, cree esta función:

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

y úsalo para redondear a 2 decimales:

console.log("seeked to " + round(1.005, 2));
> 1.01

Gracias a Razu , este artículo y la referencia de Math.round de MDN .

Para navegadores modernos, use toLocaleString:

var num = 1.345;
num.toLocaleString(undefined, { maximumFractionDigits: 2, minimumFractionDigits: 2 });

Especifique una etiqueta de configuración regional como primer parámetro para controlar el separador decimal . Para un punto, use, por ejemplo, la configuración regional de inglés de EE. UU .:

num.toLocaleString("en-US", { maximumFractionDigits: 2, minimumFractionDigits: 2 });

lo que da:

1,35

La mayoría de los países de Europa usan una coma como separador decimal, por lo que si, por ejemplo, usa la configuración regional sueca / sueca:

num.toLocaleString("sv-SE", { maximumFractionDigits: 2, minimumFractionDigits: 2 });

dará:

1,35

La respuesta más simple:

var num = 1.2353453;
num.toFixed(2); // 1.24

Ejemplo: http://jsfiddle.net/E2XU7/

Una solución mucho más genérica para redondear a N lugares

function roundN(num,n){
  return parseFloat(Math.round(num * Math.pow(10, n)) /Math.pow(10,n)).toFixed(n);
}


console.log(roundN(1,2))
console.log(roundN(1.34,2))
console.log(roundN(1.35,2))
console.log(roundN(1.344,2))
console.log(roundN(1.345,2))
console.log(roundN(1.344,3))
console.log(roundN(1.345,3))
console.log(roundN(1.3444,3))
console.log(roundN(1.3455,3))

Output

1.00
1.34
1.35
1.34
1.35
1.344
1.345
1.344
1.346

var number = 123456.789;


console.log(new Intl.NumberFormat('en-IN', { maximumFractionDigits: 2 }).format(number));

https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat

Si ya está usando jQuery, puede mirar usando el formato de número jQuery complemento .

El complemento puede devolver números formateados como una cadena, puede establecer separadores decimales y de miles, y puede elegir el número de decimales para mostrar.

$.number( 123, 2 ); // Returns '123.00'

También puede obtener jQuery Number Format de GitHub .

¿Es esto lo que quieres decir?

function showAsFloat(num, n){
      return !isNaN(+num) ? (+num).toFixed(n || 2) : num;
}

document.querySelector('#result').textContent = 
    [
     'command                      | result',
     '-----------------------------------------------',
     'showAsFloat(1);              | ' + showAsFloat(1),
     'showAsFloat(1.314);          | ' + showAsFloat(1.314),
     'showAsFloat(\'notanumber\')    | ' + showAsFloat('notanumber'),
     'showAsFloat(\'23.44567\', 3)   | ' + showAsFloat('23.44567', 3),
     'showAsFloat(2456198, 5)      | ' + showAsFloat('2456198', 5),
     'showAsFloat(0);              | ' + showAsFloat(0)
    ].join('\n');

<pre id="result"></pre>

Convierta un número en una cadena, manteniendo solo dos decimales:

var num = 5.56789;
var n = num.toFixed(2);

El resultado de n será:

5.57

¿Buscas piso?

var num = 1.42482;
var num2 = 1;
var fnum = Math.floor(num).toFixed(2);
var fnum2 = Math.floor(num2).toFixed(2);
alert(fnum + " and " + fnum2); //both values will be 1.00

function currencyFormat (num) {
    return "$" + num.toFixed(2).replace(/(\d)(?=(\d{3})+(?!\d))/g, "$1,")
}

console.info(currencyFormat(2665));   // $2,665.00
console.info(currencyFormat(102665)); // $102,665.00

Aquí también hay una función genérica que puede formatear cualquier número de decimales:

function numberFormat(val, decimalPlaces) {

    var multiplier = Math.pow(10, decimalPlaces);
    return (Math.round(val * multiplier) / multiplier).toFixed(decimalPlaces);
}

Cuando se requiere un formato específico, debe escribir su propia rutina o utilizar una función de biblioteca que haga lo que necesita. La funcionalidad básica de ECMAScript suele ser insuficiente para mostrar números formateados.

Aquí encontrará una explicación detallada del redondeo y el formato: http://www.merlyn.demon.co.uk/js-round.htm#RiJ

Como regla general, el redondeo y el formato solo deben realizarse como un último paso antes de la salida. Hacerlo antes puede introducir errores inesperadamente grandes y destruir el formato.

Simplemente encuentre este hilo más largo, a continuación está mi solución:

parseFloat(Math.round((parseFloat(num * 100)).toFixed(2)) / 100 ).toFixed(2)

Avísame si alguien puede hacer un agujero

No nos estás dando la imagen completa.

javascript:alert(parseFloat(1).toFixed(2))muestra 1.00 en mi navegador cuando lo pego en la barra de ubicación. Sin embargo, si le haces algo después, se revertirá.

var num = 2
document.getElementById('spanId').innerHTML=(parseFloat(num).toFixed(2)-1)


shows 1 and not 1.00

var quantity = 12;

var import1 = 12.55;

var total = quantity * import1;

var answer = parseFloat(total).toFixed(2);

document.write(answer);

Tuve que decidir entre las conversiones parseFloat () y Number () antes de poder hacer la llamada a toFixed (). Aquí hay un ejemplo de un número que formatea la entrada del usuario después de la captura.

HTML:

<input type="number" class="dec-number" min="0" step="0.01" />

Controlador de eventos:

$('.dec-number').on('change', function () {
     const value = $(this).val();
     $(this).val(value.toFixed(2));
});

El código anterior dará como resultado la excepción TypeError. Tenga en cuenta que aunque el tipo de entrada html es "número", la entrada del usuario es en realidad un tipo de datos de "cadena". Sin embargo, la función toFixed () solo se puede invocar en un objeto que es un Número.

Mi código final se vería de la siguiente manera:

$('.dec-number').on('change', function () {
     const value = Number($(this).val());
     $(this).val(value.toFixed(2));
});

La razón por la que prefiero emitir con Number () vs. parseFloat () es porque no tengo que realizar una validación adicional ni para una cadena de entrada vacía, ni para el valor NaN. La función Number () manejaría automáticamente una cadena vacía y la convertiría a cero.

Si me gusta:

var num = 12.749;
parseFloat((Math.round(num * 100) / 100).toFixed(2)); // 123.75

Redondea el número con 2 puntos decimales, luego asegúrate de analizarlo parseFloat() para devolver Número, no Cadena, a menos que no te importe si es Cadena o Número.

Extender objeto matemático con método de precisión

Object.defineProperty(Math, 'precision',{
   value: function (value,precision,type){
             var v = parseFloat(value),
                 p = Math.max(precision,0)||0,
                 t = type||'round';
              return (Math[t](v*Math.pow(10,p))/Math.pow(10,p)).toFixed(p);
          }
    });

console.log(
    Math.precision(3.1,3), // round 3 digits 
    Math.precision(0.12345,2,'ceil'), // ceil 2 digits
    Math.precision(1.1) // integer part
)

parseInt(number * 100) / 100; trabajó para mi.

Aquí hay otra solución para redondear solo usando piso, es decir, asegurarse de que la cantidad calculada no sea mayor que la cantidad original (a veces necesaria para las transacciones):

Math.floor(num* 100 )/100;

Puedes probar este código:

    function FormatNumber(number, numberOfDigits = 2) {
        try {
            return new Intl.NumberFormat('en-US').format(parseFloat(number).toFixed(2));
        } catch (error) {
            return 0;
        }
    }

    var test1 = FormatNumber('1000000.4444');
    alert(test1); // 1,000,000.44

    var test2 = FormatNumber(100000000000.55555555, 4);
    alert(test2); // 100,000,000,000.56

Pruebe el siguiente código:

function numberWithCommas(number) { 

   var newval = parseFloat(Math.round(number * 100) / 100).toFixed(2);

   return newval.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
}

(num + "").replace(/^([0-9]*)(\.[0-9]{1,2})?.*$/,"$1$2")

Así es como resuelvo mi problema:

parseFloat(parseFloat(floatString).toFixed(2));