Jak sprawdzić zmienną undefined lub null w JavaScript?

Myślę, że najskuteczniejszym sposobem na sprawdzenie "wartość to null lub undefined" jest

if ( some_variable == null ){
  // some_variable is either null or undefined
}

Więc te dwie linie są równoważne:

if ( typeof(some_variable) !== "undefined" && some_variable !== null ) {}
if ( some_variable != null ) {}

Uwaga 1

Jak wspomniano w pytaniu, krótki wariant wymaga zadeklarowania some_variable, w przeciwnym razie zostanie wyrzucony ReferenceError. Jednak w wielu przypadkach można założyć, że jest to bezpieczne:

Sprawdź opcjonalne argumenty:

function(foo){
    if( foo == null ) {...}

Sprawdź właściwości na istniejącym obiekt

if(my_obj.foo == null) {...}

Z drugiej strony typeof może radzić sobie z nierejestrowanymi zmiennymi globalnymi (po prostu zwraca undefined). Jak wyjaśnił Alsciende, przypadki te należy jednak ograniczyć do minimum z dobrych powodów.

Uwaga 2

Ten - jeszcze krótszy - wariant jestnie odpowiednikiem:

if ( !some_variable ) {
  // some_variable is either null, undefined, 0, NaN, false, or an empty string
}

Więc

if ( some_variable ) {
  // we don't get here if some_variable is null, undefined, 0, NaN, false, or ""
}

Uwaga 3

Ogólnie zaleca się stosowanie === zamiast ==. Proponowane rozwiązanie stanowi wyjątek od tej zasada. Sprawdzanie składni jshint zapewnia nawet opcję eqnull z tego powodu.

Z jQuery style guide :

Ścisłe sprawdzanie równości ( = = = ) powinno być stosowane na korzyść==. Jedyny wyjątkiem jest sprawdzanie undefined I null za pomocą null.

// Check for both undefined and null values, for some important reason. 
undefOrNull == null;

Sprawdzenie null z normalną równością zwróci również true dla undefined.

if (window.variable == null) alert('variable is null or undefined');

W nowszych standardach JavaScript, takich jak ES5 i ES6, można po prostu powiedzieć

> Boolean(0) //false
> Boolean(null)  //false
> Boolean(undefined) //false

All zwraca false, co jest podobne do sprawdzania pustych zmiennych w Pythonie. Więc jeśli chcesz napisać logikę warunkową wokół zmiennej, po prostu powiedz

if (Boolean(myvar)){
   // Do something
}

Tutaj "null" lub "empty string" lub "undefined" będą obsługiwane efektywnie.

Jeśli spróbujesz odwołać się do nierejestrowanej zmiennej, błąd zostanie wyrzucony we wszystkich implementacjach JavaScript.

Właściwości obiektów nie podlegają tym samym warunkom. Jeśli właściwość obiektu nie została zdefiniowana, błąd nie zostanie wyświetlony, jeśli spróbujesz uzyskać do niej dostęp. Więc w tej sytuacji można skrócić:

 if (typeof(myObj.some_property) != "undefined" && myObj.some_property != null)

Do

if (myObj.some_property != null)

Mając to na uwadze, oraz fakt, że zmienne globalne są dostępne jako właściwości obiektu globalnego (window w przypadku przeglądarki), możesz użyć następujących zmiennych globalnych:

if (window.some_variable != null) {
    // Do something with some_variable
}

W lokalnych zakresach zawsze warto upewnić się, że zmienne są zadeklarowane u góry bloku kodu, co pozwoli zaoszczędzić na powtarzających się używaniach typeof.

Najpierw musisz być bardzo jasny co testujesz. JavaScript ma wszelkiego rodzaju ukryte konwersje, aby cię zaskoczyć, i dwa różne typy porównywania równości: == i ===.

Funkcja, test(val), która sprawdza dla null lub undefined powinna mieć następujące cechy:

 test(null)         => true
 test(undefined)    => true
 test(0)            => false
 test(1)            => false
 test(true)         => false
 test(false)        => false
 test('s')          => false
 test([])           => false

Zobaczmy, który z pomysłów tutaj rzeczywiście przejść nasz test.

Te prace:

val == null
val === null || val === undefined
typeof(val) == 'undefined' || val == null
typeof(val) === 'undefined' || val === null

Te nie działają:

typeof(val) === 'undefined'
!!val

Stworzyłem wpis jsperf do porównaj poprawność i wydajność tych podejść. Wyniki są na razie niejednoznaczne, ponieważ nie ma wystarczającej liczby uruchomień w różnych przeglądarkach / platformach. Poświęć chwilę na uruchomienie testu na swoim komputerze!

Obecnie wydaje się, że prosty val == null test daje najlepsze wyniki. Jest też prawie Najkrótsza. Test może zostać zanegowany do val != null, Jeśli chcesz dopełnienia.

Ponieważ nie ma jednej kompletnej i poprawnej odpowiedzi, postaram się podsumować:

Ogólnie wyrażenie:

if (typeof(variable) != "undefined" && variable != null)

Nie można uprościć, ponieważ variable może być niezgłoszona, więc pominięcie {[5] } spowodowałoby ReferenceError. Ale można uprościć wyrażenie zgodnie z kontekstem :

Jeśli variable jest globalnym , można uprościć do:

if (window.variable != null)

Jeśli jest to local, prawdopodobnie można uniknąć sytuacji, gdy ta zmienna jest nierejestrowane, a także uprościć do:

if (variable != null)

Jeśli jest to właściwość obiektu, nie musisz się martwić ReferenceError:

if (obj.property != null)

Możesz po prostu sprawdzić, czy zmienna ma wartość, czy nie. Znaczenie,

if( myVariable ) {
//mayVariable is not :
//null
//undefined
//NaN
//empty string ("")
//0
//false

}

Jeśli nie wiesz, czy zmienna istnieje (to znaczy, jeśli została zadeklarowana), powinieneś sprawdzić za pomocą operatora typeof. np.

if( typeof myVariable !== 'undefined' ) {
    // myVariable will get resolved and it is defined
}

Jak wspomniano w jednej z odpowiedzi, możesz mieć szczęście, jeśli mówisz o zmiennej, która ma zasięg globalny. Jak zapewne wiesz, zmienne definiowane globalnie zwykle są dodawane do obiektu windows. Możesz skorzystać z tego faktu, więc powiedzmy, że uzyskujesz dostęp do zmiennej o nazwie bleh, wystarczy użyć operatora double inverted (!!)

!!window['bleh'];

Zwróci false, gdy bleh nie zostanie zadeklarowana i nie zostanie przypisana wartość.

Cokolwiek yyy jest niezdefiniowane lub null, zwróci true

if (typeof yyy == 'undefined' || !yyy) {
    console.log('yes');
} else {
    console.log('no');
}

Tak

if (!(typeof yyy == 'undefined' || !yyy)) {
    console.log('yes');
} else {
    console.log('no');
}

Nie

Otwórz Narzędzia programistyczne w swojej przeglądarce i po prostu wypróbuj kod pokazany na poniższym obrazku.

Testowanie nullity (if (value == null)) lub non-nullity (if (value != null)) jest mniej słowne niż testowanie statusu definicji zmiennej.

Ponadto testowanie if (value) (lub if( obj.property)) w celu upewnienia się, że istnieje zmienna (lub właściwość obiektu) nie powiedzie się, jeśli jest zdefiniowana wartością logiczną false. Caveat emptor:)

