it-swarm.com.de

Unbedeutende nachfolgende Nullen aus einer Zahl entfernen?

Habe ich einen Standard-API-Aufruf verpasst, bei dem nachgestellte 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.

111
Steven

Wenn Sie es in einen String konvertieren, werden keine nachgestellten Nullen angezeigt, die nicht in der Variablen gespeichert werden, da sie als Zahl und nicht als String erstellt wurden.

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

Ich hatte ein ähnliches Beispiel, wo ich .toFixed() wo nötig verwenden wollte, aber ich wollte die Polsterung nicht, wenn es nicht war. Also habe ich parseFloat in Verbindung mit toFixed verwendet.

toFixed ohne Auffüllen

parseFloat(n.toFixed(4));

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

Number(n.toFixed(4));

toFixed wird die Zahl auf eine bestimmte Länge runden/auffüllen, sie aber auch in einen String umwandeln. Wenn Sie diese Zahl wieder in einen numerischen Typ umwandeln, wird die Zahl nicht nur sicherer für die Verwendung von Arithmetik, sondern auch die nachfolgenden Nullen werden automatisch gelöscht. Zum Beispiel:

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;
169
Gary

Ich habe zuerst eine Kombination von 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. Ich habe 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.

21
w00t

Die toFixed-Methode führt gegebenenfalls die entsprechende Rundung durch. Es werden auch nachfolgende 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 eine einfachere Methode, als Ihre eigene Rundungs- oder Verkürzungsberechnung durchzuführen.

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

+(4).toFixed(2);
//-> 4
9
C. J.

Ich musste dieses Problem auch lösen, als Django Dezimalwerte in einem Textfeld anzeigt. Z.B. wenn '1' der Wert war. Es würde '1.00000000' anzeigen. Wenn "1.23" der Wert ist, würde "1.23000000" angezeigt werden (im Falle einer "decimal_places" -Einstellung von 8).

Die Verwendung von parseFloat war für mich keine Option, da es möglich ist, dass nicht der gleiche Wert zurückgegeben wird. toFixed war keine Option, da ich nichts abrunden wollte, also 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;
}
6
megasnort

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

Zusätzlich zum Abgleich der nachgestellten Nullen muss ich die Ausgabe für das aktuelle Gebietsschema des Benutzers abrunden und optional formatieren (d. H. 123.456.789).

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 sprachabhängige Zeichenfolgenvergleiche, Zahlenformate und Datums- und Uhrzeitformatierungen 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"

Bei älteren Browsern können Sie diese Funktion verwenden: https://cdn.polyfill.io/v2/polyfill.min.js?features=Intl.~locale.de

4
dperish

Wie wäre es nur mit einem solchen multiplizieren?

var x = 1.234000*1; // becomes 1.234

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

Keine dieser Lösungen funktionierte für mich bei sehr kleinen Stückzahlen. http://numeraljs.com/ hat dies für mich gelöst.

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

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

Reine Regex-Antwort

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

Ich wundere mich, warum niemand einen gab!

1
João Costa

Sie können dieses versuchen, um gleitende Zahlen zu minimieren

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

//output n = 0; 
// n = 3.14000; --> n = 3.14;
1
Amit Panasara

Wenn Sie Floats aus irgendeinem Grund nicht verwenden können (wie etwa Geldfloats) und bereits mit einer Zeichenfolge beginnen, die eine korrekte Zahl darstellt, könnte diese Lösung hilfreich sein. 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;
}
0
BennyHilarious

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

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 das drittletzte Zeichen der aktualisierten Zeichenfolge ein Gleitkomma ist, beenden Sie die Schleife.

0
Kevin H.

Nachdem ich alle Antworten und Kommentare gelesen hatte, endete ich damit:

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

Ich weiß, dass 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 von anderen angegeben.

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

Das ist es.

0
ed1nh0

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
0
Moon