如何在JavaScript中将浮点数转换为整数？

Question

我想在JavaScript中将float转换为整数.实际上,我想知道如何同时执行标准转换:截断和舍入.并且有效,而不是通过转换为字符串和解析.

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

数学对象参考

例子

正

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

Answer 2

按位OR运算符

按位或运算符可用于截断浮点数,它适用于正数和负数:

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 ^按位OR
• ~~val ^按位NOT
• parseInt(val)

只适用于正数.在这种情况下,您可以安全地使用按位运算和Math.floor函数.

但是,如果您需要使用代码来处理正数和负数,那么按位运算是最快的(OR是首选运算).这个其他JSPerf测试比较相同的地方很明显,因为额外的符号检查Math现在是四个中最慢的.

注意

如评论中所述,BITWISE运算符在带符号的32位整数上运算,因此将转换大数字,例如:

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

Answer 3

注意:您不能Math.floor()用作截断的替代品,因为Math.floor(-3.1) = -4而不是-3!!

截断的正确替换将是:

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

    return Math.floor(value);
}

Answer 4

双位按运算符可用于截断浮点数.你提到的其他操作都可以通过Math.floor,Math.ceil和Math.round.

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

更多细节由James Padolsey提供.

Answer 5

对于截断:

var intvalue = Math.floor(value);

圆形:

var intvalue = Math.round(value);

Answer 6

您可以使用parseInt方法进行舍入.由于0x(十六进制)和0(八进制)前缀选项,请注意用户输入.

var intValue = parseInt(floatValue, 10);

Answer 7

位移0,相当于除以1

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

Answer 8

如果你想要一个向下的四舍五入的答案：

var intvalue = Math.floor( floatvalue );
var integer = Math.floor(4.56);
Answer = 4

如果您想向上舍入：

var intvalue = Math.ceil( floatvalue );
Answer would be = 5

Answer 9

在你的情况下,当你想要一个字符串到最后(为了插入逗号),你也可以只使用Number.toFixed()函数,但是,这将执行舍入.

Answer 10

这里有很多建议.到目前为止,按位OR似乎是最简单的.这是另一个简短的解决方案,它使用模数运算符也可以使用负数.它可能比按位OR更容易理解:

intval = floatval - floatval%1;

此方法也适用于高值数字,其中"| 0","~~"和">> 0"都不能正常工作:

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

Answer 11

1. Math.floor()函数返回小于或等于给定数字的最大整数。

       console.log('Math.floor : ', Math.floor(3.5));
       console.log('Math.floor : ', Math.floor(-3.5));

2. Math.ceil()函数始终将数字向上舍入到下一个最大整数。

       console.log('Math.ceil : ', Math.ceil(3.5));
       console.log('Math.ceil : ', Math.ceil(-3.5));

3. Math.round()函数返回四舍五入到最接近整数的数字值。

       console.log('Math.round : ', Math.round(3.5));
       console.log('Math.round : ', Math.round(-3.5));

4. Math.trunc()函数通过删除任何小数位来返回数字的整数部分。

       console.log('Math.trunc : ', Math.trunc(3.5));
       console.log('Math.trunc : ', Math.trunc(-3.5));

Answer 12

要截断：

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

为了圆：

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

Answer 13

//Convert a float to integer

Math.floor(5.95)
//5

Math.ceil(5.95)
//6

Math.round(5.4)
//5

Math.round(5.5)
//6

Math.trunc(5.5)
//5

//Quick Ways
console.log(5.95| 0)
console.log(~~5.95) 
console.log(5.95 >> 0)
//5

Answer 14

另一种可能的方法 - 使用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/