Jak Mogę określić, czy zmienna jest 'undefined' lub 'null'?

Standardowy sposób na złapanie null i undefined jednocześnie jest następujący:

if (variable == null) {
     // do something 
}

-- co jest w 100% równoważne bardziej wyraźnemu, ale mniej zwięzłemu:

if (variable === undefined || variable === null) {
     // do something 
}

Pisząc profesjonalne JS, przyjmuje się za pewnik, że równość typu i zachowanie == vs === zrozumiano. Dlatego używamy == i porównujemy tylko do null.

Edytuj ponownie

Komentarze sugerujące użycie typeof są po prostu Źle. tak, moje rozwiązanie powyżej spowoduje ReferenceError, jeśli zmienna nie istnieje. To dobra rzecz. Ten ReferenceError jest pożądany: pomoże Ci znaleźć błędy i naprawić je przed wysłaniem kodu, tak jak błędy kompilatora w innych językach. Użycie try/catch jeśli pracujesz z danymi wejściowymi, nie masz nad nimi kontroli.

Nie powinieneś mieć żadnych odniesień do nierejestrowanych zmiennych w kodzie.

Łącząc powyższe odpowiedzi, wydaje się, że najbardziej kompletną odpowiedzią będzie:

if( typeof variable === 'undefined' || variable === null ){
    // Do stuff
}

To powinno działać dla każdej zmiennej, która jest albo niezgłoszona, albo zadeklarowana i jawnie ustawiona na null lub undefined. Wyrażenie logiczne powinno mieć wartość false dla każdej zadeklarowanej zmiennej, która ma rzeczywistą wartość inną niż null.

if (variable == null) {
    // Do stuff, will only match null or undefined, this won't match false
}

