Formate o número para sempre mostrar 2 casas decimais

Gostaria de formatar meus números para exibir sempre duas casas decimais, arredondando, quando aplicável.

Exemplos:

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

Eu tenho usado isso:

parseFloat(num).toFixed(2);

Mas está exibindo 1como 1, e não 1.00.

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

Demonstração ao 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>

Observe que ele arredondará para 2 casas decimais; portanto, a entrada 1.346retornará 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 resposta falhará se value = 1.005.

Como uma solução melhor, o problema de arredondamento pode ser evitado usando números representados na notação exponencial:

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

Código mais limpo, conforme sugerido por @Kon, e o autor original:

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

Você pode adicionar toFixed()no final para reter o ponto decimal, por exemplo: 1.00mas observe que ele retornará como string.

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

Crédito: Arredondar decimais em 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 o arredondamento mais preciso, crie esta função:

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

e use-o para arredondar para duas casas decimais:

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

Graças a Razu , este artigo, e a referência Math.round do MDN .

Para navegadores modernos, use toLocaleString:

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

Especifique uma tag de localidade como primeiro parâmetro para controlar o separador decimal . Para um ponto, use, por exemplo, localidade em inglês dos EUA:

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

que dá:

1,35

A maioria dos países da Europa usa vírgula como separador decimal; portanto, se você usa, por exemplo, o código de idioma sueco / sueco:

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

vai dar:

1,35

Resposta mais simples:

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

Exemplo: http://jsfiddle.net/E2XU7/

Uma solução muito mais genérica para arredondar para N locais

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

Se você já usa o jQuery, pode usar o plug-in jQuery Number Format .

O plug-in pode retornar números formatados como uma seqüência de caracteres, você pode definir separadores decimais e milhares e pode escolher o número de decimais a serem exibidos.

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

Você também pode obter o formato de número jQuery no GitHub .

É isto que você quer dizer?

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>

Converta um número em uma string, mantendo apenas duas casas decimais:

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

O resultado de n será:

5.57

Você está procurando andar?

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

Aqui também está uma função genérica que pode formatar para qualquer número de casas decimais:

function numberFormat(val, decimalPlaces) {

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

Onde formatação específica é necessária, você deve escrever sua própria rotina ou usar uma função de biblioteca que faça o que você precisa. A funcionalidade básica do ECMAScript geralmente é insuficiente para exibir números formatados.

Uma explicação completa sobre arredondamento e formatação está aqui: http://www.merlyn.demon.co.uk/js-round.htm#RiJ

Como regra geral, o arredondamento e a formatação devem ser executados apenas como uma última etapa antes da saída. Fazer isso antes pode introduzir erros inesperadamente grandes e destruir a formatação.

Basta correr para este de fio mais longo, abaixo está a minha solução:

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

Deixe-me saber se alguém pode fazer um buraco

Você não está nos dando uma imagem completa.

javascript:alert(parseFloat(1).toFixed(2))mostra 1,00 nos navegadores quando colo na barra de localização. No entanto, se você fizer algo posteriormente, ele será revertido.

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

Eu tive que decidir entre as conversões parseFloat () e Number () antes de poder fazer a chamada toFixed (). Aqui está um exemplo de uma formatação de número de entrada de usuário pós-captura.

HTML:

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

Manipulador de eventos:

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

O código acima resultará na exceção TypeError. Observe que, embora o tipo de entrada html seja "number", a entrada do usuário é realmente um tipo de dados "string". No entanto, a função toFixed () pode ser invocada apenas em um objeto que é um número.

Meu código final teria a seguinte aparência:

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

A razão pela qual eu prefiro converter com Number () vs. parseFloat () é porque não preciso executar uma validação extra nem para uma sequência de entrada vazia nem para o valor NaN. A função Number () manipularia automaticamente uma string vazia e a zeraria.

Eu gosto:

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

Arredonde o número com 2 casas decimais e, em seguida, analise-o parseFloat() para retornar Number, não String, a menos que você não se importe se é String ou Number.

Estenda o objeto Math com o método de precisão

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; trabalhou para mim.

aqui está outra solução para arredondar apenas o piso, ou seja, garantir que o valor calculado não seja maior que o valor original (às vezes necessário para transações):

Math.floor(num* 100 )/100;

Você pode tentar 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

Experimente o código abaixo:

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")

É assim que eu resolvo meu problema:

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