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

Ich umwandeln möchte einen float auf eine ganze Zahl, die in JavaScript. Eigentlich würde ich gerne wissen, wie zu tun, SOWOHL von der standard-Konvertierungen: von abschneiden und durch die Rundung. Und effizient, nicht über die Konvertierung in einen string-parsing.

Kommentar zu dem Problem

Wenn Sie nicht wissen, alle zahlen in javascript sind Fließkommazahlen. Aus der Spezifikation: Kommentarautor: some

4.3.20 Anzahl Typ: Die Typ-Nummer ist eine Reihe von Werten, die zahlen. In ECMAScript, der Werte vertritt, die doubleprecision 64-bit format IEEE 754 Werte einschließlich der besonderen "not-a-Number" (NaN) - Werte positiv unendlich und negativ unendlich. Kommentarautor: some

Ja, Javascript muss nicht ein deutliches "integer" - Typ, aber es ist immer noch nicht ungewöhnlich zu müssen, um diese Umwandlung zu tun. Zum Beispiel, in meiner Anwendung der Benutzer tippte eine Nummer ein (ggf. inklusive Cent). Ich hatte zum abschneiden der Cent und display w/ Kommas. Schritt 1 war, um zu konvertieren in int. Kommentarautor: mcherm

auch nützlich: speed-Vergleich aller Methoden jsperf.com/math-floor-vs-math-round-vs-parseint/33 Kommentarautor: c..

@karl: Wenn ich mich annehmen von Eingaben in ein Feld, ich könnte in der Lage sein zu kontrollieren, was die Zeichen, die ich akzeptieren, aber ich könnte es alle Arten der Verarbeitung in Javascript, nicht nur die Annahme von Benutzereingaben. Selbst dann könnte ich wollen, dass es für Dinge wie die Unterstützung einfügen. Kommentarautor: mcherm

InformationsquelleAutor der Frage mcherm | 2009-02-27

javascript syntax

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

Math-Objekt-Referenz

Beispiele

Positive

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

Negative

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 - je Größer die 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

InformationsquelleAutor der Antwort moonshadow

260

Bitweisen ODER-operator

Einer bitweisen oder-operator kann verwendet werden, um truncate floating point zahlen und es funktioniert für positive wie auch negative:
```
function float2int (value) {
    return value | 0;
}
```
Ergebnisse
```
float2int(3.1) == 3
float2int(-3.1) == -3
float2int(3.9) == 3
float2int(-3.9) == -3
```
Performance-Vergleich?

Habe ich einen JSPerf-test, 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 sind Sie sicher zu verwenden bitweise Operationen sowie Math.floor Funktion.

Aber wenn Sie benötigen, Ihren code zu Arbeit mit positiven als auch negativen, dann wird eine bitweise operation ist der Schnellste (ODER bevorzugte). Diese anderen JSPerf-test vergleicht die gleiche, wo ist es ziemlich offensichtlich, dass Sie aufgrund der zusätzlichen Zeichen prüfen Mathe ist jetzt der langsamste der vier.

Hinweis

Wie gesagt in den Kommentaren, BITWEISE Operatoren arbeiten auf signed 32-bit Integer-zahlen, daher große zahlen umgewandelt werden, Beispiel:
```
1234567890  | 0 => 1234567890
12345678901 | 0 => -539222987
```
InformationsquelleAutor der Antwort Robert Koritnik
88

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

Einen richtigen Ersatz für abschneiden würde:
```
function truncate(value)
{
    if (value < 0) {
        return Math.ceil(value);
    }

    return Math.floor(value);
}
```
InformationsquelleAutor der Antwort
40

Doppel Bitweises nicht - operator kann verwendet werden zum abschneiden schwimmt. Die anderen Operationen, die Sie erwähnt sind erhältlich über Math.Boden, Math.ceil, und Math.Runde.
```
> ~~2.5
2
> ~~(-1.4)
-1
```
Mehr details mit freundlicher Genehmigung von James Padolsey.

InformationsquelleAutor der Antwort brad

Für truncate:

var intvalue = Math.floor(value);

Runde:

var intvalue = Math.round(value);

InformationsquelleAutor der Antwort Mike

21

Können Sie die parseInt - Methode für keine Rundung. Seien Sie vorsichtig mit der Benutzer-Eingabe durch die Zeichenfolge " 0x (hex) und 0 (oktal) Präfix-Optionen.
```
var intValue = parseInt(floatValue, 10);
```
InformationsquelleAutor der Antwort Graeme Wicksted
16

Bit-Verschiebung von 0, was gleichbedeutend mit einer division durch 1
```
//>> or >>>
2.0 >> 0; //2
2.0 >>> 0; //2
```
InformationsquelleAutor der Antwort Prasanth
7

In Ihrem Fall, wenn Sie möchten, eine Zeichenfolge in das Ende (in der Reihenfolge einfügen Kommas), Sie können auch verwenden Sie einfach die Anzahl.toFixed () - Funktion, diese wird jedoch führen Rundung.

InformationsquelleAutor der Antwort Russell Leggett
6

Gibt es viele Anregungen hier. Die bitweise ODER-Verknüpfung scheint die einfachste bei weitem. Hier ist eine kurze Lösung, die funktioniert mit negativen zahlen sowie die Verwendung der modulo-operator. Es ist wahrscheinlich einfacher zu verstehen als das bitweise ODER:
```
intval = floatval - floatval%1;
```
Diese Methode funktioniert auch mit dem hohen Wert zahlen, wenn weder '|0' noch '~~' noch '>>0' korrekt:
```
> n=4294967295;
> n|0
-1
> ~~n
-1
> n>>0
-1
> n-n%1
4294967295
```
InformationsquelleAutor der Antwort Juliane Holzt
4

Eine weitere Möglichkeit — verwenden Sie XOR-operation:
```
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
```
Priorität der bitweisen Operationen ist geringer als die Priorität der mathematischen Operationen, ist es nützlich. Versuchen Sie, auf https://jsfiddle.net/au51uj3r/

InformationsquelleAutor der Antwort Dmitry Kharitonov

Zu abschneiden:

//Math.trunc() is part of the ES6 spec
Math.trunc( 1.5 );  //returns 1
Math.trunc( -1.5 ); //returns -1
//Math.floor( -1.5 ) would return -2, which is probably not what you wanted

Zu Runde:

Math.round( 1.5 );  //2
Math.round( 1.49 ); //1
Math.round( -1.6 ); //-2
Math.round( -1.3 ); //-1

InformationsquelleAutor der Antwort Razor

1

Wenn Sie mit angularjs dann einfache Lösung wie folgt In HTML-Template-Bindung

{{val | number:0}}

wird es konvertiert val in integer

gehen Sie durch mit diesem link docs.angularjs.org/api/ng/filter/number

InformationsquelleAutor der Antwort Jameel Grand
0

Ich möchte nur darauf hinweisen, dass monetär aus, die Sie abrunden möchten, und nicht kürzen. Wird ein penny ist viel weniger wahrscheinlich, da 4.999452 * 100 gerundet wird Ihnen 5, eine weitere repräsentative Antwort.

Obendrein, vergessen Sie nicht über banker ' s rounding, das ist ein Weg, um gegen die leicht positive Vorspannung, dass gerade Rundung gibt-Ihren finanziellen Einsatz erfordern.

Gauß/banker ' s rounding in JavaScript

InformationsquelleAutor der Antwort Gerard ONeill

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Beispiele

Bitweisen ODER-operator

Performance-Vergleich?

Hinweis