Frage Wie konvertiere ich eine Fließkommazahl in JavaScript in eine ganze Zahl?


Ich möchte ein Float in JavaScript in eine ganze Zahl konvertieren. Eigentlich würde ich gerne wissen, wie Sie beide Standard-Konvertierungen tun: durch Abschneiden und Runden. Und effizient, nicht durch Umwandlung in eine Zeichenfolge und Parsing.


861
2018-02-27 20:15


Ursprung


Antworten:


var intvalue = Math.floor( floatvalue );
var intvalue = Math.ceil( floatvalue ); 
var intvalue = Math.round( floatvalue );

// `Math.trunc` was added in ECMAScript 6
var intvalue = Math.trunc( floatvalue );

Referenz zum mathematischen Objekt


Beispiele

Positiv
value = 5.5

Math.floor(value) //  5
Math.ceil(value)  //  6
Math.round(value) //  6
Math.trunc(value) //  5
parseInt(value)   //  5
~~value           //  5
value | 0         //  5
value >> 0        //  5
value >>> 0       //  5
value - value % 1 //  5
Negativ
value = -5.5

Math.floor(value) // -6
Math.ceil(value)  // -5
Math.round(value) // -5
Math.trunc(value) // -5
parseInt(value)   // -5
value | 0         // -5
~~value           // -5
value >> 0        // -5
value >>> 0       // 4294967291
value - value % 1 // -5
Positiv - Größere Zahlen
value = Number.MAX_SAFE_INTEGER/10 // 900719925474099.1

Math.floor(value) //  900719925474099
Math.ceil(value)  //  900719925474100
Math.round(value) //  900719925474099
Math.trunc(value) //  900719925474099
parseInt(value)   //  900719925474099
value | 0         //  858993459
~~value           //  858993459
value >> 0        //  858993459
value >>> 0       //  858993459
value - value % 1 //  900719925474099
Negativ - Größere Zahlen
value = Number.MAX_SAFE_INTEGER/10 * -1 // -900719925474099.1

Math.floor(value) // -900719925474100
Math.ceil(value)  // -900719925474099
Math.round(value) // -900719925474099
Math.trunc(value) // -900719925474099
parseInt(value)   // -900719925474099
value | 0         // -858993459
~~value           // -858993459
value >> 0        // -858993459
value >>> 0       //  3435973837
value - value % 1 // -900719925474099

1183
2018-02-27 20:21



Bitweiser OR-Operator

Ein bitweiser Operator kann zum Abschneiden von Fließkommazahlen verwendet werden. Es funktioniert sowohl für positive als auch für negative Werte:

function float2int (value) {
    return value | 0;
}

Ergebnisse

float2int(3.1) == 3
float2int(-3.1) == -3
float2int(3.9) == 3
float2int(-3.9) == -3

Leistungsvergleich?

Ich habe eine erstellt JSPerftest das vergleicht die Leistung zwischen:

  • Math.floor(val)
  • val | 0  bitweise ODER
  • ~~val  bitweise NICHT
  • parseInt(val)

das funktioniert nur mit positiven Zahlen. In diesem Fall können Sie bitweise Operationen problemlos ausführen Math.floor Funktion.

Aber wenn du deinen Code brauchst arbeite sowohl mit positiven als auch mit negativen, dann ist eine bitweise Operation die schnellste (OR ist die bevorzugte). Dieser andere JSPerf-Test vergleicht das gleiche, wo es ziemlich offensichtlich ist, dass wegen der zusätzlichen Zeichenprüfung Mathe ist jetzt am langsamsten von den vier.

Hinweis

Wie in den Kommentaren erwähnt, arbeiten BITWISE-Operatoren mit 32-Bit-Ganzzahlen mit Vorzeichen, daher werden große Zahlen konvertiert, zum Beispiel:

1234567890  | 0 => 1234567890
12345678901 | 0 => -539222987

263
2017-10-11 10:18



Hinweis: Sie können nicht verwenden Math.floor() als Ersatz für truncate, weil Math.floor(-3.1) = -4 und nicht -3 !!

Ein korrekter Ersatz für truncate wäre:

function truncate(value)
{
    if (value < 0) {
        return Math.ceil(value);
    }

    return Math.floor(value);
}

88
2017-10-14 16:17



Ein Doppel bitweise nicht Operator kann zum Abschneiden von Floats verwendet werden. Die anderen von Ihnen erwähnten Operationen sind verfügbar Math.floor, Math.ceil, und Math.round.

> ~~2.5
2
> ~~(-1.4)
-1

Weitere Details mit freundlicher Genehmigung von James Padolsey.


40
2018-01-11 16:54



Zum Abschneiden:

var intvalue = Math.floor(value);

Für Runde:

var intvalue = Math.round(value);

36
2018-02-27 20:22



Du kannst den ... benutzen parseInt Methode für keine Rundung. Seien Sie vorsichtig bei der Benutzereingabe aufgrund der Präfixoptionen 0x (hexadezimal) und 0 (oktal).

var intValue = parseInt(floatValue, 10);

22
2017-09-26 20:41



Bitverschiebung um 0, was einer Division durch 1 entspricht

// >> or >>>
2.0 >> 0; // 2
2.0 >>> 0; // 2

17
2017-07-25 07:33



In Ihrem Fall, wenn Sie am Ende eine Zeichenkette haben möchten (um Kommas einzufügen), können Sie auch einfach die Funktion Number.toFixed () verwenden, dies führt jedoch zu einer Rundung.


7
2017-10-14 16:30



Es gibt viele Vorschläge hier. Das bitweise OR scheint bei weitem das einfachste zu sein. Hier ist eine andere kurze Lösung, die auch mit negativen Zahlen arbeitet, die den Modulo-Operator verwenden. Es ist wahrscheinlich einfacher zu verstehen als das bitweise ODER:

intval = floatval - floatval%1;

Diese Methode funktioniert auch mit hohen Zahlen, bei denen weder '| 0' noch '~~' noch '>> 0' korrekt funktionieren:

> n=4294967295;
> n|0
-1
> ~~n
-1
> n>>0
-1
> n-n%1
4294967295

6
2017-07-11 13:42



Eine weitere Möglichkeit - XOR-Operation verwenden:

console.log(12.3 ^ 0); // 12
console.log("12.3" ^ 0); // 12
console.log(1.2 + 1.3 ^ 0); // 2
console.log(1.2 + 1.3 * 2 ^ 0); // 3
console.log(-1.2 ^ 0); // -1
console.log(-1.2 + 1 ^ 0); // 0
console.log(-1.2 - 1.3 ^ 0); // -2

Die Priorität der bitweisen Operationen ist weniger als die Priorität der mathematischen Operationen, sie ist nützlich. Anprobieren https://jsfiddle.net/au51uj3r/


4
2018-02-28 17:45