Obie wartości można łatwo odróżnić za pomocą ścisłego operatora porównania:

Przykład pracy w:

Http://www.thesstech.com/tryme?filename=nullandundefined

Przykładowy Kod:

function compare(){
    var a = null; //variable assigned null value
    var b;  // undefined
    if (a === b){
        document.write("a and b have same datatype.");
    }
    else{
        document.write("a and b have different datatype.");
    }   
}

Aby zrozumieć, przeanalizujmy, jaka będzie wartość zwracana przez silnik Javascript podczas konwersji undefined, null i "(również pusty łańcuch). Możesz sprawdzić to samo bezpośrednio na konsoli dewelopera.

Widać, że wszystkie konwertują na false, czyli wszystkie te trzy zakładają "brak istnienia" przez javascript. Więc nie musisz wyraźnie sprawdzać wszystkich trzech w kodzie, jak poniżej.

if (a === undefined || a === null || a==='') {
    console.log("Nothing");
} else {
    console.log("Something");
}

Chcę również zwrócić uwagę na jeszcze jedną thing

Jaki będzie wynik Boolean (0)?

Oczywiście false. Spowoduje to powstanie błędu w kodzie, gdy 0 stanie się poprawną wartością oczekiwanego wyniku. Więc upewnij się, że ta rzecz również podczas pisania kodu

Musisz zdefiniować funkcję tej postaci:

validate = function(some_variable){
    return(typeof(some_variable) != 'undefined' && some_variable != null)
}