将布尔结果转换为数字/整数

276

我有一个存储false或的变量true，但我分别需要0或1代替。我怎样才能做到这一点？

javascript  numbers  integer  boolean  type-conversion 
— 高清
source
8
这是一些提供的技术的性能比较：jsperf.com/conversion-from-boolean-to-number。
— 2014年
4
Node.JS用户将要使用bool === true ? 1 : 0，因为它是V8中最快的。
— Qix-蒙尼卡犯了错误，2014年
3
或只是bool ? 1 : 0;
— Atrahasis

Answers:

343

JavaScript具有三元运算符，您可以使用：

var i = result ? 1 : 0;
— 安迪·罗斯
source
7
最佳答案。为什么？这适用于更普遍的真理，可以接受任何类型（字符串，数字等）。一元答案的确确实很聪明，但是如果我将其传递给字符串，它将返回NaN。因此，如果您要L33T并保证输入，请尝试一下，否则最好使用三元+真值测试。
— gdibble
465

使用一元运算+符，它将其操作数转换为数字。

+ true; // 1
+ false; // 0

当然，请注意，您仍然应该在服务器端清理数据，因为无论客户端代码说什么，用户都可以将任何数据发送到您的服务器。

— 寂寞的一天
source
50
尽管很酷（我从未想到过），但它的运行速度非常慢（确切地说，在Chrome浏览器中速度要慢 97％）。警惕！
— Qix-蒙尼卡（Monica）2014年
5
查看此修订版。Number()甚至更慢。
— Qix-蒙尼卡（Monica）错误
23
它似乎bool === true ? 1 : 0是最快的，仅次于bool | 0。
— Qix-蒙尼卡（Monica）错误
1
乘法（例如3 * false）感觉很错，但是可以。：） 谢谢！
— mattsoave
1
@DerkJanSpeelman在Typescript中不允许执行某些操作并不意味着您不应该在Javascript中进行操作。它们是不同的（尽管相关）语言。
— lonesomeday
119

恕我直言，最好的解决方案是：

fooBar | 0

在asm.js中使用它来强制整数类型。

— 克拉利克
source
最快的之一；+1。
— Qix-蒙尼卡（Monica）错误
3
好一个。您也可以使用“布尔值^ 0”。OR或XOR起作用。
— F8ER
1如果fooBar不是，它将不会返回整数？
— ESR
58

我更喜欢使用Number函数。它接受一个对象并将其转换为数字。

例：

var myFalseBool = false;
var myTrueBool = true;

var myFalseInt = Number(myFalseBool);
console.log(myFalseInt === 0);

var myTrueInt = Number(myTrueBool);
console.log(myTrueInt === 1);

您可以在jsFiddle中对其进行测试。

— 雷内
source
3
到目前为止，这是最好的答案。当然在底部。仅“带一个物体”是不对的。
— 鲁迪
2
链接到MDN比W3Schools的要好得多（eeek！）：developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/...
— Olivvv
我认为这是最好的方法，因为它很容易阅读和表达意图。
— 2014年
3
这也是在最慢的。
— Qix-蒙尼卡（Monica）错误
45

我创建了所有建议答案的JSperf比较。

TL; DR-当前所有浏览器的最佳选择是：

val | 0;

。

更新：

看起来这些天它们几乎都是相同的，只是Number()功能最慢而最好val === true ? 1 : 0;。

— 加尔·塔尔莫
source
2
有趣的是，三进制现在在macOS 10.13.3上的Chrome 64.0.3282中最快。
— 2540625
当时，这将是最快的选择。这与最佳选择不同。
— mikemaccana
16

当JavaScript期望数字值但接收到布尔值时，它将布尔值转换为数字：true和false分别转换为1和0。因此，您可以利用此优势；

var t = true;
var f = false;

console.log(t*1); // t*1 === 1
console.log(f*1); // f*1 === 0 

console.log(+t); // 0+t === 1 or shortened to +t === 1
console.log(+f); //0+f === 0 or shortened to +f === 0
展开摘要

进一步阅读《 Java权威指南》的类型转换第3.8章。

— 查理·林奇
source
13

一元运算+符将对此进行处理：

