Jak mogę ustalić, czy zmienna jest „niezdefiniowana” czy „pusta”?

Jak ustalić, czy zmienna jest undefinedlub null?

Mój kod jest następujący:

var EmpName = $("div#esd-names div#name").attr('class');
if(EmpName == 'undefined'){
  // DO SOMETHING
};

<div id="esd-names">
  <div id="name"></div>
</div>

Ale jeśli to zrobię, interpreter JavaScript przestanie działać.

Możesz użyć właściwości abstrakcyjnego operatora równości, aby to zrobić:

if (variable == null){
    // your code here.
}

Ponieważ null == undefinedto prawda, powyższy kod przechwytuje zarówno nulli undefined.

Standardowy sposób łapania nulli undefinedjednocześnie jest następujący:

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

- który jest w 100% równoważny z bardziej wyraźnym, ale mniej zwięzłym:

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

Pisząc profesjonalną JS, przyjmuje się za pewnik, że równość typów===== jest zrozumiała, a zachowanie vs jest zrozumiałe. Dlatego używamy ==i tylko porównujemy null.

Edytuj ponownie

Komentarze sugerujące użycie typeofsą po prostu błędne. Tak, moje powyższe rozwiązanie spowoduje błąd ReferenceError, jeśli zmienna nie istnieje. To coś dobrego. Błąd ReferenceError jest pożądany: pomoże ci znaleźć błędy i naprawić je przed wysłaniem kodu, podobnie jak błędy kompilatora w innych językach. Użyj try/, catchjeśli pracujesz z danymi wejściowymi, nad którymi nie masz kontroli.

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

Łącząc powyższe odpowiedzi, wydaje się, że najbardziej kompletną odpowiedzią byłoby:

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

