Wie konvertiere ich eine Float-Nummer in JavaScript in eine ganze Zahl?

Ich möchte einen Float in JavaScript in eine ganze Zahl konvertieren. Eigentlich möchte ich wissen, wie BEIDE Standardkonvertierungen durchgeführt werden: durch Abschneiden und Runden. Und effizient, nicht durch Konvertieren in einen String und Parsen.

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

Mathe-Objektreferenz

Beispiele

// 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

// 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

// 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

// 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

Bitweiser ODER-Operator

Ein bitweiser oder Operator kann zum Abschneiden von Gleitkommazahlen verwendet werden und funktioniert sowohl für positive als auch für negative Punkte:

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 einen JSPerf-Test erstellt , der die Leistung vergleicht 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 sicher bitweise Operationen und Math.floorFunktionen verwenden.

Wenn Sie jedoch Ihren Code benötigen, um sowohl mit positiven als auch mit negativen Ergebnissen zu arbeiten , ist eine bitweise Operation die schnellste (ODER die bevorzugte). Dieser andere JSPerf-Test vergleicht den gleichen, bei dem es ziemlich offensichtlich ist, dass Math aufgrund der zusätzlichen Vorzeichenprüfung jetzt der langsamste der vier ist.

Hinweis

Wie in den Kommentaren angegeben, arbeiten BITWISE-Operatoren mit vorzeichenbehafteten 32-Bit-Ganzzahlen. Daher werden große Zahlen konvertiert. Beispiel:

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

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

Ein korrekter Ersatz für Abschneiden wäre:

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

    return Math.floor(value);
}

Ein doppelter bitweiser Nicht- Operator kann verwendet werden, um Floats abzuschneiden. Die anderen Operationen , die Sie erwähnt sind durch Math.floor, Math.ceilund Math.round.

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

Weitere Details mit freundlicher Genehmigung von James Padolsey.

Zum Abschneiden:

var intvalue = Math.floor(value);

Für Runde:

var intvalue = Math.round(value);

Sie können die parseInt- Methode ohne Rundung verwenden. Seien Sie vorsichtig mit Benutzereingaben aufgrund der Präfixoptionen 0x (hex) und 0 (oktal).

var intValue = parseInt(floatValue, 10);

Bitverschiebung um 0, was einer Division durch 1 entspricht

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

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

Hier gibt es viele Vorschläge. Das bitweise ODER scheint bei weitem das einfachste zu sein. Hier ist eine weitere kurze Lösung, die auch mit negativen Zahlen unter Verwendung des Modulo-Operators funktioniert. 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

So 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

Zum Runden :

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

Ein weiterer möglicher Weg - verwenden Sie die 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

Die Priorität von bitweisen Operationen ist geringer als die Priorität von mathematischen Operationen, es ist nützlich. Versuchen Sie es mit https://jsfiddle.net/au51uj3r/

Wenn Sie sich ein natives MathObjekt in JavaScript ansehen , erhalten Sie eine ganze Reihe von Funktionen, mit denen Sie Zahlen und Werte usw. bearbeiten können.

Grundsätzlich ist das, was Sie tun möchten, in JavaScript recht einfach und nativ ...

Stellen Sie sich vor, Sie haben die folgende Nummer:

const myValue = 56.4534931;

und jetzt, wenn Sie es auf die nächste Zahl abrunden möchten, tun Sie einfach:

const rounded = Math.floor(myValue);

und du bekommst:

56

Wenn Sie es auf die nächste Zahl aufrunden möchten, gehen Sie einfach wie folgt vor:

const roundedUp = Math.ceil(myValue);

und du bekommst:

57

Auch Math.roundnur auf eine höhere oder niedrigere Zahl abrunden, hängt davon ab, welche näher an der Flotzahl liegt.

Sie können auch ~~hinter der Gleitkommazahl verwenden, um einen Gleitkommawert in eine ganze Zahl umzuwandeln.

Sie können es verwenden wie ~~myValue...

Ich möchte nur darauf hinweisen, dass Sie monetär runden und nicht abschneiden möchten. Es ist viel weniger wahrscheinlich, dass Sie um einen Cent davonkommen, da 4,999452 * 100 gerundet 5 ergibt, eine repräsentativere Antwort.

Vergessen Sie außerdem nicht die Rundung des Bankiers , um der leicht positiven Tendenz entgegenzuwirken, die eine gerade Rundung mit sich bringt - Ihre finanzielle Anwendung erfordert dies möglicherweise.

Gaußsche / Banker-Rundung in JavaScript

Wenn Sie anglejs verwenden, gehen Sie wie folgt vor: In HTML Template Binding

{{val | number:0}}

es wird val in eine ganze Zahl umwandeln

Gehen Sie mit diesem Link durch docs.angularjs.org/api/ng/filter/number