var test = true;
// +test === 1
test = false;
// +test === 0

您自然会希望在存储它之前先在服务器上对其进行完整性检查，但是无论如何这可能是一个更明智的选择。

— 古斯塔夫·巴克福斯
source
我已将注释更改为===，因为true == 1即使没有“显式转换:-)也是正确的，但它true === 1是错误的
— 。– xanatos
13

我只是在用自己编写的某些代码处理这个问题。我的解决方案是使用按位和。

var j = bool & 1;

处理恒定问题的一种更快的方法是创建一个函数。它对其他人更具可读性，在维护阶段更易理解，并且消除了编写错误内容的可能性。

function toInt( val ) {
    return val & 1;
}

var j = toInt(bool);

编辑-2014年9月10日

由于某种原因，在Chrome中使用与操作符相同的三元运算符进行转换不会更快。对于为什么它更快，没有任何意义，但我想这是某种低水平的优化，在整个过程中都有意义。

var j = boolValue === true ? 1 : 0;

自己测试：http : //jsperf.com/boolean-int-conversion/2

在FireFox和Internet Explorer中，使用我发布的版本通常更快。

编辑-2017年7月14日

好的，我不会告诉您您应该或不应该使用哪一个。每个奇怪的浏览器在使用每种方法进行操作时的速度一直在上升和下降。实际上，Chrome在某一点上的按位＆版本比其他版本要好，但是突然之间，情况变得更糟。我不知道他们在做什么，所以我将留给谁在乎。几乎没有任何理由在乎这样的操作有多快。即使在移动设备上，它也不是任何操作。

另外，这是一种用于添加无法覆盖的“ toInt”原型的更新方法。

Object.defineProperty(Boolean.prototype, "toInt", { value: function()
{
    return this & 1;
}});
— 尼古拉斯·格兰特
source
我对此帖子有两次投票。您为什么不解释为什么要拒​​绝投票。否则，这只是毫无理由的不满。
— 尼古拉斯·格兰特
1
jsperf的结果的99倍只是引导您走上了过早的优化路径，当您应将注意力集中在丑陋的SQL语句上时，可以在循环之外优化纳秒级的性能。感谢您提供几种不同的方法来解决这一问题
— RozzA，2017年
什么SQL语句？这里没有一个查询。如果您指的是JSPerf，那么我是将其与其他人的测试联系起来。不是我自己的 老实说，我并不在乎性能方面，因为它是什么都不做的操作。我创建了自己的语言，几乎具有与JS相同的功能，并且我还记得强制转换为int是一个愚蠢的快速操作。没有攀登原型链。这就是为什么我仍然推荐我做的第一种方法的原因，它带有一个可以由编译器内联的简单函数。
— 尼古拉斯·格兰特
SQL东西是一种概括。感谢您的见解
— RozzA
9

您还可以加0，使用移位运算符或xor：

val + 0;
val ^ 0;
val >> 0;
val >>> 0;
val << 0;

这些具有与其他答案相似的速度。

— REMqb
source
6

在我的上下文中，React Native是我从布尔值获得不透明度值的最简单方法：使用一元+运算符。

+ true; // 1
+ false; // 0

这会将布尔值转换为数字；

style={ opacity: +!isFirstStep() }
— 何塞·贝拉斯科
source
4

您可以通过简单地扩展布尔型原型来做到这一点

Boolean.prototype.intval = function(){return ~~this}

理解那里发生的事情不是太容易，所以会有一个替代版本是 

Boolean.prototype.intval = function(){return (this == true)?1:0}

做完了你可以做的事情

document.write(true.intval());

当我使用布尔值存储条件时，我经常将它们转换为位域，在这种情况下，我最终会使用原型函数的扩展版本

Boolean.prototype.intval = function(places)
{
 places = ('undefined' == typeof(places))?0:places; 
 return (~~this) << places
}

你可以用它做 

document.write(true.intval(2))

产生4作为其输出。

— DroidOS
source
1

我已经测试了所有这些示例，做了一个基准测试，最后我建议您选择较短的示例，因为它不会影响性能。

在Ubuntu服务器14.04，nodejs v8.12.0中运行-26/10/18

    let i = 0;
