Deklarieren eines Booleschen Werts in JavaScript mit nur var

Wenn ich eine boolesche JavaScript-Variable wie folgt deklariere:

var IsLoggedIn;

Und dann initialisiere es mit entweder trueoder 1, ist das sicher? Oder wird beim Initialisieren 1die Variable zu einer Zahl?

Die Typen hängen von Ihrer Initialisierung ab:

var IsLoggedIn1 = "true"; //string
var IsLoggedIn2 = 1; //integer
var IsLoggedIn3 = true; //bool

Aber schauen Sie sich dieses Beispiel an:

var IsLoggedIn1 = "true"; //string
IsLoggedIn1 = true; //now your variable is a boolean

Der Typ Ihrer Variablen hängt vom zugewiesenen Wert in JavaScript ab.

Nein, es ist nicht sicher. Sie könnten später var tun IsLoggedIn = "Foo";und JavaScript wird keinen Fehler auslösen.

Es ist möglich zu tun

var IsLoggedIn = new Boolean(false);
var IsLoggedIn = new Boolean(true);

Sie können auch die nicht-boolesche Variable an übergeben new Boolean(), wodurch IsLoggedIn boolesch wird.

var IsLoggedIn = new Boolean(0); // false
var IsLoggedIn = new Boolean(NaN); // false
var IsLoggedIn = new Boolean("Foo"); // true
var IsLoggedIn = new Boolean(1); // true

Wie dieses sehr nützliche Tutorial sagt:

var age = 0;

// bad
var hasAge = new Boolean(age);

// good
var hasAge = Boolean(age);

// good
var hasAge = !!age;

Wenn Sie IsLoggedInals Boolescher Wert behandelt werden möchten , sollten Sie Folgendes initialisieren:

var IsLoggedIn=true;

Wenn Sie es mit initialisieren, var IsLoggedIn=1;wird es als Ganzzahl behandelt.

Die Variable kann sich jedoch IsLoggedInjederzeit auf einen anderen Datentyp beziehen:

 IsLoggedIn="Hello World";

Dies verursacht keinen Fehler.

Sie können nicht initialisierte Variablen verwenden und zumindest auf ihre 'Definiertheit' testen. So was:

var iAmNotDefined;
alert(!iAmNotDefined); //true
//or
alert(!!iAmNotDefined); //false

Darüber hinaus gibt es viele Möglichkeiten: Wenn Sie nicht an genauen Typen interessiert sind, verwenden Sie den Operator '==' (oder! [Variable] / !! [Variable]) zum Vergleich (das nennt Douglas Crockford 'wahr' oder ') Falschheit 'denke ich). In diesem Fall gibt das Zuweisen von true oder 1 oder '1' zur unitialisierten Variablen immer true zurück, wenn Sie dazu aufgefordert werden. Andernfalls [wenn Sie einen typsicheren Vergleich benötigen] verwenden Sie '===' zum Vergleich.

var thisMayBeTrue;

thisMayBeTrue = 1;
alert(thisMayBeTrue == true); //=> true
alert(!!thisMayBeTrue); //=> true
alert(thisMayBeTrue === true); //=> false

thisMayBeTrue = '1';
alert(thisMayBeTrue == true); //=> true 
alert(!!thisMayBeTrue); //=> true
alert(thisMayBeTrue === true); //=> false
// so, in this case, using == or !! '1' is implicitly 
// converted to 1 and 1 is implicitly converted to true)

thisMayBeTrue = true;
alert(thisMayBeTrue == true); //=> true
alert(!!thisMayBeTrue); //=> true
alert(thisMayBeTrue === true); //=> true

thisMayBeTrue = 'true';
alert(thisMayBeTrue == true); //=> false
alert(!!thisMayBeTrue); //=> true
alert(thisMayBeTrue === true); //=> false
// so, here's no implicit conversion of the string 'true'
// it's also a demonstration of the fact that the 
// ! or !! operator tests the 'definedness' of a variable.

PS: Sie können die 'Definiertheit' jedoch nicht auf nicht vorhandene Variablen testen. So:

alert(!!HelloWorld);

gibt einen Referenzfehler an ('HelloWorld ist nicht definiert')

(Gibt es ein besseres Wort für "Definiertheit"? Verzeihen Sie meinen Holländern trotzdem; ~)

Variablen in Javascript haben keinen Typ. Nicht Null, nicht Null, nicht leer und truesind "wahr". Null, null, undefiniert, leere Zeichenfolge und falsesind "falsch".

Es gibt jedoch einen booleschen Typ, ebenso wie Literale trueund false.

Wie wäre es mit so etwas:

var MyNamespace = {
    convertToBoolean: function (value) {
        //VALIDATE INPUT
        if (typeof value === 'undefined' || value === null) return false;

        //DETERMINE BOOLEAN VALUE FROM STRING
        if (typeof value === 'string') {
            switch (value.toLowerCase()) {
                case 'true':
                case 'yes':
                case '1':
                    return true;
                case 'false':
                case 'no':
                case '0':
                    return false;
            }
        }

        //RETURN DEFAULT HANDLER
        return Boolean(value);
    }
};

Dann können Sie es so verwenden:

MyNamespace.convertToBoolean('true') //true
MyNamespace.convertToBoolean('no') //false
MyNamespace.convertToBoolean('1') //true
MyNamespace.convertToBoolean(0) //false

Ich habe es nicht auf Leistung getestet, aber die Konvertierung von Typ zu Typ sollte nicht zu oft erfolgen, sonst öffnen Sie Ihre App bis zur Instabilität!

Die Variable wird zu dem Typ, den Sie ihr zuweisen. Anfangs ist es so undefined. Wenn Sie es zuweisen, wird 'true'es zu einer Zeichenfolge, wenn Sie es zuweisen, wird truees zu einem Booleschen Wert. Wenn Sie es zuweisen, wird 1es zu einer Zahl. Nachfolgende Zuweisungen können den Typ der Variablen später ändern.