Wie kann ich feststellen, ob eine Variable "undefiniert" oder "null" ist?

Wie bestimme ich, ob Variable undefinedoder ist null?

Mein Code lautet wie folgt:

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

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

Wenn ich dies tue, stoppt der JavaScript-Interpreter die Ausführung.

Sie können die Eigenschaften des abstrakten Gleichheitsoperators verwenden , um dies zu tun:

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

Da dies null == undefinedzutrifft, fängt der obige Code sowohl nullals auch ab undefined.

Die Standardmethode zum Fangen nullund undefinedgleichzeitig ist:

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

- was zu 100% dem expliziteren, aber weniger prägnanten entspricht:

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

Beim Schreiben von professionellem JS wird davon ausgegangen, dass die Typgleichheit und das Verhalten von ==vs=== verstanden werden. Deshalb verwenden wir ==und vergleichen nur mit null.

Erneut bearbeiten

Die Kommentare, die die Verwendung von vorschlagen, typeofsind einfach falsch. Ja, meine obige Lösung verursacht einen ReferenceError, wenn die Variable nicht vorhanden ist. Das ist eine gute Sache. Dieser ReferenceError ist wünschenswert: Er hilft Ihnen, Ihre Fehler zu finden und zu beheben, bevor Sie Ihren Code versenden, genau wie Compilerfehler in anderen Sprachen. Verwenden Sie try/, catchwenn Sie mit Eingaben arbeiten, über die Sie keine Kontrolle haben.

Sie sollten keine Verweise auf nicht deklarierte Variablen in Ihrem Code haben.

Wenn man die obigen Antworten kombiniert, scheint die vollständigste Antwort zu sein:

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

Dies sollte für jede Variable funktionieren, die entweder nicht deklariert oder deklariert und explizit auf null oder undefiniert gesetzt ist. Der boolesche Ausdruck sollte für jede deklarierte Variable mit einem tatsächlichen Wert ungleich Null als false ausgewertet werden.

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

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

wird als wahr ausgewertet, wenn der Wert nicht ist:

• Null

• nicht definiert

• NaN

• leerer String ("")

• 0

• falsch

Die jQuery- attr()Funktion gibt entweder eine leere Zeichenfolge oder den tatsächlichen Wert zurück (und niemals nulloder undefined). Es wird nur zurückgegeben, undefinedwenn Ihr Selektor kein Element zurückgegeben hat.

Vielleicht möchten Sie also gegen eine leere Zeichenfolge testen. Da leere Zeichenfolgen null und undefiniert false-y sind, können Sie alternativ Folgendes tun:

if (!EmpName) { //do something }

Ich bin gekommen, um meine eigene Funktion dafür zu schreiben. JavaScript ist komisch.

Es ist buchstäblich für alles verwendbar. (Beachten Sie, dass hierdurch auch geprüft wird, ob die Variable verwendbare Werte enthält . Da diese Informationen jedoch normalerweise ebenfalls benötigt werden, lohnt es sich meiner Meinung nach, sie zu veröffentlichen.) Bitte hinterlassen Sie eine Notiz.

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

TypeScript-kompatibel.

Diese Funktion sollte genau das Gleiche tun wie die PHP- empty()Funktion (siehe RETURN VALUES)

Vertritt die Ansicht undefined, null, false, 0, 0.0, "0" {}, []wie leer.

"0.0", NaN, " ", trueSind nicht leer betrachtet.

Wenn die Variable, die Sie überprüfen möchten, global ist, tun Sie dies

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

Diese Art der Überprüfung yourVarNamelöst keinen Fehler aus, auch wenn die Variable nicht vorhanden ist.

Beispiel: Ich möchte wissen, ob mein Browser die Verlaufs-API unterstützt

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

So funktioniert das:

windowist ein Objekt, das alle globalen Variablen als Eigenschaften enthält. In JavaScript ist es zulässig, auf eine nicht vorhandene Objekteigenschaft zuzugreifen. Wenn historynicht vorhanden, wird window.historyzurückgegeben undefined. undefinedist falsey, daher wird Code in einem if(undefined){}Block nicht ausgeführt.

Das kürzeste und einfachste:

if(!EmpName ){
 // DO SOMETHING
}

Dies wird wahr ausgewertet, wenn EmpName ist:

• Null
• nicht definiert
• NaN
• leeren
• Zeichenfolge ("")
• 0
• falsch

Der wahrscheinlich kürzeste Weg, dies zu tun, ist:

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

Hier ist der Beweis:

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" 

Und hier sind weitere Details zu ==(Quelle hier )

BONUS : Grund warum ===ist klarer als ==(siehe agc Antwort )

Ich hatte gerade dieses Problem, dh zu überprüfen, ob ein Objekt null ist.
Ich benutze einfach das:

if (object) {
    // Your code
}

Zum Beispiel:

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

Da Sie jQuery verwenden , können Sie mithilfe einer einzelnen Funktion feststellen, ob eine Variable undefiniert oder ihr Wert null ist.

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;

jQuery-Prüfelement nicht null:

var dvElement = $('#dvElement');

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

In JavaScript können wir meines Wissens nach eine undefinierte, null oder leere Variable wie unten überprüfen.

if (variable === undefined){
}

if (variable === null){
}

if (variable === ''){
}

Überprüfen Sie alle Bedingungen:

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

Sie können einfach Folgendes verwenden (ich weiß, dass es kürzere Möglichkeiten gibt, dies zu tun, aber dies kann die visuelle Beobachtung erleichtern, zumindest für andere, die sich den Code ansehen).

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

Der einfachste Weg zu überprüfen ist:

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

Mit der folgenden Lösung:

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

Ich kann Folgendes überprüfen:

• Null
• nicht definiert
• NaN
• leeren
• Zeichenfolge ("")
• 0
• falsch

Um zu testen, ob eine Variable null oder undefiniert ist, verwende ich den folgenden Code.

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

Ich führe diesen Test in der Chrome-Konsole aus. Mit (void 0) können Sie undefiniert überprüfen:

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

Schauen wir uns das an,

1.  

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

   Oben wird die Variable nur als deklariert apple. In diesem Fall wird beim Aufrufen der Methode alertundefiniert angezeigt.

2.  

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

Im zweiten wird null angezeigt, da die Wertvariable applenull ist.

So können Sie überprüfen, ob ein Wert undefiniert oder null ist.

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

Bester Weg:

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

/* do your stuff */
}

