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

【问题标题】：Convert boolean result into number/integer将布尔结果转换为数字/整数
【发布时间】：2011-12-10 20:44:51
【问题描述】：

我有一个存储false 或true 的变量，但我分别需要0 或1。我该怎么做？

【问题讨论】：

以下是一些提供的技术的性能比较：jsperf.com/conversion-from-boolean-to-number。
Node.JS 用户会希望使用 bool === true ? 1 : 0，因为它是 V8 中迄今为止最快的。
或者只是bool ? 1 : 0;

标签： javascript numbers integer boolean type-conversion

【解决方案1】：

使用unary + operator，它将其操作数转换为数字。

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

当然，请注意，您仍应清理服务器端的数据，因为用户可以将任何数据发送到您的服务器，而不管客户端代码是什么。

【讨论】：

虽然很酷（我从未想过这个），但它是incredibly slow（准确地说，Chrome 慢了 97%）。小心！
查看this revision。 Number() 更慢。
看来bool === true ? 1 : 0 是最快的，紧随bool | 0 次之。
乘法（例如 3*false）感觉很不对，但它确实有效。 :) 谢谢！
@DerkJanSpeelman Typescript 中不允许的事实并不意味着您不应该在 Javascript 中这样做。它们是不同的（尽管相关的）语言。

【解决方案2】：

Javascript 有一个可以使用的三元运算符：

var i = result ? 1 : 0;

【讨论】：

最佳答案。为什么？这适用于更普遍的真实性，并接受任何类型（字符串、数字等）。一元答案确实很聪明，但如果我传递一个字符串，它会返回NaN。所以如果你想要L33T并保证输入，那就去urary，否则我认为三元+真值测试是最好的。
这个解决方案基本上是使用三元运算符最小化if 语句。
三元解法是最快的方法之一。 +true 或 Number(true) 等其他解决方案非常慢。见benchmark。
@Dominik 该基准测试工具非常令人困惑和误导。 jsbench.me 是一个更好的选择。

【解决方案3】：

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

fooBar | 0

这在 asm.js 中用于强制整数类型。

【讨论】：

最快的之一； +1。
不错的一个。你也可以使用“Boolean ^ 0”。 OR 或 XOR 有效。
如果 fooBar 不是，这将不会返回 1 整数吗？
@ESR 它将所有内容转换为一个数字，但并不总是您想要的数字，如果您正在处理其他真实类型。 1 | 0 = 1; 0 | 0 = 0; true | 0 = 1; false | 0 = 0; 'foo' | 0 = 0; undefined | 0 = 0
打字稿错误：The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type.

【解决方案4】：

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

例子：

var myFalseBool = false;
var myTrueBool = true;

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

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

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

【讨论】：

这是迄今为止最好的答案。当然在底部。只有“它需要一个对象”是不对的。
链接到 mdn 比 w3schools(eeek !) 好得多：developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
我认为这是最好的方式，因为它易于阅读和意图揭示。
它也是最慢的。
很好，这正是我会做的。而不是使用三元表达式。

【解决方案5】：

键入的方法是：

Number(true) // 1
Number(false) // 0

【讨论】：

终于得到了一些不错的答案。谢谢。
三元解法是最快的方法之一。 +true 或 Number(true) 等其他解决方案非常慢。见benchmark。

【解决方案6】：

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

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

val | 0;

.

更新：

现在看起来它们都差不多，除了 Number() 函数最慢，而最好的是 val === true ? 1 : 0;。

【讨论】：

有趣的是，三进制现在在 macOS 10.13.3 上的 Chrome 64.0.3282 中是最快的。
这将是当时最快的选择。这与它是最佳选择不同。

【解决方案7】：

我今天才发现这个快捷方式。

~~(真)

~~(假)

人们比我能解释的聪明得多：

http://james.padolsey.com/javascript/double-bitwise-not/

【讨论】：

有趣。我今天学了些新东西。不过，我不会在任何项目中使用这种技术，因为它可能会混淆未来的我或队友。
hacky js 是我的最爱。说真的，+1

【解决方案8】：

当 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

进一步阅读 The Definitive Guide to Javascript 的类型转换第 3.8 章。

【讨论】：

【解决方案9】：

