Déclarer un booléen en JavaScript en utilisant uniquement var

Si je déclare une variable booléenne JavaScript comme celle-ci:

var IsLoggedIn;

Et puis initialisez-le avec trueou 1, est-ce sûr? Ou est-ce que l'initialiser avec 1fera de la variable un nombre?

Les types dépendent de votre initialisation:

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

Mais jetez un œil à cet exemple:

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

Le type de vos variables dépend de la valeur attribuée dans JavaScript.

Non, ce n'est pas sûr. Vous pourrez plus tard faire var IsLoggedIn = "Foo";et JavaScript ne générera pas d'erreur.

Il est possible de faire

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

Vous pouvez également passer la variable non booléenne dans le new Boolean()et cela rendra IsLoggedIn booléen.

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

Comme le dit ce tutoriel très utile :

var age = 0;

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

// good
var hasAge = Boolean(age);

// good
var hasAge = !!age;

Si vous voulez IsLoggedInêtre traité comme un booléen, vous devez initialiser comme suit:

var IsLoggedIn=true;

Si vous l'initialisez avec, var IsLoggedIn=1;il sera traité comme un entier.

Cependant, à tout moment, la variable IsLoggedInpeut faire référence à un type de données différent:

 IsLoggedIn="Hello World";

Cela ne provoquera pas d'erreur.

Vous pouvez utiliser et tester des variables non initialisées au moins pour leur «définition». Comme ça:

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

De plus, il existe de nombreuses possibilités: si vous n'êtes pas intéressé par les types exacts, utilisez l'opérateur '==' (ou! [Variable] / !! [variable]) pour la comparaison (c'est ce que Douglas Crockford appelle 'vérité' ou ' faux 'je pense). Dans ce cas, l'affectation de true ou 1 ou '1' à la variable unifiée retourne toujours true quand on lui demande. Sinon [si vous avez besoin d'une comparaison sûre de type], utilisez '===' pour la comparaison.

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: vous ne pouvez pas tester la «définition» pour des variables non existantes. Alors:

alert(!!HelloWorld);

donne une erreur de référence ('HelloWorld n'est pas défini')

(Y a-t-il un meilleur mot pour `` définition ''? Pardonnez-moi quand même mon néerlandais; ~)

Les variables en Javascript n'ont pas de type. Non nul, non nul, non vide et truesont "vrais". Zéro, nul, indéfini, chaîne vide et falsesont "faux".

Il existe cependant un type booléen, tout comme les littéraux trueet false.

Que diriez-vous quelque chose comme ça:

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

Ensuite, vous pouvez l'utiliser comme ceci:

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

Je ne l'ai pas testé pour les performances, mais la conversion de type en type ne devrait pas se produire trop souvent, sinon vous ouvrez votre application à une grande instabilité!

La variable deviendra le type que vous lui attribuez. Au départ, ça l'est undefined. Si vous l'assignez, 'true'il deviendra une chaîne, si vous l'assignez, trueil deviendra un booléen, si vous l'assignez, 1il deviendra un nombre. Les affectations ultérieures peuvent changer le type de la variable ultérieurement.