web-dev-qa-db-fra.com

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

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

var IsLoggedIn;

Et puis initialisez-le avec true ou 1, est-ce sécuritaire? Ou l'initialisera-t-il avec 1 faire de la variable un nombre?

javascriptboolean
87
mrblah

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.

159
Canavar

Non ce n'est pas sûr. Vous pourriez faire plus tard var IsLoggedIn = "Foo"; Et JavaScript ne lançera 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 la 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
19
Ólafur Waage

Comme ceci tutoriel très utile dit:

var age = 0;

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

// good
var hasAge = Boolean(age);

// good
var hasAge = !!age;
8
pavv

Si vous voulez que IsLoggedIn soit traité comme un booléen, vous devez initialiser comme suit:

var IsLoggedIn=true;

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

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

 IsLoggedIn="Hello World";

Cela ne causera pas d'erreur.

7
zpesk

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

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

En outre, il existe de nombreuses possibilités: si vous n'êtes pas intéressé par les types exacts, utilisez l'opérateur '==' (ou! [Variable]/!! [variable]) à des fins de comparaison (c'est ce que Douglas Crockford appelle 'vérité' ou ' la 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 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 mon néerlandais de toute façon; ~)

5
KooiInc

Les variables en Javascript n'ont pas de type. Non nul, non nul, non vide et true sont "vrais". Zéro, null, indé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.

2
Eugene Morozov

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ée pour la performance, mais la conversion de type en type ne devrait pas arriver trop souvent, sinon vous ouvrez votre application à une instabilité extrême!

2
TruMan1

La variable deviendra quel que soit le type que vous lui affectez. Au départ, il s’agit de undefined. Si vous l'assignez 'true' il deviendra une chaîne, si vous l’attribuez true 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.

1
AnthonyWJones