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

Question

Ich möchte in JavaScript einen Float in eine ganze Zahl umwandeln. Eigentlich würde ich gerne wissen, wie man BEIDE Standardkonvertierungen durchführt: durch Abschneiden und Runden. Und effizient, nicht über die Umwandlung in eine Zeichenfolge und Parsing.

Answer 1

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 auf ein mathematisches Objekt

---

Beispiele

Positiv

// value=x        //  x=5          5<x<5.5      5.5<=x<6  

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

Negativ

// value=x        // x=-5         -5>x>=-5.5   -5.5>x>-6

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

Positiv - Größere Zahlen

// x = Number.MAX_SAFE_INTEGER/10 // =900719925474099.1

// value=x            x=900719925474099    x=900719925474099.4  x=900719925474099.5

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

Negativ - Größere Zahlen

// x = Number.MAX_SAFE_INTEGER/10 * -1 // -900719925474099.1

// value = x      // x=-900719925474099   x=-900719925474099.5 x=-900719925474099.6

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

Answer 2

Bitweiser OR-Operator

Ein bitweiser oder Operator kann verwendet werden, um Fließkommazahlen abzuschneiden, und er 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 JSPerf-Test die die Leistung zwischen vergleicht:

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

die nur mit positiven Zahlen funktioniert. In diesem Fall sind Sie sicher, dass Sie bitweise Operationen ebenso verwenden können wie Math.floor Funktion.

Aber wenn Sie Ihren Code brauchen, um sowohl mit positiven als auch mit negativen Aspekten arbeiten dann ist eine bitweise Operation am schnellsten (OR ist die bevorzugte). Dieser andere JSPerf-Test vergleicht dasselbe, wobei es ziemlich offensichtlich ist, dass aufgrund der zusätzlichen Zeichenprüfung Mathe ist jetzt am langsamsten der vier.

Hinweis

Wie in den Kommentaren angegeben, arbeiten die BITWISE-Operatoren mit vorzeichenbehafteten 32-Bit-Ganzzahlen, daher werden große Zahlen umgewandelt, Beispiel:

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

Answer 3

Hinweis: Sie können nicht verwenden Math.floor() als Ersatz für truncate, denn 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);
}

Answer 4

Ein Doppel bitweise nicht Operator kann verwendet werden, um Fließkommazahlen abzuschneiden. Die anderen von Ihnen erwähnten Operationen sind verfügbar über Math.floor , Math.ceil y Math.round .

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

Weitere Einzelheiten mit freundlicher Genehmigung von James Padolsey.

Answer 5

Für truncate:

var intvalue = Math.floor(value);

Für die Runde:

var intvalue = Math.round(value);