Unbedeutende nachgestellte Nullen aus einer Zahl entfernen?

Habe ich einen Standard-API-Aufruf verpasst, bei dem nachfolgende unbedeutende Nullen aus einer Zahl entfernt werden?

Ex.

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

Number.toFixed () und Number.toPrecision () sind nicht ganz das, wonach ich suche.

Wenn Sie es in eine Zeichenfolge konvertieren, werden keine nachgestellten Nullen angezeigt, die nicht in der Variablen gespeichert sind, seit sie als Zahl und nicht als Zeichenfolge erstellt wurden.

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

Ich hatte eine ähnliche Instanz, in der ich sie .toFixed()bei Bedarf verwenden wollte, aber ich wollte die Polsterung nicht, wenn sie nicht vorhanden war. Also habe ich parseFloat in Verbindung mit toFixed verwendet.

toFixed ohne Polsterung

parseFloat(n.toFixed(4));

Eine weitere Option, die fast dasselbe tut.
Diese Antwort kann Ihnen bei Ihrer Entscheidung helfen

Number(n.toFixed(4));

toFixedrundet / füllt die Zahl auf eine bestimmte Länge, konvertiert sie aber auch in eine Zeichenfolge. Wenn Sie dies wieder in einen numerischen Typ konvertieren, wird die arithmetische Verwendung der Zahl nicht nur sicherer, sondern es werden auch automatisch nachfolgende Nullen gelöscht. Beispielsweise:

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

Denn selbst wenn Sie eine Zahl mit nachgestellten Nullen definieren, werden sie gelöscht.

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

Ich habe zuerst eine Kombination aus Matti-Lyra und Garys Antworten verwendet:

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

Ergebnisse:

• 1234870.98762341: 1234870.9876
• 1230009100: "1230009100"
• 0,0012234: 0,0012
• 0,1200234: 0,12
• 0,000001231: "0"
• 0,10001: 0,1000
• "asdf": "NaN" (also kein Laufzeitfehler)

Der etwas problematische Fall ist 0.10001. Am Ende habe ich diese längere Version verwendet:

    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" (also kein Laufzeitfehler)

Update : Und dies ist Garys neuere Version (siehe Kommentare):

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

Dies ergibt die gleichen Ergebnisse wie oben.

Die toFixedMethode führt bei Bedarf die entsprechende Rundung durch. Es werden auch nachgestellte Nullen hinzugefügt, was nicht immer ideal ist.

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

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

Wenn Sie den Rückgabewert in eine Zahl umwandeln, werden diese nachgestellten Nullen gelöscht. Dies ist ein einfacherer Ansatz als Ihre eigene Rundungs- oder Kürzungsmathematik.

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

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

Ich hatte im Grunde die gleiche Anforderung und stellte fest, dass es für diese Funktionalität keinen eingebauten Mechanismus gibt.

Zusätzlich zum Trimmen der nachfolgenden Nullen musste ich auch die Ausgabe für das aktuelle Gebietsschema des Benutzers (dh 123.456.789) abrunden und formatieren.

Alle meine Arbeiten dazu wurden als prettyFloat.js (MIT Licensed) auf GitHub aufgenommen: https://github.com/dperish/prettyFloat.js

Anwendungsbeispiele:

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)

Aktualisiert - August 2018

Alle modernen Browser unterstützen jetzt die ECMAScript Internationalization API , die sprachempfindlichen Zeichenfolgenvergleich, Zahlenformatierung sowie Datums- und Uhrzeitformatierung bietet.

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"

Für ältere Browser können Sie diese Polyfüllung verwenden: https://cdn.polyfill.io/v2/polyfill.min.js?features=Intl.~locale.en

Wie wäre es einfach mit einem solchen zu multiplizieren?

var x = 1.234000*1; // becomes 1.234

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

Sie können dies versuchen, um schwebende Zahlen zu minimieren

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

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

Reine Regex-Antwort

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

Ich frage mich, warum niemand einen gegeben hat!

Ich musste dieses Problem auch lösen, als Django Werte vom Typ Dezimal in einem Textfeld anzeigte. ZB wenn '1' der Wert war. Es würde '1.00000000' anzeigen. Wenn '1.23' der Wert wäre, würde '1.23000000' angezeigt (im Fall einer Einstellung von 'decimal_places' von 8)

Die Verwendung von parseFloat war für mich keine Option, da möglicherweise nicht genau derselbe Wert zurückgegeben wird. toFixed war keine Option, da ich nichts runden wollte, also habe ich eine Funktion erstellt:

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

Keine dieser Lösungen hat bei mir für sehr kleine Stückzahlen funktioniert. http://numeraljs.com/ hat das für mich gelöst.

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

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

Wenn Sie Floats aus irgendeinem Grund nicht verwenden können (z. B. bei Geld-Floats) und bereits von einer Zeichenfolge ausgehen, die eine korrekte Zahl darstellt, ist diese Lösung möglicherweise hilfreich. Es konvertiert eine Zeichenfolge, die eine Zahl darstellt, in eine Zeichenfolge, die eine Zahl ohne nachgestellte Nullen darstellt.

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

Nachdem ich alle Antworten - und Kommentare - gelesen hatte, kam ich zu folgendem Ergebnis:

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

Ich weiß mit eval irgendwie schädlich sein kann, aber das hat mir sehr geholfen.

So:

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

Wenn Sie die Dezimalstellen begrenzen möchten, verwenden Sie, toFixed()wie in anderen angegeben.

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

Das ist es.

Ich musste alle nachgestellten Nullen entfernen, aber mindestens 2 Dezimalstellen, einschließlich aller Nullen , beibehalten.
Die Zahlen, mit denen ich arbeite, sind 6 Dezimalzahlen, die von .toFixed (6) generiert werden.

Erwartetes Ergebnis:

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

Lösung:

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

Logik:

Führen Sie die Schleifenfunktion aus, wenn das letzte Zeichen der Zeichenfolge eine Null ist.
Entfernen Sie das letzte Zeichen und aktualisieren Sie die Zeichenfolgenvariable.
Wenn das letzte Zeichen der aktualisierten Zeichenfolge keine Null ist, beenden Sie die Schleife.
Wenn die aktualisierte Zeichenfolge des vorletzten Zeichens eine Gleitkomma-Endschleife ist.

Hier ist eine mögliche Lösung:

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

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

Nur eine einfache mathematische Alternative zur Verwendung toFixed

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