Remover zeros à direita insignificantes de um número?

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

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

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

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

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

toFixedarredondará / preencherá o número em um comprimento específico, mas também o converterá em uma sequência. Converter isso de volta para um tipo numérico não apenas tornará o número mais seguro para usar aritmeticamente, mas também eliminará automaticamente os 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, eles serão descartados.

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

Eu usei uma combinação das 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 tanto 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 recente de Gary (ver comentários):

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

Isso fornece os mesmos resultados acima.

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

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

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

Se você converter o valor de retorno para um número, os zeros à direita serão eliminados. 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 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 tive a necessidade de arredondar e 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 licenciado) 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 - agosto de 2018

Todos os navegadores modernos agora oferecem suporte à API de Internacionalização do ECMAScript , que fornece comparação de strings sensíveis ao idioma, 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

Que tal apenas multiplicar por um como este?

var x = 1.234000*1; // becomes 1.234

var y = 1.234001*1; // stays as 1.234001

Você pode tentar este para reduzir números flutuantes

var n = 0.0000;
n = parseFloat(n.toString()); 

//output n = 0; 
// n = 3.14000; --> n = 3.14;

Resposta regex pura

n.replace(/(\.[0-9]*[1-9])0+$|\.0*$/,'$1');

Eu me pergunto por que ninguém deu um!

Eu também precisava resolver esse problema quando o Django estava exibindo valores de tipo decimal em um campo de texto. Por exemplo, quando '1' era o valor. Ele mostraria '1.00000000'. Se '1,23' fosse o valor, ele mostraria '1,23000000' (no caso de uma configuração de 'decimal_places' de 8)

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

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

Nenhuma dessas soluções funcionou para mim por 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"

Se você não puder usar flutuadores por qualquer motivo (como dinheiro envolvido) e já estiver iniciando a partir de uma sequência que representa um número correto, poderá encontrar esta solução útil. Ele converte uma string representando um número em uma string representando o número sem zeros à direita.

function removeTrailingZeroes( strAmount ) {
    // remove all trailing zeroes in the decimal part
    var strDecSepCd = '.'; // decimal separator
    var iDSPosition = strAmount.indexOf( strDecSepCd ); // decimal separator positions
    if ( iDSPosition !== -1 ) {
        var strDecPart = strAmount.substr( iDSPosition ); // including the decimal separator

        var i = strDecPart.length - 1;
        for ( ; i >= 0 ; i-- ) {
            if ( strDecPart.charAt(i) !== '0') {
                break;
            }
        }

        if ( i=== 0 ) {
            return strAmount.substring(0, iDSPosition);
        } else {
            // return INTPART and DS + DECPART including the rightmost significant number
            return strAmount.substring(0, iDSPosition) + strDecPart.substring(0,i + 1);
        }
    }

    return strAmount;
}

Depois de ler todas as respostas - e comentários - acabei com isso:

function isFloat(n) {
    let number = (Number(n) === n && n % 1 !== 0) ? eval(parseFloat(n)) : n;
    return number;
}

Eu sei que o uso evalpode ser prejudicial de alguma forma, mas isso me ajudou muito.

Assim:

isFloat(1.234000);     // = 1.234;
isFloat(1.234001);     // = 1.234001
isFloat(1.2340010000); // = 1.234001

Se você deseja limitar as casas decimais, use toFixed()como as outras pessoas apontaram.

let number = (Number(n) === n && n % 1 !== 0) ? eval(parseFloat(n).toFixed(3)) : n;

É isso aí.

Eu precisava remover quaisquer zeros à direita, mas manter pelo menos 2 casas decimais, incluindo zeros.
Os números com os quais estou trabalhando são seis seqüências de números decimais, geradas por .toFixed (6).

Resultado esperado:

var numstra = 12345.000010 // should return 12345.00001
var numstrb = 12345.100000 // should return 12345.10
var numstrc = 12345.000000 // should return 12345.00
var numstrd = 12345.123000 // should return 12345.123

Solução:

var numstr = 12345.100000

while (numstr[numstr.length-1] === "0") {           
    numstr = numstr.slice(0, -1)
    if (numstr[numstr.length-1] !== "0") {break;}
    if (numstr[numstr.length-3] === ".") {break;}
}

console.log(numstr) // 12345.10

Lógica:

Execute a função de loop se o último caractere da cadeia for zero.
Remova o último caractere e atualize a variável de sequência.
Se o último caractere da string atualizada não for zero, termine o loop.
Se a sequência atualizada do terceiro ao último caractere for um ponto flutuante, termine o loop.

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