Supprimer les zéros de fin insignifiants d'un nombre?

Ai-je manqué un appel d'API standard qui supprime les zéros insignifiants de fin d'un nombre?

Ex.

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

Number.toFixed () et Number.toPrecision () ne sont pas tout à fait ce que je recherche.

Si vous le convertissez en chaîne, il n'affichera pas de zéros à la fin, qui ne sont pas stockés dans la variable en premier lieu car il a été créé en tant que nombre, pas en tant que chaîne.

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

J'avais une instance similaire où je voulais utiliser .toFixed()si nécessaire, mais je ne voulais pas le rembourrage quand ce n'était pas le cas. J'ai donc fini par utiliser parseFloat en conjonction avec toFixed.

toFixed sans rembourrage

parseFloat(n.toFixed(4));

Une autre option qui fait presque la même chose
Cette réponse peut vous aider dans votre décision

Number(n.toFixed(4));

toFixedarrondira / complétera le nombre à une longueur spécifique, mais le convertira également en chaîne. La reconversion en un type numérique rendra non seulement le nombre plus sûr à utiliser arithmétiquement, mais supprimera également automatiquement tous les 0 à la fin. Par exemple:

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

Parce que même si vous définissez un nombre avec des zéros à la fin, ils sont supprimés.

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

J'ai d'abord utilisé une combinaison de matti-lyra et de réponses de Gary:

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

Résultats:

• 1234870.98762341: "1234870.9876"
• 1230009100: "1230009100"
• 0,0012234: "0,0012"
• 0.1200234: "0.12"
• 0,000001231: "0"
• 0,10001: «0,1000»
• "asdf": "NaN" (donc pas d'erreur d'exécution)

Le cas quelque peu problématique est 0,10001. J'ai fini par utiliser cette version plus longue:

    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" (donc pas d'erreur d'exécution)

Mise à jour : Et voici la version la plus récente de Gary (voir les commentaires):

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

Cela donne les mêmes résultats que ci-dessus.

La toFixedméthode effectuera l'arrondi approprié si nécessaire. Il ajoutera également des zéros de fin, ce qui n'est pas toujours idéal.

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

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

Si vous convertissez la valeur de retour en un nombre, ces zéros de fin seront supprimés. C'est une approche plus simple que de faire vos propres calculs d'arrondi ou de troncature.

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

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

J'avais fondamentalement la même exigence et j'ai constaté qu'il n'y avait pas de mécanisme intégré pour cette fonctionnalité.

En plus de couper les zéros de fin, j'ai également eu besoin d'arrondir et de formater la sortie pour les paramètres régionaux actuels de l'utilisateur (c'est-à-dire 123 456 789).

Tout mon travail à ce sujet a été inclus sous le nom prettyFloat.js (sous licence MIT) sur GitHub: https://github.com/dperish/prettyFloat.js

Exemples d'utilisation:

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)

Mise à jour - août 2018

Tous les navigateurs modernes prennent désormais en charge l' API ECMAScript Internationalization , qui fournit une comparaison de chaînes sensible à la langue, la mise en forme des nombres et la mise en forme de la date et de l'heure.

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"

Pour les navigateurs plus anciens, vous pouvez utiliser ce polyfill: https://cdn.polyfill.io/v2/polyfill.min.js?features=Intl.~locale.en

Pourquoi ne pas multiplier par un comme ça?

var x = 1.234000*1; // becomes 1.234

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

Vous pouvez essayer celui-ci pour réduire les nombres flottants

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

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

Réponse pure regex

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

Je me demande pourquoi personne n'en a donné!

J'avais également besoin de résoudre ce problème lorsque Django affichait des valeurs de type décimal dans un champ de texte. Par exemple, lorsque «1» était la valeur. Il afficherait «1.00000000». Si '1.23' était la valeur, il afficherait '1.23000000' (dans le cas d'un paramètre 'decimal_places' de 8)

Utiliser parseFloat n'était pas une option pour moi car il est possible qu'il ne renvoie pas exactement la même valeur. toFixed n'était pas une option car je ne voulais rien arrondir, j'ai donc créé une fonction:

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

Aucune de ces solutions n'a fonctionné pour moi pour de très petits nombres. http://numeraljs.com/ a résolu cela pour moi.

parseFloat(0.00000001.toFixed(8));
// 1e-8

numeral(0.00000001).format('0[.][00000000]');
// "0.00000001"

Si vous ne pouvez pas utiliser les flottants pour une raison quelconque (comme les flotteurs d'argent impliqués) et que vous commencez déjà à partir d'une chaîne représentant un nombre correct, vous pouvez trouver cette solution pratique. Il convertit une chaîne représentant un nombre en une chaîne représentant un nombre sans zéros de fin.

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

Après avoir lu toutes les réponses - et commentaires - je me suis retrouvé avec ceci:

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

Je sais que l'utilisation evalpeut être nuisible d'une manière ou d'une autre, mais cela m'a beaucoup aidé.

Alors:

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

Si vous souhaitez limiter les décimales, utilisez toFixed()comme d'autres l'ont indiqué.

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

C'est tout.

J'avais besoin de supprimer tous les zéros de fin, mais gardez au moins 2 décimales, y compris les zéros.
Les nombres avec lesquels je travaille sont 6 chaînes de nombres décimaux, générées par .toFixed (6).

Résultat attendu:

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

Solution:

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

Logique:

Exécutez la fonction de boucle si le dernier caractère de la chaîne est un zéro.
Supprimez le dernier caractère et mettez à jour la variable chaîne.
Si le dernier caractère de la chaîne mise à jour n'est pas un zéro, terminer la boucle.
Si la chaîne mise à jour du troisième au dernier caractère est une virgule flottante, terminer la boucle.

Voici une solution possible:

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

eval(x) --> 1.234
eval(y) --> 1.234001