Powinno to działać dla każdej zmiennej, która jest niezadeklarowana lub zadeklarowana i jawnie ustawiona na null lub niezdefiniowana. Wyrażenie logiczne powinno mieć wartość false dla każdej deklarowanej 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) {

oceni prawdę, jeśli wartość nie jest:

• zero

• nieokreślony

• NaN

• pusta struna ("")

• 0

• fałszywe

attr()Funkcja jQuery zwraca pusty ciąg znaków lub rzeczywistą wartość (i nigdy nulllub undefined). Powraca tylko wtedy, undefinedgdy selektor nie zwrócił żadnego elementu.

Możesz więc przetestować pusty ciąg. Alternatywnie, ponieważ puste ciągi, puste i niezdefiniowane są fałszywe-y, możesz po prostu to zrobić:

if (!EmpName) { //do something }

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

Można go używać dosłownie na wszystkim. (Zauważ, że sprawdza to również, czy zmienna zawiera jakieś użyteczne wartości . Ale ponieważ ta informacja jest zwykle potrzebna, myślę, że warto ją opublikować). Proszę rozważyć pozostawienie notatki.

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 TypeScript.

Ta funkcja powinna robić dokładnie to samo, co empty()funkcja PHP (patrz RETURN VALUES)

Uważa undefined, null, false, 0, 0.0, "0" {}, []jako pusty.

"0.0", NaN, " ", trueSą uważane za niepusty.

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

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

Ten sposób sprawdzania nie spowoduje zgłoszenia błędu, nawet jeśli yourVarNamezmienna nie istnieje.

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

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

Jak to działa:

windowjest obiektem, który przechowuje wszystkie zmienne globalne jako swoje właściwości, aw JavaScript można próbować uzyskać dostęp do nieistniejącej właściwości obiektu. Jeśli historynie istnieje, to window.historyzwraca undefined. undefinedjest falsey, więc kod w if(undefined){}bloku nie będzie działał.

Najkrótszy i najłatwiejszy:

if(!EmpName ){
 // DO SOMETHING
}

to oceni prawdę, jeśli EmpName to:

• zero
• nieokreślony
• NaN
• pusty
• strunowy ("")
• 0
• fałszywe

Prawdopodobnie najkrótszym sposobem na to 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 : dlaczego ===jest bardziej jasne niż ==(spójrz na odpowiedź agc )

Właśnie miałem ten problem, tj. Sprawdzanie, czy obiekt jest pusty.
Po prostu używam tego:

if (object) {
    // Your code
}

Na przykład:

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

Ponieważ używasz jQuery , możesz określić, czy zmienna jest niezdefiniowana, czy jej wartość jest pusta, używając 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;

Element sprawdzający jQuery nie jest pusty:

var dvElement = $('#dvElement');

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

W JavaScript, zgodnie z moją wiedzą, możemy sprawdzić niezdefiniowaną, zerową lub pustą zmienną, jak poniżej.

if (variable === undefined){
}

if (variable === null){
}

if (variable === ''){
}

Sprawdź wszystkie warunki:

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

Możesz po prostu użyć następujących (wiem, że istnieją krótsze sposoby, aby to zrobić, ale może to ułatwić wizualną obserwację, przynajmniej dla innych osób oglądających kod).

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

Najłatwiejszym sposobem sprawdzenia jest:

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

Z rozwiązaniem poniżej:

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ć, czy:

• zero
• nieokreślony
• NaN
• pusty
• strunowy ("")
• 0
• fałszywe

Aby sprawdzić, czy zmienna jest pusta lub niezdefiniowana, używam poniższego kodu.

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

Test ten uruchamiam w konsoli Chrome. Używając (void 0) możesz sprawdzić niezdefiniowane:

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

   Powyżej zmienna jest zadeklarowana tylko jako apple. W takim przypadku, jeśli wywołamy metodę alert, wyświetli się niezdefiniowana.

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 applewartości ma wartość null.

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

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

Najlepszym sposobem:

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

/* do your stuff */
}

(null == undefined)  // true

(null === undefined) // false

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

var i;

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

foo == nullSprawdzenie powinno załatwić sprawę i rozwiązać „niezdefiniowany lub null” przypadek w jak najkrótszym czasie. (Nie biorąc pod uwagę przypadku „foo nie jest zadeklarowany”). Ale ludzie, którzy są przyzwyczajeni do 3 równych (co jest najlepszą praktyką), mogą tego nie zaakceptować. Wystarczy spojrzeć na zasady eqeqeq lub triple-equals w eslint i tslint ...

W tym przypadku należy zastosować jawne podejście, gdy sprawdzamy, czy zmienna jest, undefinedczy nullosobno, a moim wkładem w ten temat (na razie 27 odpowiedzi nie-negatywnych!) Jest użycie void 0zarówno krótkiego, jak i bezpiecznego sposobu przeprowadzania kontroli dla undefined.

Używanie foo === undefinednie jest bezpieczne, ponieważ niezdefiniowane nie jest słowem zarezerwowanym i może być śledzone ( MDN ). Korzystanie z typeof === 'undefined'czeku jest bezpieczne, ale jeśli nie będziemy się przejmować przypadkiem foo-is-undeklarowanym, można zastosować następujące podejście:

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

jeśli utworzysz funkcję, aby to 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;
}

Wywołanie typeof null zwraca wartość „object”, ponieważ wartość specjalna null jest uważana za odwołanie do pustego obiektu. Safari w wersji 5 i Chrome w wersji 7 mają dziwactwo, w którym wywołanie typeof wyrażenia regularnego zwraca „funkcję”, podczas gdy wszystkie inne przeglądarki zwracają „obiekt”.

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 przelanie wartości na ciąg:

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 zerowa, po prostu używając typeof:

if(typeof value == 'undefined'){

if(x==null)jest złym pomysłem w JavaScript. Oceniaj za pomocą "=="- może to spowodować nieoczekiwany przymus typu i nie może być odczytany przez CoffeeScript, nigdy nie używaj „==” lub „! =” W ocenie stanu!

if(x)będzie lepiej, ale uważaj na 0 i „” . Będzie ona traktowana jako fałszywą , a nie z równym metody "!= null"jest prawdą .

Zobacz najlepsze praktyki JavaScript .