Sprawdzanie JavaScript pod kątem wartości null vs. niezdefiniowana oraz różnicy między == a ===

1. Jak sprawdzić zmienną, jeśli jest nulllub undefinedjaka jest różnica między nulli undefined?

2. Jaka jest różnica między ==i ===(trudno wyszukiwać w Google „===”)?

Jak sprawdzić zmienną, jeśli jest nulllub undefined...

Czy zmienna null:

if (a === null)
// or
if (a == null) // but see note below

... ale zauważ, że to ostatnie będzie również prawdą, jeśli tak ajest undefined.

Czy to jest undefined:

if (typeof a === "undefined")
// or
if (a === undefined)
// or
if (a == undefined) // but see note below

... ale znowu zauważ, że ostatni jest niejasny; będzie to również prawdą, jeśli tak ajest null.

Teraz, pomimo powyższego, zwykłym sposobem na sprawdzenie tych jest skorzystanie z faktu, że są falsey :

if (!a) {
    // `a` is falsey, which includes `undefined` and `null`
    // (and `""`, and `0`, and `NaN`, and [of course] `false`)
}

Jest to zdefiniowane przez ToBoolean w specyfikacji.

... a jaka jest różnica między nulli undefined?

Obie wartości są zwykle używane do wskazania braku czegoś. undefinedjest bardziej ogólna, używana jako domyślna wartość zmiennych, dopóki nie zostanie im przypisana inna wartość, jako wartość argumentów funkcji, które nie zostały podane, gdy funkcja została wywołana, i jako wartość, którą otrzymujesz, gdy pytasz obiekt dla nieruchomości, której nie ma. Ale może być również wyraźnie użyte we wszystkich tych sytuacjach. (Istnieje różnica między obiektem nieposiadającym właściwości a posiadaniem właściwości z wartością undefined; istnieje różnica między wywołaniem funkcji z wartością undefinedargumentu, a całkowitym pominięciem tego argumentu).

nulljest nieco bardziej szczegółowy niż undefined: Jest to odwołanie do pustego obiektu. JavaScript jest oczywiście luźno wpisany, ale nie wszystkie rzeczy, z którymi JavaScript wchodzi w interakcje, są luźno wpisane. Jeśli interfejs API, taki jak DOM w przeglądarkach, wymaga odwołania do obiektu, które jest puste, używamy go nullnie undefined. Podobnie getElementByIdoperacja DOM zwraca odwołanie do obiektu - albo poprawne (jeśli znalazło element DOM), albo null(jeśli nie znalazło ).

Co ciekawe (lub nie), są to ich własne typy. Oznacza to, że nulljest jedyną wartością typu Null i undefinedjedyną wartością typu Undefined.

Jaka jest różnica między „==” a „===”

Jedyna różnica między nimi polega na tym ==, że spowoduje przymus typu, aby spróbować dopasować wartości, i ===nie będzie. Tak na przykład "1" == 1jest to prawda, ponieważ "1"wymusza 1. Ale "1" === 1to fałsz , ponieważ typy nie pasują. ( "1" !== 1jest prawdą). Pierwszym (prawdziwym) krokiem ===jest „Czy typy operandów są takie same?” a jeśli odpowiedź brzmi „nie”, wynikiem jest false. Jeśli typy są takie same, robi dokładnie to, co ==robi.

Koercja typów wykorzystuje dość złożone reguły i może mieć zaskakujące wyniki (na przykład "" == 0jest to prawda).

Więcej w specyfikacji:

• Abstrakcyjne porównanie równości ( ==zwane również „luźną” równością)
• Porównanie ścisłej równości ( ===)

Różnica jest subtelna.

W JavaScript undefinedzmienna jest zmienną, która nigdy nie została zadeklarowana ani nigdy nie przypisała wartości. Załóżmy, że var a;na przykład deklarujesz , bo tak się astanie undefined, ponieważ nigdy nie przypisano żadnej wartości.

Ale jeśli wtedy przydzielisz, a = null;to ateraz będzie null. W JavaScript nulljest obiekt (spróbuj typeof nullw konsoli JavaScript, jeśli mi nie wierzysz), co oznacza, że ​​null jest wartością (w rzeczywistości nawet undefinedjest wartością).

Przykład:

var a;
typeof a;     # => "undefined"

a = null;
typeof null;  # => "object"

Może to okazać się przydatne w argumentach funkcji. Możesz chcieć mieć wartość domyślną, ale uważaj null za dopuszczalny. W takim przypadku możesz:

function doSomething(first, second, optional) {
    if (typeof optional === "undefined") {
        optional = "three";
    }
    // do something
}

Jeśli pominiesz optionalparametr, doSomething(1, 2) thenopcjonalny będzie "three"ciąg, ale jeśli przejdziesz, doSomething(1, 2, null)opcjonalny będzie null.

