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

Question

Si je déclare une variable booléenne JavaScript comme ceci:

var IsLoggedIn;

Et initialisez-le avec true ou 1 , est-ce sûr? Ou l'initialiser avec 1 transformera-t-il la variable en nombre?

Answer 1

Les types dépendent de votre initialisation:

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

Mais jetez un oeil à 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 en JavaScript.

Answer 2

Non, ce n’est pas sûr. Vous pourrez faire plus tard 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 rend IsLoggedIn boolean.

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

Answer 3

Comme ce didacticiel très utile dit:

var age = 0;

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

// good
var hasAge = Boolean(age);

// good
var hasAge = !!age;

Answer 4

Si vous souhaitez que IsLoggedIn soit 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 IsLoggedIn peut faire référence à un type de données différent:

 IsLoggedIn="Hello World";

Cela ne causera pas d'erreur.

Answer 5

Vous pouvez utiliser et tester des variables non initialisées au moins pour leur "définition". Comme ceci:

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 "la vérité" 'ou' fausseté 'je pense). Dans ce cas, affecter true ou 1 ou '1' à la variable unitialisée renvoie toujours true lorsque demandé. Sinon [si vous avez besoin d'une comparaison de type sûre], utilisez '===' pour 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 cependant pas tester la «définition» pour des variables inexistantes. Donc:

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 mon néerlandais de toute façon; ~)

Answer 6

Les variables en Javascript n'ont pas de type. Non nul, non nul, non vide et true sont "vrais". Zéro, null, non défini, chaîne vide et false sont "faux".

Il existe cependant un type booléen, de même que les littéraux true et false .

Answer 7

Que diriez-vous de 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 n'ai pas testé ses performances, mais la conversion de type en type ne devrait pas arriver trop souvent, sinon vous ouvrez votre application à une instabilité extrême!

Answer 8

La variable deviendra quel que soit le type que vous lui affectez. Au départ, il s'agit de undefined . Si vous l'attribuez 'true' , il deviendra une chaîne. Si vous l'attribuez vrai , il deviendra un booléen, si vous l'attribuez 1 . cela deviendra un numéro. Les affectations suivantes peuvent changer le type de la variable ultérieurement.