一元 + 运算符会处理这个问题：

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

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

【讨论】：

我已将 cmets 更改为 ===，因为即使没有“显式转换 :-) true === 1 true == 1 也为 true。

【解决方案10】：

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

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

【讨论】：

我对这篇文章投了两次反对票。你为什么不解释你为什么拒绝它。否则，这只是没有理由的投反对票。
jsperf 的 99 倍结果只会让您走上过早的优化路径，当您应该专注于那个丑陋的 SQL 语句时，优化了几纳秒的循环。感谢您提供几种不同的方法来解决这个问题
什么SQL语句？这里没有一个查询。如果您指的是 JSPerf，我是从其他人的测试中链接的。这不是我自己的。老实说，我不关心这个的性能方面，因为它是一个无操作。我创建了自己的语言，它的功能几乎与 JS 相同，我记得强制转换为 int 是一个愚蠢的快速操作。攀登原型链不是。这就是为什么我仍然推荐我这样做的第一种方法，它具有一个可以由编译器内联的简单函数。
SQL 的东西是一个概括。感谢您的洞察力

【解决方案11】：

也可以加0，使用移位运算符或异或：

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

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

【讨论】：

【解决方案12】：

TL;DR: 避免 `Number` 构造函数，一元 `+`;一直使用简单的`if`；如果您的项目中的基准测试以这种方式做得更好，请使用 `bool | 0` 或 `1 * bool`。

这是一个相当古老的问题，并且存在许多有效的答案。我注意到这里所有的基准测试都是无关紧要的——没有一个考虑到branch prediction。此外，如今，JS 引擎不只是简单地解释代码，它们JIT compile 将其转换为本地机器代码并在执行之前对其进行优化。这意味着，除了分支预测之外，编译器甚至可以用它们的最终值替换表达式。

现在，这两个因素如何影响布尔到整数转换的性能？让我们来了解一下！在我们进入基准测试之前，了解我们的基准测试是很重要的。对于转换，我们使用以下七种转换方法：

号码构造函数：Number(bool)
If 语句（使用三元组）：bool ? 1 : 0
一元运算符+:+bool
按位或：bool | 0
按位与：bool & 1
按位双非：~~bool
数字乘法：bool * 1

“转换”是指将false 转换为0 和true 转换为1¹。每种转换方法运行 100000 次，测量操作/毫秒。在下表中，转换方法将相应地分组到它们的结果中。结果来自我的机器，它的 CPU 是 AMD Ryzen 7 4800HS。

第一个benchmark转换常量true：

Method	Edge/Chromium (V8)	Firefox (Spidermonkey)
`Number(bool)`	83103	1088
`bool ? 1 : 0`	83073	7732
`+bool`	83372	1043
`bool \| 0`	83479	9344
`bool & 1`	83242	9354
`~~bool`	83293	9316
`bool * 1`	83504	9316

有趣！ V8 显示了一些巨大的数字，所有数字都大致相同！ Spidermonkey 并没有真正发光，但我们可以看到按位和乘法技巧排在第一位，三进制 if 排在第二位。有什么外卖？ Chrome 浏览器设法用简单的值 1 替换我们的转换。这种优化将发生在我们可以将布尔值替换为常数值的地方。

以上不是我们在实际项目中会遇到的情况。所以让我们改变我们的变量：布尔值现在是Math.random() < 0.5。这产生了true 的 50% 机会，false 的 50%。我们的结果会改变吗？让我们运行这个benchmark 看看。

Method	Edge/Chromium (V8)	Firefox (Spidermonkey)
`Number(bool)`	2405	662
`bool ? 1 : 0`	1482	1580
`+bool`	2386	673
`bool \| 0`	2391	2499
`bool & 1`	2409	2513
`~~bool`	2341	2493
`bool * 1`	2398	2518

结果现在更加一致。我们看到三元 if、按位和乘法方法的数字相似，但 Number 构造函数和一元 + 在 V8 上表现更好。我们可以从数字推测 V8 用它用于按位技巧的任何指令替换它们，但在 Spidermonkey 中，这些函数完成了所有工作。

我们还没有解决上面提到的一个因素：分支预测。让我们将这个benchmark 中的布尔变量更改为Math.random() < 0.01，这意味着1% true，99% false。