Jeśli chodzi o równe ==i ściśle równe ===komparatory, pierwszy jest słabo typowy, podczas gdy ściśle równy sprawdza również typ wartości. Oznacza to, że 0 == "0"zwróci się prawda; while 0 === "0"zwróci false, ponieważ liczba nie jest łańcuchem.

Użytkownik może korzystać z tych operatorów, by sprawdzić między . Na przykład:undefinednull

null === null            # => true
undefined === undefined  # => true
undefined === null       # => false
undefined == null        # => true

Ostatni przypadek jest interesujący, ponieważ pozwala sprawdzić, czy zmienna jest niezdefiniowana lub pusta i nic więcej:

function test(val) {
    return val == null;
}
test(null);       # => true
test(undefined);  # => true

Specyfikacja jest miejscem, w którym można uzyskać pełne odpowiedzi na te pytania. Oto podsumowanie:

1. W przypadku zmiennej xmożesz:
   
   
   • sprawdź, czy to nullprzez bezpośrednie porównanie za pomocą ===. Przykład:x === null
   • sprawdź, czy jest to undefinedjedna z dwóch podstawowych metod: bezpośrednie porównanie z undefinedlub typeof. Z różnych powodów wolę typeof x === "undefined".
   • sprawdzić, czy jest to jedna nulli undefinedza pomocą ==i opierając się na nieco bardziej zaawansowanej zasad rodzaj przymusu, że średni x == nullrobi dokładnie to, co chcesz.
     
     
2. Podstawowa różnica między ==i ===polega na tym, że jeśli operandy są różnych typów, ===zawsze powróci, falsepodczas gdy ==jeden lub oba operandy zostaną przekształcone w ten sam typ przy użyciu reguł, które prowadzą do nieco nieintuicyjnych zachowań. Jeśli operandy są tego samego typu (np. Oba są łańcuchami, jak w typeofpowyższym porównaniu) ==i ===będą zachowywać się dokładnie tak samo.

Więcej lektur:

• Prawda, równość i JavaScript Angusa Crolla
• JavaScript Coercion Andrei Giammarchi zdemistyfikowany
• comp.lang.javascript FAQ: Konwersja typów JavaScript

Jak sprawdzić zmienną, jeśli jest pusta lub niezdefiniowana

po prostu sprawdź, czy zmienna ma poprawną wartość taką jak ta:

if(variable)

zwróci true, jeśli zmienna nie zawiera:

• zero
• nieokreślony
• 0
• fałszywe
• „” (pusty ciąg)
• NaN

nieokreślony

Oznacza to, że zmienna nie jest jeszcze zainicjalizowana.

Przykład:

var x;
if(x){ //you can check like this
   //code.
}

równa się (==)

Sprawdza tylko, czy wartość jest równa, a nie typ danych.

Przykład:

var x = true;
var y = new Boolean(true);
x == y ; //returns true

Ponieważ sprawdza tylko wartość.

Ścisłe równe (===)

Sprawdza, czy wartość i typ danych powinny być takie same.

Przykład:

var x = true;
var y = new Boolean(true);
x===y; //returns false.

Ponieważ sprawdza, czy typ danych x jest typem pierwotnym, ay jest obiektem typu boolean.

Reklama 1. nullnie jest identyfikatorem właściwości obiektu globalnego, jak undefined może być

let x;      // undefined
let y=null; // null
let z=3;    // has value
// 'w'      // is undeclared

if(!x) console.log('x is null or undefined');
if(!y) console.log('y is null or undefined');
if(!z) console.log('z is null or undefined');

try { if(w) 0 } catch(e) { console.log('w is undeclared') }
// typeof not throw exception for undelared variabels
if(typeof w === 'undefined') console.log('w is undefined');

Ad 2. ===Wartości i typy kontrolne. ==Dont wymagać tego samego rodzaju i wykonane niejawna konwersja przed porównania (za pomocą .valueOf()a .toString()). Tutaj masz wszystko ( src ):

gdyby

== (jego negacja ! = )

=== (jego negacja ! == )

Jeśli twoja (logiczna) kontrola dotyczy negacji (!) I chcesz przechwycić zarówno JS, jak nulli undefined (ponieważ różne przeglądarki dadzą różne wyniki), skorzystasz z mniej restrykcyjnego porównania: np .:

var ItemID = Item.get_id();
if (ItemID != null)
{
 //do stuff
}

To uchwyci zarówno nulliundefined

Spróbuj z inną logiką . Możesz użyć poniższego kodu do sprawdzenia wszystkich czterech (4) warunków sprawdzania poprawności, takich jak: nie jest pusty, nie jest pusty, nie jest niezdefiniowany i nie zero używa tylko tego kodu (! (! (Zmienna))) w javascript i jquery.

function myFunction() {
var data;  //The Values can be like as null, blank, undefined, zero you can test

if(!(!(data)))
{
   //If data has valid value
    alert("data "+data);
} 
else 
{
    //If data has null, blank, undefined, zero etc.
    alert("data is "+data);
}

}