console.time("TRUE test1")
    i=0;
    for(;i<100000000;i=i+1){
        true ? 1 : 0;
    }
console.timeEnd("TRUE test1")


console.time("FALSE test2")
    i=0;
    for(;i<100000000;i=i+1){
        false ? 1 : 0;
    }
console.timeEnd("FALSE test2")

console.log("----------------------------")

console.time("TRUE test1.1")
    i=0;
    for(;i<100000000;i=i+1){
        true === true ? 1 : 0;
    }
console.timeEnd("TRUE test1.1")


console.time("FALSE test2.1")
    i=0;
    for(;i<100000000;i=i+1){
        false === true ? 1 : 0;
    }
console.timeEnd("FALSE test2.1")

console.log("----------------------------")

console.time("TRUE test3")
    i=0;
    for(;i<100000000;i=i+1){
        true | 0;
    }
console.timeEnd("TRUE test3")

console.time("FALSE test4")
    i=0;
    for(;i<100000000;i=i+1){
        false | 0;
    }
console.timeEnd("FALSE test4")

console.log("----------------------------")

console.time("TRUE test5")
    i=0;
    for(;i<100000000;i=i+1){
        true * 1;
    }
console.timeEnd("TRUE test5")

console.time("FALSE test6")
    i=0;
    for(;i<100000000;i=i+1){
        false * 1;
    }
console.timeEnd("FALSE test6")

console.log("----------------------------")

console.time("TRUE test7")
    i=0;
    for(;i<100000000;i=i+1){
        true & 1;
    }
console.timeEnd("TRUE test7")

console.time("FALSE test8")
    i=0;
    for(;i<100000000;i=i+1){
        false & 1;
    }
console.timeEnd("FALSE test8")

console.log("----------------------------")

console.time("TRUE test9")
    i=0;
    for(;i<100000000;i=i+1){
        +true;
    }
console.timeEnd("TRUE test9")

console.time("FALSE test10")
    i=0;
    for(;i<100000000;i=i+1){
        +false;
    }
console.timeEnd("FALSE test10")

console.log("----------------------------")

console.time("TRUE test9.1")
    i=0;
    for(;i<100000000;i=i+1){
        0+true;
    }
console.timeEnd("TRUE test9.1")

console.time("FALSE test10.1")
    i=0;
    for(;i<100000000;i=i+1){
        0+false;
    }
console.timeEnd("FALSE test10.1")

console.log("----------------------------")

console.time("TRUE test9.2")
    i=0;
    for(;i<100000000;i=i+1){
        -true*-1;
    }
console.timeEnd("TRUE test9.2")

console.time("FALSE test10.2")
    i=0;
    for(;i<100000000;i=i+1){
        -false*-1;
    }
console.timeEnd("FALSE test10.2")

console.log("----------------------------")

console.time("TRUE test9.3")
    i=0;
    for(;i<100000000;i=i+1){
        true-0;
    }
console.timeEnd("TRUE test9.3")

console.time("FALSE test10.3")
    i=0;
    for(;i<100000000;i=i+1){
        false-0;
    }
console.timeEnd("FALSE test10.3")

console.log("----------------------------")

console.time("TRUE test11")
    i=0;
    for(;i<100000000;i=i+1){
        Number(true);
    }
console.timeEnd("TRUE test11")

console.time("FALSE test12")
    i=0;
    for(;i<100000000;i=i+1){
        Number(false);
    }
console.timeEnd("FALSE test12")

console.log("----------------------------")

console.time("TRUE test13")
    i=0;
    for(;i<100000000;i=i+1){
        true + 0;
    }
console.timeEnd("TRUE test13")

console.time("FALSE test14")
    i=0;
    for(;i<100000000;i=i+1){
        false + 0;
    }
console.timeEnd("FALSE test14")

console.log("----------------------------")

console.time("TRUE test15")
    i=0;
    for(;i<100000000;i=i+1){
        true ^ 0;
    }
console.timeEnd("TRUE test15")

console.time("FALSE test16")
    i=0;
    for(;i<100000000;i=i+1){
        false ^ 0;
    }