(null == undefined)  // true

(null === undefined) // false

Weil === sowohl nach Typ als auch nach Wert sucht. Der Typ von beiden ist unterschiedlich, aber der Wert ist der gleiche.

var i;

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

Die foo == nullPrüfung sollte den Trick ausführen und den Fall "undefiniert ODER null" auf kürzeste Weise lösen. (Der Fall "foo wird nicht deklariert" wird nicht berücksichtigt.) Personen, die 3 Gleichgestellte haben (als bewährte Methode), akzeptieren dies möglicherweise nicht. Schauen Sie sich einfach eqeqeq oder Triple-Equals- Regeln in eslint und tslint an ...

Der explizite Ansatz, wenn wir prüfen, ob eine Variable undefinedoder nullseparat ist, sollte in diesem Fall angewendet werden, und mein Beitrag zum Thema (27 derzeit nicht negative Antworten!) Besteht darin, void 0sowohl eine kurze als auch eine sichere Methode zur Durchführung der Prüfung zu verwenden zumundefined .

Die Verwendung foo === undefinedist nicht sicher, da undefiniert kein reserviertes Wort ist und schattiert werden kann ( MDN ). Die Verwendung von typeof === 'undefined'check ist sicher, aber wenn wir uns nicht um den nicht deklarierten Fall kümmern, kann der folgende Ansatz verwendet werden:

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

Wenn Sie eine Funktion erstellen, um dies zu überprüfen:

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

Wenn Sie typeof null aufrufen, wird der Wert "object" zurückgegeben, da der spezielle Wert null als leere Objektreferenz betrachtet wird. Safari bis Version 5 und Chrome bis Version 7 haben eine Besonderheit, bei der der Aufruf von typeof für einen regulären Ausdruck "function" zurückgibt, während alle anderen Browser "object" zurückgeben.

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

Sie können nur die zweite verwenden, da sowohl die Definition als auch die Deklaration überprüft werden

Ich denke immer noch, dass der beste / sicherste Weg, diese beiden Bedingungen zu testen, darin besteht, den Wert in einen String umzuwandeln:

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
}

Sie können überprüfen, ob der Wert undefiniert oder null ist, indem Sie einfach typeof verwenden:

if(typeof value == 'undefined'){

if(x==null)ist eine schlechte Idee in JavaScript. Beurteilen mit "=="- es kann zu einem unerwarteten Zwang führen, und es kann nicht von CoffeeScript gelesen werden. Verwenden Sie niemals "==" oder "! =" Bei der Zustandsbeurteilung!

if(x)wird besser sein, aber sei vorsichtig mit 0 und "" . Es wird als falsch behandelt , nicht die gleiche Methode "!= null"ist wahr .

Siehe Best Practices für JavaScript .