Remover zeros à direita insignificantes de um número?

Eu perdi uma chamada de API padrão que remove zeros insignificantes à direita de um número?

Ex.

var x = 1.234000 // to become 1.234; var y = 1.234001; // stays 1.234001 

Number.toFixed () e Number.toPrecision () não são exatamente o que eu estou procurando.

Se você convertê-lo em uma string, ele não exibirá nenhum zeros à direita, que não são armazenados na variável desde que ele foi criado como um Number, não como uma String.

 var n = 1.245000 var noZeroes = n.toString() // "1.245" 

Eu tive um exemplo semelhante, onde eu queria usar .toFixed() quando necessário, mas eu não queria o preenchimento quando não era. Então acabei usando parseFloat em conjunto com toFixed.

toFixed sem preenchimento

 parseFloat(n.toFixed(4)); 

Outra opção que faz quase a mesma coisa
Esta resposta pode ajudar sua decisão

 Number(n.toFixed(4)); 

toFixed / preencherá o número em um tamanho específico, mas também o converterá em uma string. Converter isso de volta para um tipo numérico não apenas tornará o número mais seguro para usar aritmeticamente, mas também automaticamente derrubará qualquer um dos 0s à direita. Por exemplo:

 var n = "1.234000"; n = parseFloat(n); // n is 1.234 and in number form 

Porque mesmo se você definir um número com zeros à direita, ele é descartado.

 var n = 1.23000; // n == 1.23; 

Eu usei pela primeira vez uma combinação de respostas de matti-lyra e gary:

 r=(+n).toFixed(4).replace(/\.0+$/,'') 

Resultados:

  • 1234870.98762341: “1234870.9876”
  • 1230009100: “1230009100”
  • 0,0012234: “0,0012”
  • 0.1200234: “0.12”
  • 0,000001231: “0”
  • 0,10001: “0,1000”
  • “asdf”: “NaN” (portanto, nenhum erro de tempo de execução)

O caso um pouco problemático é 0,10001. Acabei usando esta versão mais longa:

  r = (+n).toFixed(4); if (r.match(/\./)) { r = r.replace(/\.?0+$/, ''); } 
  • 1234870.98762341: “1234870.9876”
  • 1230009100: “1230009100”
  • 0,0012234: “0,0012”
  • 0.1200234: “0.12”
  • 0,000001231: “0”
  • 0,10001: “0,1”
  • “asdf”: “NaN” (portanto, nenhum erro de tempo de execução)

Atualização : E esta é a versão mais nova de Gary (veja os comentários):

 r=(+n).toFixed(4).replace(/([0-9]+(\.[0-9]+[1-9])?)(\.?0+$)/,'$1') 

Isso dá os mesmos resultados acima.

O método toFixed fará o arredondamento apropriado, se necessário. Ele também adicionará zeros à direita, o que nem sempre é ideal.

 (4.55555).toFixed(2); //-> "4.56" (4).toFixed(2); //-> "4.00" 

Se você converter o valor de retorno para um número, esses zeros à direita serão descartados. Essa é uma abordagem mais simples do que fazer sua própria matemática de arredondamento ou truncamento.

 +(4.55555).toFixed(2); //-> 4.56 +(4).toFixed(2); //-> 4 

Eu precisava resolver esse problema também quando o Django estava exibindo valores do tipo Decimal em um campo de texto. Por exemplo, quando “1” era o valor. Mostraria ‘1.00000000’. Se ‘1.23’ fosse o valor, ele mostraria ‘1.23000000’ (no caso de uma configuração ‘decimal_places’ de 8)

Usar o parseFloat não era uma opção para mim, pois é possível que ele não retorne exatamente o mesmo valor. toFixed não era uma opção, já que eu não queria arredondar nada, então criei uma function:

 function removeTrailingZeros(value) { value = value.toString(); # if not containing a dot, we do not need to do anything if (value.indexOf('.') === -1) { return value; } # as long as the last character is a 0 or a dot, remove it while((value.slice(-1) === '0' || value.slice(-1) === '.') && value.indexOf('.') !== -1) { value = value.substr(0, value.length - 1); } return value; } 

Eu tinha basicamente o mesmo requisito e descobri que não há mecanismo interno para essa funcionalidade.

Além de aparar os zeros à direita, também tenho a necessidade de arredondar e, opcionalmente, formatar a saída para a localidade atual do usuário (ou seja, 123.456.789).

Todo o meu trabalho sobre isso foi incluído como prettyFloat.js (MIT Licensed) no GitHub: https://github.com/dperish/prettyFloat.js


Exemplos de uso:

 prettyFloat(1.111001, 3) // "1.111" prettyFloat(1.111001, 4) // "1.111" prettyFloat(1.1111001, 5) // "1.1111" prettyFloat(1234.5678, 2) // "1234.57" prettyFloat(1234.5678, 2, true) // "1,234.57" (en-us) 


Atualizado em agosto de 2018


Todos os navegadores modernos agora suportam a ECMAScript Internationalization API , que fornece comparação de strings sensíveis a idiomas, formatação de números e formatação de data e hora.

 let formatters = { default: new Intl.NumberFormat(), currency: new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD', minimumFractionDigits: 0, maximumFractionDigits: 0 }), whole: new Intl.NumberFormat('en-US', { style: 'decimal', minimumFractionDigits: 0, maximumFractionDigits: 0 }), oneDecimal: new Intl.NumberFormat('en-US', { style: 'decimal', minimumFractionDigits: 1, maximumFractionDigits: 1 }), twoDecimal: new Intl.NumberFormat('en-US', { style: 'decimal', minimumFractionDigits: 2, maximumFractionDigits: 2 }) }; formatters.twoDecimal.format(1234.5678); // result: "1,234.57" formatters.currency.format(28761232.291); // result: "$28,761,232" 

Para navegadores mais antigos, você pode usar este polyfill: https://cdn.polyfill.io/v2/polyfill.min.js?features=Intl.~locale.en

Nenhuma dessas soluções funcionou para mim em números muito pequenos. http://numeraljs.com/ resolveu isso para mim.

 parseFloat(0.00000001.toFixed(8)); // 1e-8 numeral(0.00000001).format('0[.][00000000]'); // "0.00000001" 

Aqui está uma solução possível:

 var x = 1.234000 // to become 1.234; var y = 1.234001; // stays 1.234001 eval(x) --> 1.234 eval(y) --> 1.234001 

Que tal multiplicar por um assim?

 var x = 1.234000*1; // becomes 1.234 var y = 1.234001*1; // stays as 1.234001 

Apenas uma simples alternativa matemática para usar toFixed

 function truncateNumber( num, precision ){ let c = Math.pow(10,precision); return Math.trunc( num*c )/c; } console.log( truncateNumber(1234.5678, 4) ); console.log( truncateNumber(1234.56, 4) );