console.timeEnd("FALSE test16")

console.log("----------------------------")

console.time("TRUE test17")
    i=0;
    for(;i<100000000;i=i+1){
        true ^ 0;
    }
console.timeEnd("TRUE test17")

console.time("FALSE test18")
    i=0;
    for(;i<100000000;i=i+1){
        false ^ 0;
    }
console.timeEnd("FALSE test18")

console.log("----------------------------")

console.time("TRUE test19")
    i=0;
    for(;i<100000000;i=i+1){
        true >> 0;
    }
console.timeEnd("TRUE test19")

console.time("FALSE test20")
    i=0;
    for(;i<100000000;i=i+1){
        false >> 0;
    }
console.timeEnd("FALSE test20")

console.log("----------------------------")

console.time("TRUE test21")
    i=0;
    for(;i<100000000;i=i+1){
        true >>> 0;
    }
console.timeEnd("TRUE test21")

console.time("FALSE test22")
    i=0;
    for(;i<100000000;i=i+1){
        false >>> 0;
    }
console.timeEnd("FALSE test22")

console.log("----------------------------")

console.time("TRUE test23")
    i=0;
    for(;i<100000000;i=i+1){
        true << 0;
    }
console.timeEnd("TRUE test23")

console.time("FALSE test24")
    i=0;
    for(;i<100000000;i=i+1){
        false << 0;
    }
console.timeEnd("FALSE test24")

console.log("----------------------------")

console.time("TRUE test25")
    i=0;
    for(;i<100000000;i=i+1){
        ~~true;
    }
console.timeEnd("TRUE test25")

console.time("FALSE test26")
    i=0;
    for(;i<100000000;i=i+1){
        ~~false;
    }
console.timeEnd("FALSE test26")

console.log("----------------------------")

console.time("TRUE test25.1")
    i=0;
    for(;i<100000000;i=i+1){
        ~true*-1-1;
    }
console.timeEnd("TRUE test25.1")

console.time("FALSE test26.1")
    i=0;
    for(;i<100000000;i=i+1){
        ~false*-1-1;
    }
console.timeEnd("FALSE test26.1")

console.log("----------------------------")

console.time("TRUE test27")
    i=0;
    for(;i<100000000;i=i+1){
        true/1;
    }
console.timeEnd("TRUE test27")

console.time("FALSE test28")
    i=0;
    for(;i<100000000;i=i+1){
        false/1;
    }
console.timeEnd("FALSE test28")

结果 

TRUE test1: 93.301ms
FALSE test2: 102.854ms
----------------------------
TRUE test1.1: 118.979ms
FALSE test2.1: 119.061ms
----------------------------
TRUE test3: 97.265ms
FALSE test4: 108.389ms
----------------------------
TRUE test5: 85.854ms
FALSE test6: 87.449ms
----------------------------
TRUE test7: 83.126ms
FALSE test8: 84.992ms
----------------------------
TRUE test9: 99.683ms
FALSE test10: 87.080ms
----------------------------
TRUE test9.1: 85.587ms
FALSE test10.1: 86.050ms
----------------------------
TRUE test9.2: 85.883ms
FALSE test10.2: 89.066ms
----------------------------
TRUE test9.3: 86.722ms
FALSE test10.3: 85.187ms
----------------------------
TRUE test11: 86.245ms
FALSE test12: 85.808ms
----------------------------
TRUE test13: 84.192ms
FALSE test14: 84.173ms
----------------------------
TRUE test15: 81.575ms
FALSE test16: 81.699ms
----------------------------
TRUE test17: 81.979ms
FALSE test18: 81.599ms
----------------------------
TRUE test19: 81.578ms
FALSE test20: 81.452ms
----------------------------
TRUE test21: 115.886ms
FALSE test22: 88.935ms
----------------------------
TRUE test23: 82.077ms
FALSE test24: 81.822ms
----------------------------
TRUE test25: 81.904ms
FALSE test26: 82.371ms
----------------------------
TRUE test25.1: 82.319ms
FALSE test26.1: 96.648ms
----------------------------
TRUE test27: 89.943ms
FALSE test28: 83.646ms
— 达克·布莱泽
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.