Jak przekonwertować liczbę zmiennoprzecinkową na liczbę całkowitą w JavaScript?

Chciałbym przekonwertować liczbę zmiennoprzecinkową na liczbę całkowitą w JavaScript. Właściwie chciałbym wiedzieć, jak ZROBIĆ standardowe konwersje: przez obcinanie i zaokrąglanie. I skutecznie, nie poprzez konwersję na ciąg i parsowanie.

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

Odwołanie do obiektu matematycznego

Przykłady

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

Bitowy operator OR

Do obcinania liczb zmiennoprzecinkowych można użyć operatora bitowego lub operatora. Działa to zarówno z dodatnimi, jak i ujemnymi wartościami:

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

Wyniki

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

Porównanie wydajności?

Stworzyłem test JSPerf, który porównuje wydajność między:

• Math.floor(val)
• val | 0 ^{bitowe LUB}
• ~~val ^{bitowe NIE}
• parseInt(val)

która działa tylko z liczbami dodatnimi. W takim przypadku możesz bezpiecznie używać operacji bitowych i Math.floorfunkcji.

Ale jeśli potrzebujesz kodu do pracy zarówno z dodatnimi, jak i ujemnymi , wtedy operacja bitowa jest najszybsza (LUB jest preferowana). Ten drugi test JSPerf porównuje to samo, gdzie jest całkiem oczywiste, że ze względu na dodatkowe sprawdzanie znaków Math jest teraz najwolniejszy z czterech.

Uwaga

Jak stwierdzono w komentarzach, operatorzy BITWISE działają na podpisanych 32-bitowych liczbach całkowitych, dlatego duże liczby zostaną przekonwertowane, na przykład:

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

Uwaga: Nie możesz użyć Math.floor()jako zamiennika obcięcia, ponieważ Math.floor(-3.1) = -4i nie -3!!

Prawidłowym zamiennikiem obcięcia byłoby:

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

    return Math.floor(value);
}

Do obcinania liczb zmiennoprzecinkowych można zastosować podwójny bitowy operator nie będący operatorem. Inne operacje, które wymieniłeś są dostępne Math.floor, Math.ceili Math.round.

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

Więcej szczegółów dzięki uprzejmości Jamesa Padolseya.

Do obcinania:

var intvalue = Math.floor(value);

Dla rundy:

var intvalue = Math.round(value);

Możesz użyć metody parseInt bez zaokrąglania. Uważaj na dane wprowadzane przez użytkownika ze względu na opcje prefiksu 0x (hex) i 0 (octal).

var intValue = parseInt(floatValue, 10);

Przesunięcie bitu o 0, co odpowiada podziałowi przez 1

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

W twoim przypadku, jeśli chcesz na końcu napis (w celu wstawienia przecinków), możesz również po prostu użyć Number.toFixed()funkcji, jednak spowoduje to zaokrąglenie.

Tutaj jest wiele sugestii. Bitowa OR wydaje się zdecydowanie najprostsza. Oto kolejne krótkie rozwiązanie, które działa również z liczbami ujemnymi przy użyciu operatora modulo. Prawdopodobnie jest to łatwiejsze do zrozumienia niż bitowe LUB:

intval = floatval - floatval%1;

Ta metoda działa również z liczbami o wysokiej wartości, w których ani „| 0”, ani „~~”, ani „>> 0” nie działają poprawnie:

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

Aby obciąć :

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

Aby zaokrąglić :

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

Jeszcze jeden możliwy sposób - użyj operacji XOR:

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

Priorytet operacji bitowych jest mniejszy niż priorytet operacji matematycznych, jest to przydatne. Spróbuj na https://jsfiddle.net/au51uj3r/

Jeśli spojrzysz na natywny Mathobiekt w JavaScript, dostaniesz całą masę funkcji do pracy na liczbach i wartościach itp.

Zasadniczo to, co chcesz zrobić, jest dość proste i natywne w JavaScript ...

Wyobraź sobie, że masz numer poniżej:

const myValue = 56.4534931;

a teraz, jeśli chcesz zaokrąglić w dół do najbliższej liczby, po prostu wykonaj:

const rounded = Math.floor(myValue);

i dostajesz:

56

Jeśli chcesz zaokrąglić w górę do najbliższej liczby, po prostu wykonaj:

const roundedUp = Math.ceil(myValue);

i dostajesz:

57

Po Math.roundprostu zaokrąglij go do wyższej lub niższej liczby, zależnie od tego, która z nich jest bliżej liczby flot.

Możesz także użyć liczby ~~spoza liczby zmiennoprzecinkowej, która zamieni liczbę zmiennoprzecinkową na liczbę całkowitą.

Możesz używać go jak ~~myValue...

Chcę tylko zaznaczyć, że pieniężnie chcesz zaokrąglać, a nie obcinać. Posiadanie grosza jest znacznie mniej prawdopodobne, ponieważ 4.999452 * 100 zaokrąglone da 5, bardziej reprezentatywną odpowiedź.

Co więcej, nie zapominaj o zaokrąglaniu przez bankiera , który jest sposobem na przeciwdziałanie lekko pozytywnemu nastawieniu, jakie daje proste zaokrąglanie - Twoja aplikacja finansowa może tego wymagać.

Zaokrąglanie Gaussa / bankiera w JavaScript

Jeśli używasz angularjs, to proste rozwiązanie w następujący sposób: Wiązanie szablonów HTML

{{val | number:0}}

zamieni val na liczbę całkowitą

przejdź przez ten link docs.quarejs.org/api/ng/filter/number