Declarando um booleano em JavaScript usando apenas var

Se eu declarar uma variável booleana JavaScript como esta:

var IsLoggedIn;

E então inicialize-o com trueou 1, isso é seguro? Ou inicializá-lo com 1tornar a variável um número?

Os tipos dependem da sua inicialização:

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

Mas dê uma olhada neste exemplo:

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

O tipo de suas variáveis ​​depende do valor atribuído em JavaScript.

Não, não é seguro. Você pode fazer var mais tarde IsLoggedIn = "Foo";e o JavaScript não gerará um erro.

É possível fazer

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

Você também pode passar a variável não booleana para o new Boolean()e isso tornará 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

Como este tutorial muito útil diz:

var age = 0;

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

// good
var hasAge = Boolean(age);

// good
var hasAge = !!age;

Se você quiser IsLoggedInser tratado como um booleano, deve inicializar da seguinte maneira:

var IsLoggedIn=true;

Se você inicializar com var IsLoggedIn=1;, ele será tratado como um número inteiro.

No entanto, a qualquer momento, a variável IsLoggedInpode se referir a um tipo de dados diferente:

 IsLoggedIn="Hello World";

Isso não causará erro.

Você pode usar e testar variáveis ​​não inicializadas pelo menos quanto à sua 'definição'. Como isso:

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

Além disso, existem muitas possibilidades: se você não estiver interessado em tipos exatos, use o operador '==' (ou! [Variável] / !! [variável]) para comparação (isso é o que Douglas Crockford chama de 'verdadeiro' ou ' falsy 'eu acho). Nesse caso, atribuir verdadeiro ou 1 ou '1' à variável unificada sempre retorna verdadeiro quando solicitado. Caso contrário [se você precisar de uma comparação segura de tipo] use '===' para comparação.

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: você não pode testar 'definição' para variáveis ​​não existentes. Assim:

alert(!!HelloWorld);

dá um erro de referência ('HelloWorld não está definido')

(existe uma palavra melhor para 'definição'? Perdoe meu holandês de qualquer maneira; ~)

As variáveis ​​em Javascript não têm um tipo. Diferentes de zero, não nulos, não vazios e truesão "verdadeiros". Zero, null, undefined, string vazia e falsesão "falsos".

Porém, há um tipo booleano, assim como literais truee false.

Que tal algo como isso:

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

Então você pode usá-lo assim:

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

Eu não testei o desempenho, mas a conversão de um tipo para outro não deve acontecer com muita frequência, caso contrário, você abrirá seu aplicativo até a instabilidade!

A variável se tornará o tipo que você atribuir a ela. Inicialmente é undefined. Se você atribuí- 'true'lo , ele se tornará uma string, se você atribuí- truelo , ele se tornará um booleano, se você atribuí- 1lo , ele se tornará um número. As atribuições subsequentes podem alterar o tipo da variável posteriormente.