Как преобразовать число с плавающей точкой в ​​целое число в JavaScript?

Я хотел бы преобразовать число с плавающей точкой в ​​JavaScript. На самом деле, я хотел бы знать, как сделать ОБА из стандартных преобразований: путем усечения и округления. И эффективно, а не путем преобразования в строку и анализа.

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

Примеры

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

Побитовый оператор ИЛИ

Побитовый или оператор можно использовать для усечения чисел с плавающей запятой, и он работает как для положительных, так и для отрицательных значений:

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

Результаты

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

Сравнение производительности?

Я создал тест JSPerf, который сравнивает производительность между:

• Math.floor(val)
• val | 0 ^{побитовое ИЛИ}
• ~~val ^{поразрядно НЕ}
• parseInt(val)

это работает только с положительными числами. В этом случае вы можете безопасно использовать побитовые операции как Math.floorфункции.

Но если вам нужен код для работы как с положительными, так и с отрицательными значениями , побитовая операция является самой быстрой (ИЛИ предпочтительной). Этот другой тест JSPerf сравнивает то же самое, где совершенно очевидно, что из-за дополнительной проверки знака Math теперь самый медленный из четырех.

Запись

Как указано в комментариях, операторы BITWISE работают с 32-разрядными целыми числами со знаком, поэтому большие числа будут преобразованы, например:

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

Примечание: вы не можете использовать Math.floor()в качестве замены для усечения, потому что Math.floor(-3.1) = -4и не-3 !!

Правильная замена для усечения будет:

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

    return Math.floor(value);
}

Двойной побитовый оператор not можно использовать для усечения чисел с плавающей запятой. Другие операции , упомянутые вами доступны через Math.floor, Math.ceilи Math.round.

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

Больше деталей любезно предоставлено Джеймсом Падолси.

Для усечения:

var intvalue = Math.floor(value);

Для тура:

var intvalue = Math.round(value);

Вы можете использовать метод parseInt без округления. Будьте осторожны с пользовательским вводом из-за вариантов префикса 0x (шестнадцатеричный) и 0 (восьмеричный).

var intValue = parseInt(floatValue, 10);

Сдвиг битов на 0, что эквивалентно делению на 1

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

В вашем случае, когда вам нужна строка в конце (для вставки запятых), вы также можете просто использовать Number.toFixed()функцию, однако она выполнит округление.

Здесь много предложений. Побитовое ИЛИ кажется самым простым на сегодняшний день. Вот еще одно короткое решение, которое работает и с отрицательными числами, используя оператор по модулю. Это, вероятно, легче понять, чем побитовое ИЛИ:

intval = floatval - floatval%1;

Этот метод также работает с большими значениями, где ни «| 0», ни «~~», ни «>> 0» не работают правильно:

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

Чтобы усечь :

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

Для округления :

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

Еще один возможный способ - использовать операцию 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

Приоритет побитовых операций меньше, чем приоритет математических операций, это полезно. Попробуйте на https://jsfiddle.net/au51uj3r/

Если вы посмотрите на нативный Mathобъект в JavaScript, вы получите целый набор функций для работы с числами и значениями и т. Д.

В основном то, что вы хотите сделать, довольно просто и встроено в JavaScript ...

Представьте, что у вас есть номер ниже:

const myValue = 56.4534931;

и теперь, если вы хотите округлить его до ближайшего числа, просто сделайте:

const rounded = Math.floor(myValue);

и вы получите:

56

Если вы хотите округлить его до ближайшего числа, просто выполните:

const roundedUp = Math.ceil(myValue);

и вы получите:

57

Кроме Math.roundтого, округление до большего или меньшего числа зависит от того, какой из них ближе к числу смещения.

Также вы можете использовать число ~~с плавающей точкой, которое преобразует число с плавающей точкой в ​​целое число.

Вы можете использовать его как ~~myValue...

Я просто хочу указать, что в денежном выражении вы хотите округлить, а не усечь. Снижение на пенни гораздо менее вероятно, так как округленное 4.999452 * 100 даст вам 5, более представительный ответ.

И, кроме того, не забывайте о банковском округлении , которое является способом противостоять слегка положительному смещению, которое дает прямое округление - вашему финансовому заявлению это может потребоваться.

Гауссово / банковское округление в JavaScript

Если вы используете angularjs, тогда простое решение:

{{val | number:0}}

преобразует val в целое число

перейдите по этой ссылке docs.angularjs.org/api/ng/filter/number