if (typeof EmpName != 'undefined' && EmpName) {

Będzie oceniać na true, jeśli wartość nie jest:

• Null

• Undefined

• NaN

• Pusty łańcuch ("")

• 0

• Fałsz

Funkcja JQuery attr() zwraca pusty łańcuch lub rzeczywistą wartość (i nigdy null lub undefined). Zwraca undefined tylko wtedy, gdy selektor nie zwrócił żadnego elementu.

Więc możesz chcieć przetestować na pustym łańcuchu. Alternatywnie, ponieważ puste ciągi, null i undefined są false-y, możesz po prostu zrobić to:

if (!EmpName) { //do something }

Prawdopodobnie najkrótszą drogą do tego jest:

if(EmpName == null) { /* DO SOMETHING */ };

Oto dowód:

function check(EmpName) {
  if(EmpName == null) { return true; };
  return false;
}

var log = (t,a) => console.log(`${t} -> ${check(a)}`);

log('null', null);
log('undefined', undefined);
log('NaN', NaN);
log('""', "");
log('{}', {});
log('[]', []);
log('[1]', [1]);
log('[0]', [0]);
log('[[]]', [[]]);
log('true', true);
log('false', false);
log('"true"', "true");
log('"false"', "false");
log('Infinity', Infinity);
log('-Infinity', -Infinity);
log('1', 1);
log('0', 0);
log('-1', -1);
log('"1"', "1");
log('"0"', "0");
log('"-1"', "-1");

// "void 0" case
console.log('---\n"true" is:', true);
console.log('"void 0" is:', void 0);
log(void 0,void 0); // "void 0" is "undefined" 

A oto więcej szczegółów na temat == (Źródło tutaj )

BONUS : powód, dla którego === jest bardziej jasny niż == (Spójrz na odpowiedź agc)

Przyszedłem napisać własną funkcję do tego. JavaScript jest dziwny.

function empty(v) {
    let type = typeof v;
    if (type === 'undefined') {
        return true;
    }
    if (type === 'boolean') {
        return !v;
    }
    if (v === null) {
        return true;
    }
    if (v === undefined) {
        return true;
    }
    if (v instanceof Array) {
        if (v.length < 1) {
            return true;
        }
    } else if (type === 'string') {
        if (v.length < 1) {
            return true;
        }
        if (v === '0') {
            return true;
        }
    } else if (type === 'object') {
        if (Object.keys(v).length < 1) {
            return true;
        }
    } else if (type === 'number') {
        if (v === 0) {
            return true;
        }
    }
    return false;
}

Kompatybilny z maszynopisem.

Ta funkcja powinna robić dokładnie to samo jak PHP empty() function (zobacz RETURN VALUES)

Rozważa undefined, null, false, 0, 0.0, "0" {}, [] jako puste.

"0.0", NaN, " ", true są uważane za niepuste.

Najkrótszy i najłatwiejszy:

if(!EmpName ){
 // DO SOMETHING
}

To oceni true, jeśli EmpName to:

• null
• undefined
• NaN
• empty
• string ( "" )
• 0
• false

Jeśli zmienna, którą chcesz sprawdzić, jest globalna, wykonaj

if (window.yourVarName) {
    // Your code here
}

Ten sposób sprawdzenia nie spowoduje błędu, nawet jeśli zmienna yourVarName nie istnieje.

Przykład: Chcę wiedzieć, czy moja przeglądarka obsługuje History API

if (window.history) {
    history.back();
}

Jak to działa:

window jest obiektem, który posiada wszystkie zmienne globalne jako swoje właściwości, a w JavaScript jest legalne, aby spróbować uzyskać dostęp do nieistniejącej właściwości obiektu. Jeśli history nie istnieje, to window.history zwraca undefined. undefined jest false, więc kod w bloku if(undefined){} nie będzie działać.

W JavaScript , zgodnie z moją wiedzą, możemy sprawdzić undefined, null lub empty zmienna jak poniżej.

if (variable === undefined){
}

if (variable === null){
}

if (variable === ''){
}

Sprawdź wszystkie warunki:

if(variable === undefined || variable === null || variable === ''){
}

Ponieważ używasz jQuery , możesz określić, czy zmienna jest niezdefiniowana, czy jej wartość jest null za pomocą pojedynczej funkcji.

var s; // undefined
jQuery.isEmptyObject(s); // will return true;

s = null; // defined as null
jQuery.isEmptyObject(s); // will return true;

// usage
if(jQuery.isEmptyObject(s)){
    alert('Either variable: s is undefined or its value is null');
}else{
     alert('variable: s has value ' + s);
}

s = 'something'; // defined with some value
jQuery.isEmptyObject(s); // will return false;

Właśnie miałem taki problem, czyli sprawdzanie czy obiekt jest null.
Po prostu używam tego:

if (object) {
    // Your code
}

Na przykład:

if (document.getElementById("enterJob")) {
    document.getElementById("enterJob").className += ' current';
}

Możesz po prostu użyć poniższego kodu (wiem, że są na to krótsze sposoby, ale może to ułatwić obserwację wizualną, przynajmniej dla innych patrzących na kod).

if (x === null || x === undefined) {
 // Add your response code here, etc.
}

JQuery check element not null:

var dvElement = $('#dvElement');

if (dvElement.length  > 0) {
    // Do something
}
else{
    // Else do something else
}

Najprostszym sposobem sprawdzenia jest:

if(!variable) {
  // If the variable is null or undefined then execution of code will enter here.
}

Z poniższym rozwiązaniem:

const getType = (val) => typeof val === 'undefined' || !val ? null : typeof val;
const isDeepEqual = (a, b) => getType(a) === getType(b);

console.log(isDeepEqual(1, 1)); // true
console.log(isDeepEqual(null, null)); // true
console.log(isDeepEqual([], [])); // true
console.log(isDeepEqual(1, "1")); // false
etc...

Jestem w stanie sprawdzić:

• null
• undefined
• NaN
• pusty
• string ( "" )
• 0
• false

Aby sprawdzić czy zmienna jest NULL lub undefined używam poniższego kodu.

    if(typeof sVal === 'undefined' || sVal === null || sVal === ''){
      console.log('variable is undefined or null');
    }

Uruchamiam ten test w konsoli Chrome. Używając (void 0) Możesz sprawdzić undefined:

var c;
undefined
if (c === void 0) alert();
// output =  undefined
var c = 1;
// output =  undefined
if (c === void 0) alert();
// output =   undefined
// check c value  c
// output =  1
if (c === void 0) alert();
// output =  undefined
c = undefined;
// output =  undefined
if (c === void 0) alert();
// output =   undefined

Spójrzmy na to,

1.  

   let apple; // Only declare the variable as apple
   alert(apple); // undefined
   

   W powyższym przykładzie zmienna jest zadeklarowana tylko jako apple. W tym przypadku wywołanie metody alert wyświetli undefined.

2.  

      let apple = null; /* Declare the variable as apple and initialized but the value is null */
      alert(apple); // null
   

W drugim wyświetla null, ponieważ zmienna o wartości {[3] } jest null.

Możesz więc sprawdzić, czy wartość jest niezdefiniowana czy null.

if(apple !== undefined || apple !== null) {
    // Can use variable without any error
}

Sprawdzanie foo == null powinno załatwić sprawę i rozwiązać "undefined OR null" w najkrótszy sposób. (Nie biorąc pod uwagę przypadku "foo nie jest zadeklarowane".) Ale ludzie, którzy są przyzwyczajeni do 3 równych (jako najlepsza praktyka) może nie zaakceptować. Wystarczy spojrzeć na eqeqeqlub triple-equals zasady w eslint i tslint...

Podejście jawne, kiedy sprawdzamy, czy zmienna jest undefined lub null oddzielnie, powinno być zastosowane w tym przypadku, a mój wkład w temat (27 nie-negatywne odpowiedzi na razie!) jest użycie void 0 jako krótkiego i bezpiecznego sposobu na sprawdzenie undefined.

Używanie foo === undefined nie jest bezpieczne, ponieważ undefined nie jest słowem zastrzeżonym i może być cieniowane (MDN ). Użycie sprawdzania typeof === 'undefined' jest bezpieczne, ale jeśli nie będziemy się przejmować przypadkiem foo-is-undeclared, można zastosować następujące podejście:

if (foo === void 0 || foo === null) { ... }

(null == undefined)  // true

(null === undefined) // false

Ponieważ = = = sprawdza zarówno typ, jak i wartość. Typ obu są różne, ale wartość jest taka sama.

Jeśli utworzysz funkcję, aby ją sprawdzić:

export function isEmpty (v) {
 if (typeof v === "undefined") {
   return true;
 }
 if (v === null) {
   return true;
 }
 if (typeof v === "object" && Object.keys(v).length === 0) {
   return true;
 }

 if (Array.isArray(v) && v.length === 0) {
   return true;
 }

 if (typeof v === "string" && v.trim().length === 0) {
   return true;
 }

return false;
}

Najlepszy sposób:

if(typeof variable==='undefined' || variable===null) {

/* do your stuff */
}

var i;

if (i === null || typeof i === 'undefined') {
    console.log(i, 'i is undefined or null')
}
else {
    console.log(i, 'i has some value')
}

Wiem, że spóźniłem się 10 lat. Ale zostawię tu moją odpowiedź na wypadek, gdyby ktoś potrzebował krótkiej metody.

Instalacja Lodash w Twoim projekcie może być przydatna ze względu na funkcje pomocnicze, które mogą się przydać w takich sytuacjach.

Używając modułów ES6, import będzie wyglądał następująco:

import isNull from 'lodash/isNull';

import isUndefined from 'lodash/isUndefined';

import isNil from 'lodash/isNil';

Byłoby lepiej, gdyby tylko używane funkcje były importowane.

Lodash ' s isNull sprawdza, czy wartość jest null.

const value = null;
 
 if(isNull(value)) {
    // do something if null
 }

Lodash ' s isUndefined sprawdza, czy wartość jest niezdefiniowana.

const value = undefined;

if(isUndefined(value)) {
   // do something if undefined.
}

IsNil sprawdza, czy wartość jest null lub undefined. Wolę tę metodę niż dwie pozostałe, ponieważ sprawdza zarówno undefined, jak i null.

Wywołanie typeof null Zwraca wartość "object", ponieważ specjalna wartość null jest uważana za puste odniesienie do obiektu. Safari od wersji 5 i Chrome od wersji 7 mają dziwaczność, w której wywołanie typeof w wyrażeniu regularnym zwraca "function", podczas gdy wszystkie inne przeglądarki zwracają"object".

var x;
if (x === undefined) {
    alert ("only declared, but not defined.")
};
if (typeof y === "undefined") {
    alert ("not even declared.")
};

Możesz użyć tylko drugiego: ponieważ sprawdzi zarówno definicję, jak i deklarację

Nadal uważam, że najlepszym / bezpiecznym sposobem przetestowania tych dwóch warunków jest rzucenie wartości na ciąg znaków:

var EmpName = $("div#esd-names div#name").attr('class');

// Undefined check
if (Object.prototype.toString.call(EmpName) === '[object Undefined]'){
    // Do something with your code
}

// Nullcheck
if (Object.prototype.toString.call(EmpName) === '[object Null]'){
    // Do something with your code
}

Możesz sprawdzić, czy wartość jest niezdefiniowana lub null, po prostu używając typeof:

if(typeof value == 'undefined'){