Dichiarare un booleano in JavaScript usando solo var

Se dichiaro una variabile booleana JavaScript come questa:

var IsLoggedIn;

E poi inizializzalo con trueo 1, è sicuro? O l'inizializzazione con 1renderà la variabile un numero?

I tipi dipendono dalla tua inizializzazione:

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

Ma dai un'occhiata a questo esempio:

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

Il tipo di variabili dipende dal valore assegnato in JavaScript.

No, non è sicuro. Successivamente potresti eseguire var IsLoggedIn = "Foo";e JavaScript non genererà un errore.

È possibile farlo

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

Puoi anche passare la variabile non booleana in new Boolean()e renderà IsLoggedIn booleano.

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

Come dice questo tutorial molto utile :

var age = 0;

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

// good
var hasAge = Boolean(age);

// good
var hasAge = !!age;

Se vuoi IsLoggedInessere trattato come booleano dovresti inizializzare come segue:

var IsLoggedIn=true;

Se lo si inizializza con var IsLoggedIn=1;, verrà trattato come un numero intero.

Tuttavia in qualsiasi momento la variabile IsLoggedInpotrebbe fare riferimento a un diverso tipo di dati:

 IsLoggedIn="Hello World";

Ciò non causerà un errore.

È possibile utilizzare e testare variabili non inizializzate almeno per la loro "definizione". Come questo:

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

Inoltre, ci sono molte possibilità: se non sei interessato ai tipi esatti usa l'operatore '==' (o! [Variabile] / !! [variabile]) per il confronto (questo è ciò che Douglas Crockford chiama 'verità' o ' falsy 'credo). In tal caso, l'assegnazione di true o 1 o "1" alla variabile unitializzata restituisce sempre true quando richiesto. Altrimenti [se hai bisogno di un confronto sicuro dei tipi] usa '===' per il confronto.

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: non puoi testare la "definizione" per variabili inesistenti. Così:

alert(!!HelloWorld);

restituisce un errore di riferimento ("HelloWorld non è definito")

(esiste una parola migliore per 'definizione'? Perdonate comunque il mio olandese; ~)

Le variabili in Javascript non hanno un tipo. Diverso da zero, non nullo, non vuoto e truesono "veri". Zero, null, undefined, stringa vuota e falsesono "false".

C'è un tipo booleano, così come i letterali truee false.

Che ne dici di qualcosa del genere:

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

Quindi puoi usarlo in questo modo:

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

Non l'ho testato per le prestazioni, ma la conversione da tipo a tipo non dovrebbe avvenire troppo spesso altrimenti apri la tua app fino a instabilità alla grande!

La variabile diventerà il tipo che le assegni. Inizialmente lo è undefined. Se lo assegni 'true'diventerà una stringa, se lo assegni truediventerà un booleano, se lo assegni 1diventerà un numero. Le assegnazioni successive possono modificare il tipo della variabile in un secondo momento.