Declarar un booleano en JavaScript usando solo var

Si declaro una variable booleana de JavaScript como esta:

var IsLoggedIn;

Y luego inicializarlo con trueo 1, ¿es seguro? ¿O inicializarlo con 1hará que la variable sea un número?

Los tipos dependen de su inicialización:

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

Pero mire este ejemplo:

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

El tipo de sus variables depende del valor asignado en JavaScript.

No, no es seguro. Más tarde, podría hacer var IsLoggedIn = "Foo";y JavaScript no arrojará un error.

Es posible hacer

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

También puede pasar la variable no booleana al new Boolean()y hará que IsLoggedIn sea 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

Como dice este tutorial muy útil :

var age = 0;

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

// good
var hasAge = Boolean(age);

// good
var hasAge = !!age;

Si desea IsLoggedInser tratado como un booleano, debe inicializar de la siguiente manera:

var IsLoggedIn=true;

Si lo inicializa con var IsLoggedIn=1;, se tratará como un número entero.

Sin embargo, en cualquier momento, la variable IsLoggedInpodría referirse a un tipo de datos diferente:

 IsLoggedIn="Hello World";

Esto no provocará ningún error.

Usted puede usar y probar las variables sin inicializar al menos por su 'definedness'. Me gusta esto:

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

Además, hay muchas posibilidades: si no está interesado en los tipos exactos, use el operador '==' (o! [Variable] / !! [variable]) para comparar (eso es lo que Douglas Crockford llama 'verdadero' o ' falso ', creo). En ese caso, asignar verdadero o 1 o '1' a la variable unitaria siempre devuelve verdadero cuando se le pregunta. De lo contrario, [si necesita una comparación segura de tipos] use '===' para comparar.

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.

PD: sin embargo, no se puede probar la 'definición' para las variables inexistentes. Entonces:

alert(!!HelloWorld);

da un error de referencia ('HelloWorld no está definido')

(¿Hay una palabra mejor para 'definición'? Perdón por mi holandés de todos modos; ~)

Las variables en Javascript no tienen un tipo. No cero, no nulo, no vacío y trueson "verdaderos". Cero, nulo, indefinido, cadena vacía yfalse son "falsos".

Sin embargo, hay un tipo booleano, al igual que los literales truey false.

Qué tal algo como esto:

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

Entonces puedes usarlo así:

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

No he probado su rendimiento, pero la conversión de un tipo a otro no debería suceder con demasiada frecuencia, de lo contrario, ¡abrirás tu aplicación a la inestabilidad a lo grande!

La variable se convertirá en el tipo que le asigne. Inicialmente lo es undefined. Si lo asigna se 'true'convertirá en una cadena, si lo asigna se trueconvertirá en un booleano, si lo asigna se 1convertirá en un número. Las asignaciones posteriores pueden cambiar el tipo de la variable más adelante.