Method	Edge/Chromium (V8)	Firefox (Spidermonkey)
`Number(bool)`	2364	865
`bool ? 1 : 0`	2352	2390
`+bool`	2447	777
`bool \| 0`	2421	2513
`bool & 1`	2400	2509
`~~bool`	2446	2501
`bool * 1`	2421	2497

出乎意料？预期的？我会说后者，因为在这种情况下，分支预测在几乎所有情况下都是成功的，因为三元 if 和按位 hack 之间的差异很小。其他结果都一样，这里不多说。

这项努力让我们回到了最初的问题：如何在 Javascript 中将 bool 转换为 int？以下是我的建议：

避免使用Number(bool) 和+bool。这两种方法在后台做了很多工作，尽管 Chrome 设法在我们的基准测试中优化了它们，但 Firefox 没有，而且在某些情况下编译器可能不会完成这些优化。除此之外，并不是每个人都在使用 Chrome！我仍然不得不忍受，不是吗？...
通常使用 if 语句。不要变得聪明——浏览器通常会做得更好，而且通常意味着大多数情况。它们是这里所有方法中最易读和最清晰的。当我们处于可读性时，也许使用if (bool) 而不是那个丑陋的三元组！我希望 Javascript 拥有 Rust 或 Python 所拥有的...
真正需要时使用其余部分。也许您项目中的基准测试不符合标准，并且您发现讨厌的 if 会导致性能不佳 - 如果是这种情况，请随时进入 branchless programming！但是不要在那个兔子洞里走得太深，相信我，没有人会从 -1 * (a < b) + 1 * (a > b) 这样的东西中受益。

我将永远感谢您阅读到最后 - 这是我第一个更长的、重要的 StackOverflow 答案，如果它有帮助和有见地，它对我来说意味着世界。如果您发现任何错误，请随时纠正我！

定义了转换，因为不清楚布尔到整数的含义。例如，Go does not support this conversion at all。

【讨论】：

赞成这项工作，但我想不出一个真正的用例，当这种操作的性能很重要时:)
@skwisgaar 完全同意，虽然我认为这个操作主要是在人们觉得需要优化的时候才想到的
优秀的帖子，但我试图弄清楚基准数字的解释，因为您表示“操作/秒”。在我使用了 5 年的 Acer 笔记本电脑的 V8 浏览器调试器中，以下百万次操作在 36 毫秒（！）内运行：start=performance.now(); for (let i = 0; i < 1000000; i++) {let x = +(Math.random()<0.5);} end=performance.now(); console.log(end-start)。我在误解什么？
感谢您的回复！自己运行基准测试，数字看起来更像操作/_毫秒_。尽管在 Chrome 和 Firefox 的 DevTools 中，相同的基准测试似乎在我的机器上也运行得更快——也许 JSBench 是一个瓶颈。我现在将更改度量单位，但这必须进一步研究。
@TeodorMaxim 刚刚看到您已回复...听起来不清楚 JSBench 报告的内容...您最好创建自己的迷你基准测试工具，至少您会知道除了确切地知道如何解释结果之外，准确地测量了什么。

【解决方案13】：

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

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

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

style={ opacity: +!isFirstStep() }

【讨论】：

【解决方案14】：

+!! 允许您将其应用于变量，即使它是 undefined：

+!!undefined    // 0
+!!false        // 0
+!!true         // 1

+!!(<boolean expression>)  // 1 if it evaluates to true, 0 otherwise

【讨论】：

【解决方案15】：

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

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 作为其输出。

【讨论】：

【解决方案16】：

let integerVariable = booleanVariable * 1;

【讨论】：

【解决方案17】：

试试

val*1

let t=true;
let f=false;

console.log(t*1);
console.log(f*1)

【讨论】：

【解决方案18】：

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

在 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

【讨论】：

TL;DR: 避免 Number 构造函数，一元 +;一直使用简单的if；如果您的项目中的基准测试以这种方式做得更好，请使用 bool | 0 或 1 * bool。

TL;DR: 避免 `Number` 构造函数，一元 `+`;一直使用简单的`if`；如果您的项目中的基准测试以这种方式做得更好，请使用 `bool | 0` 或 `1 * bool`。