Deklarowanie wartości logicznej w JavaScript przy użyciu po prostu var

Jeśli zadeklaruję zmienną logiczną JavaScript, taką jak ta:

var IsLoggedIn;

A następnie zainicjuj go za pomocą jednego z nich, trueczy 1to jest bezpieczne? A może zainicjowanie go za pomocą 1spowoduje, że zmienna będzie liczbą?

Typy zależą od Twojej inicjalizacji:

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

Ale spójrz na ten przykład:

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

Typ Twoich zmiennych zależy od wartości przypisanej w JavaScript.

Nie, to nie jest bezpieczne. Możesz później zrobić var, IsLoggedIn = "Foo";a JavaScript nie zgłosi błędu.

Można to zrobić

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

Możesz również przekazać zmienną new Boolean()inną niż boolowska do zmiennej, a to sprawi, że IsLoggedIn będzie wartością logiczną.

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

Jak mówi ten bardzo przydatny samouczek :

var age = 0;

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

// good
var hasAge = Boolean(age);

// good
var hasAge = !!age;

Jeśli chcesz IsLoggedInbyć traktowany jako boolean, powinieneś zainicjować w następujący sposób:

var IsLoggedIn=true;

Jeśli zainicjujesz go z var IsLoggedIn=1;, będzie traktowany jako liczba całkowita.

Jednak w dowolnym momencie zmienna IsLoggedInmoże odnosić się do innego typu danych:

 IsLoggedIn="Hello World";

Nie spowoduje to błędu.

Państwo może używać i testy niezainicjowanymi zmienne przynajmniej dla ich „definedness”. Lubię to:

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

Ponadto istnieje wiele możliwości: jeśli nie jesteś zainteresowany dokładnymi typami, użyj operatora '==' (lub! [Zmienna] / !! [zmienna]) do porównania (tak Douglas Crockford nazywa „prawda” lub „ fałszywe '' chyba). W takim przypadku przypisanie wartości true, 1 lub „1” do zjednoliconej zmiennej zawsze zwraca prawdę, gdy zostaniesz o to poproszony. W przeciwnym razie [jeśli potrzebujesz bezpiecznego porównania typów] użyj '===' dla porównania.

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: nie można jednak przetestować „zdefiniowania” dla nieistniejących zmiennych. Więc:

alert(!!HelloWorld);

podaje błąd odniesienia („HelloWorld nie jest zdefiniowany”)

(czy jest lepsze słowo na określenie `` definiowalności ''? Mimo wszystko przepraszam za mój holenderski; ~)

Zmienne w JavaScript nie mają typu. Niezerowe, niezerowe, niepuste i true„prawdziwe”. Zero, null, undefined, pusty ciąg i falsemają wartość „false”.

Istnieje jednak typ Boolean, podobnie jak dosłowne truei false.

Co powiesz na coś takiego:

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

Następnie możesz go użyć w ten sposób:

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

Nie testowałem tego pod kątem wydajności, ale konwersja z typu na typ nie powinna zdarzać się zbyt często, w przeciwnym razie otworzysz aplikację na dużą niestabilność!

Zmienna stanie się tym, czym kiedykolwiek ją przypiszesz. Na początku tak jest undefined. Jeśli go przypiszesz, 'true'stanie się łańcuchem, jeśli go przypiszesz true, stanie się wartością logiczną, jeśli go przypiszesz 1, stanie się liczbą. Kolejne przypisania mogą później zmienić typ zmiennej.