Преобразование булева результата в число/целое число

У меня есть переменная, которая хранит false или true, но мне нужно 0 или 1 вместо этого, соответственно. Как я могу это сделать?

Ответ 1

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

var i = result ? 1 : 0;

Ответ 2

Используйте унарный + оператор, который преобразует его операнд в число.

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

Обратите внимание, что вы все равно должны дезинфицировать данные на стороне сервера, так как пользователь может отправлять любые данные на ваш сервер, независимо от того, что говорит код на стороне клиента.

Ответ 3

Imho лучшее решение:

fooBar | 0

Это используется в asm.js для принудительного применения целочисленного типа.

Ответ 4

Я предпочитаю использовать функцию Number. Он принимает объект и преобразует его в число.
Пример:

var myFalseBool = false;
var myTrueBool = true;

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

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

Или запустите его в jsFiddle.

Ответ 5

Я создал JSperf сравнение всех предложенных ответов.

TL; DR - лучший вариант для всех существующих браузеров:

val | 0;

Обновить:

Кажется, что в наши дни все они довольно идентичны, за исключением того, что функция Number() является самой медленной, в то время как лучшим является val === true? 1: 0; val === true? 1: 0; ,

Ответ 6

Введенный способ сделать это будет следующим:

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

Ответ 7

Я только что наткнулся на эту ярлык сегодня.

~~ (истина)

~~ (ложь)

Люди гораздо умнее, чем я могу объяснить:

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

Ответ 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

Ответ 9

Я просто имел дело с этой проблемой в каком-то коде, который писал. Моим решением было использовать побитовое и.

var j = bool & 1;

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

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

var j = toInt(bool);

Изменить - 10 сентября 2014 г.

По какой-то причине в Chrome нет быстрого преобразования с использованием троичного оператора с идентичным оператору. Не имеет смысла, почему это быстрее, но я полагаю, что это своего рода оптимизация низкого уровня, которая имеет смысл где-то по пути.

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

Проверьте сами: http://jsperf.com/boolean-int-conversion/2

В FireFox и Internet Explorer использование версии, которую я разместил, обычно происходит быстрее.

Изменить - 14 июля 2017 г.

Хорошо, я не собираюсь говорить вам, какой из них вы должны или не должны использовать. Каждый взбешенный браузер все время показывал, насколько быстро они могут выполнять операции с каждым методом. В какой-то момент у Chrome битовая версия работала лучше, чем у других, но вдруг все стало намного хуже. Я не знаю, что они делают, поэтому я просто оставлю это тем, кого это волнует. Существует редкая причина заботиться о том, как быстро выполняется такая операция. Даже на мобильном это ничто, операция.

Кроме того, здесь более новый метод для добавления прототипа toInt, который не может быть перезаписан.

Object.defineProperty(Boolean.prototype, "toInt", { value: function()
{
    return this & 1;
}});

Ответ 10

Унарный оператор + позаботится об этом:

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

Вы, естественно, хотите здравомыслия - проверьте это на сервере, прежде чем хранить его, так что это может быть более разумным местом, чтобы сделать это в любом случае.

Ответ 11

Вы также можете добавить 0, использовать операторы сдвига или xor:

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

Они имеют схожие скорости, как и ответы других.

Ответ 12

Вы можете сделать это, просто расширив булевский прототип

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 в качестве выхода.

Ответ 13

let integerVariable = booleanVariable * 1;

Ответ 14

В моем контексте, React Native, где я получаю значение непрозрачности из логического, самый простой способ: использовать унарный оператор +.

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

Это преобразует логическое число в число;

style={ opacity: +!isFirstStep() }

Ответ 15

Я протестировал все эти примеры, сделал тест и, наконец, рекомендую выбрать более короткий, он не влияет на производительность.

Работает на сервере 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

Ответ 16

пытаться

val*1

let t=true;
let f=false;

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

Ответ 17

если вы хотите, чтобы целочисленное значение x изменялось с 1 на 0 и с 0 на 1 вы можете использовать (х + 1)% 2