Konvertieren Sie das boolesche Ergebnis in Zahl / Ganzzahl

Ich habe eine Variable, die falseoder speichert true, aber ich brauche 0oder 1stattdessen. Wie kann ich das machen?

Javascript hat einen ternären Operator, den Sie verwenden können:

var i = result ? 1 : 0;

Verwenden Sie den unären +Operator , der seinen Operanden in eine Zahl konvertiert.

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

Beachten Sie natürlich, dass Sie die Daten auf der Serverseite weiterhin bereinigen sollten, da ein Benutzer alle Daten an Ihren Server senden kann, unabhängig davon, was der clientseitige Code sagt.

Imho die beste Lösung ist:

fooBar | 0

Dies wird in asm.js verwendet, um den Integer-Typ zu erzwingen.

Ich bevorzuge die Zahlenfunktion . Es nimmt ein Objekt und wandelt es in eine Zahl um.

Beispiel:

var myFalseBool = false;
var myTrueBool = true;

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

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

Sie können es in einer jsFiddle testen .

Ich habe einen JSperf- Vergleich aller vorgeschlagenen Antworten erstellt.

TL; DR - die beste Option für alle aktuellen Browser ist:

val | 0;

.

Aktualisieren:

Es scheint, dass sie heutzutage alle ziemlich identisch sind, außer dass die Number()Funktion die langsamste und die beste ist val === true ? 1 : 0;.

Der typisierte Weg, dies zu tun, wäre:

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

Ich bin heute gerade auf diese Abkürzung gestoßen.

~~ (wahr)

~~ (falsch)

Leute viel schlauer als ich erklären kann:

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

Wenn JavaScript einen Zahlenwert erwartet, aber stattdessen einen Booleschen Wert empfängt, wird dieser Boolesche Wert in eine Zahl konvertiert: true und false konvertieren in 1 bzw. 0. Sie können dies also nutzen.

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

Lesen Sie weiter Typ Conversions Kapitel 3.8 des Definitiven Handbuchs zu Javascript.

Der unäre +Operator wird sich darum kümmern:

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

Sie sollten dies natürlich vor dem Speichern auf dem Server überprüfen, damit dies ohnehin sinnvoller ist.

Ich habe mich gerade mit diesem Problem in einem Code befasst, den ich geschrieben habe. Meine Lösung war, ein bitweises und zu verwenden.

var j = bool & 1;

Ein schnellerer Weg, um ein ständiges Problem zu lösen, wäre das Erstellen einer Funktion. Es ist für andere besser lesbar, besser für das Verständnis in der Wartungsphase und beseitigt das Potenzial, etwas Falsches zu schreiben.

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

var j = toInt(bool);

Bearbeiten - 10. September 2014

Aus irgendeinem Grund ist in Chrome keine Konvertierung mit einem ternären Operator, der mit dem Operator identisch ist, schneller. Es macht keinen Sinn, warum es schneller ist, aber ich nehme an, es ist eine Art Low-Level-Optimierung, die irgendwo auf dem Weg Sinn macht.

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

Testen Sie selbst: http://jsperf.com/boolean-int-conversion/2

In FireFox und Internet Explorer ist die Verwendung der von mir veröffentlichten Version im Allgemeinen schneller.

Bearbeiten - 14. Juli 2017

Okay, ich werde dir nicht sagen, welches du verwenden sollst oder nicht. Jeder verdammte Browser hat sich auf und ab bewegt, wie schnell er die Operation mit jeder Methode ausführen kann. In Chrome war die bitweise Version besser als die anderen, aber dann war es plötzlich viel schlimmer. Ich weiß nicht, was sie tun, also werde ich es einfach bei wem belassen. Es gibt selten einen Grund, sich darum zu kümmern, wie schnell eine solche Operation durchgeführt wird. Selbst auf dem Handy ist es eine Nichts-Operation.

Hier ist auch eine neuere Methode zum Hinzufügen eines 'toInt'-Prototyps, der nicht überschrieben werden kann.

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

Sie können auch 0 hinzufügen, Shift-Operatoren oder xor verwenden:

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

Diese haben ähnliche Geschwindigkeiten wie die anderen Antworten.

In meinem Kontext ist React Native, wo ich den Opazitätswert vom Booleschen Wert erhalte, der einfachste Weg: Verwenden Sie den Operator unary +.

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

Dies wandelt den Booleschen Wert in eine Zahl um.

style={ opacity: +!isFirstStep() }

Sie können dies tun, indem Sie einfach den booleschen Prototyp erweitern

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

Es ist nicht leicht zu verstehen, was dort vor sich geht, also wäre eine alternative Version

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

getan zu haben, was man so machen kann

document.write(true.intval());

Wenn ich Boolesche Werte zum Speichern von Bedingungen verwende, konvertiere ich sie häufig in Bitfelder. In diesem Fall verwende ich eine erweiterte Version der Prototypfunktion

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

womit du machen kannst

document.write(true.intval(2))

welches 4 als seine Ausgabe erzeugt.

let integerVariable = booleanVariable * 1;

Versuchen

val*1

let t=true;
let f=false;

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

Ich habe alle diese Beispiele getestet, einen Benchmark durchgeführt und schließlich empfehle ich Ihnen, den kürzeren zu wählen, da dies keinen Einfluss auf die Leistung hat.

Wird in Ubuntu Server 14.04 ausgeführt, 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")

Ergebnis

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

Wenn Sie möchten, dass sich der ganzzahlige x-Wert ändert, wenn 1 bis 0 und wenn 0 bis 1, können Sie (x + 1)% 2 verwenden