Konvertieren Sie das boolesche Ergebnis in Zahl / Ganzzahl

275

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

hd.
quelle
8
Hier ist ein Leistungsvergleich einiger der bereitgestellten Techniken: jsperf.com/conversion-from-boolean-to-number .
Sam
4
Node.JS- Benutzer werden es verwenden wollen bool === true ? 1 : 0, da es bei weitem das schnellste in V8 ist.
Qix - MONICA wurde am
3
oder einfachbool ? 1 : 0;
Atrahasis

Antworten:

343

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

var i = result ? 1 : 0;
Andy Rose
quelle
7
Beste Antwort. Warum? Dies funktioniert bei Wahrheiten, die allgemeiner sind und jeden Typ (Zeichenfolge, Zahl usw.) akzeptieren. Die unäre Antwort ist zwar klug, aber wenn ich ihr eine Zeichenfolge übergebe, wird sie zurückgegeben NaN. Wenn Sie also L33T möchten und die Eingabe garantieren möchten, gehen Sie urary, andernfalls ist der ternäre + Wahrheitstest am besten.
Gdibble
465

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.

einsamer Tag
quelle
50
Obwohl cool (ich hatte noch nie daran gedacht), ist es unglaublich langsam (97% langsamer in Chrome, um genau zu sein). Sei vorsichtig!
Qix - MONICA wurde am
5
Schauen Sie sich diese Revision an . Number()ist noch langsamer.
Qix - MONICA wurde am
23
Es scheint bool === true ? 1 : 0das schnellste zu sein, mit einer knappen Sekunde von bool | 0.
Qix - MONICA wurde am
1
Multiplizieren (zB 3 * falsch) fühlt sich so falsch an, aber es funktioniert. :) Vielen Dank!
Mattsoave
1
@DerkJanSpeelman Die Tatsache, dass etwas in Typescript nicht erlaubt ist, bedeutet nicht, dass Sie es nicht in Javascript tun sollten. Sie sind verschiedene (wenn auch verwandte) Sprachen.
einsamer
119

Imho die beste Lösung ist:

fooBar | 0

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

kralyk
quelle
Einer der schnellsten; +1.
Qix - MONICA wurde am
3
Schön. Sie können auch "Boolean ^ 0" verwenden. OR oder XOR funktioniert.
F8ER
Dies wird keine 1Ganzzahl zurückgeben, wenn fooBar nicht ist?
ESR
58

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 .

René
quelle
3
Dies ist bei weitem die beste Antwort. Ganz unten natürlich. Nur "es braucht ein Objekt" ist nicht richtig.
Rudie
2
Der Link zu mdn ist viel besser als w3schools (eeek!): Developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
Olivvv
Ich denke, das ist der beste Weg, weil es leicht zu lesen und aufschlussreich ist.
Sam
3
Es ist auch das langsamste.
Qix - MONICA wurde am
45

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

Gal Talmor
quelle
2
Interessanterweise ist das Ternär jetzt in Chrome 64.0.3282 unter macOS 10.13.3 am schnellsten.
2540625
Das wäre zu dieser Zeit die schnellste Option. Das unterscheidet sich davon, dass es die beste Option ist.
Mikemaccana
41

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

Number(true) // 1
Number(false) // 0
Philip
quelle
2
Endlich eine anständige Antwort. Vielen Dank.
Erik Campobadal
30

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/

Tonyjcamp
quelle
2
Interessant. Ich habe heute etwas Neues gelernt. Ich werde diese Technik jedoch in keinem Projekt anwenden, da sie das zukünftige Ich oder meine Teamkollegen verwirren kann.
Nicholaides
1
hacky js ist mein Favorit. Ernsthaft, +1
Todd
16

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.

Charlie Lynch
quelle
13

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.

Gustav Barkefors
quelle
Ich habe die Kommentare in geändert ===, weil true == 1es auch ohne die "explizite Konvertierung wahr ist :-) ist true === 1stattdessen falsch.
Xanatos
13

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;
}});
Nicholas R. Grant
quelle
Ich habe zwei Downvotes für diesen Beitrag erhalten. Warum erklärst du nicht, warum du es abgelehnt hast? Ansonsten ist es nur eine Ablehnung ohne Begründung.
Nicholas R. Grant
1
Das 99-fache der Ergebnisse von jsperf führt Sie nur auf den vorzeitigen Optimierungspfad und optimiert Nanosekunden außerhalb einer Schleife, wenn Sie sich stattdessen auf diese hässliche SQL-Anweisung konzentrieren sollten.
Vielen
Welche SQL-Anweisung? Hier gibt es keine einzige Abfrage. Wenn Sie sich auf JSPerf beziehen, habe ich das aus dem Test eines anderen verknüpft. Es ist nicht mein eigenes. Der Leistungsaspekt ist mir ehrlich gesagt egal, da es sich um eine Nichts-Operation handelt. Ich habe meine eigene Sprache erstellt, die fast identisch mit JS war, und ich erinnere mich, dass das Casting in int eine dumm schnelle Operation war. Kletternde Prototypketten gab es nicht. Aus diesem Grund würde ich immer noch empfehlen, wie ich es zuerst gemacht habe, mit einer einfachen Funktion, die vom Compiler eingefügt werden kann.
Nicholas R. Grant
Das SQL-Ding war eine Verallgemeinerung. danke für den Einblick
RozzA
9

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.

REMqb
quelle
6

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() }
Jose Velasco
quelle
4

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.

DroidOS
quelle
4
let integerVariable = booleanVariable * 1;
Esger
quelle
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
DarckBlezzer
quelle
0

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

şevket Karayılan
quelle