Wie ermittle ich, ob die Variable 'undefiniert' oder 'null' ist?

Die Standardmethode, um null und undefined gleichzeitig zu fangen, ist folgende:

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

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

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

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

Erneut bearbeiten

Die Kommentare, die die Verwendung von typeof vorschlagen, sind einfach falsch. Ja, meine obige Lösung wird einen ReferenceError verursachen, wenn die Variable nicht existiert. Dies 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.

In Ihrem Code sollten sich keine Verweise auf nicht deklarierte Variablen befinden.

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, die einen tatsächlichen Wert ungleich Null hat, mit 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

• ndefiniert

• NaN

• leere Zeichenfolge ("")

• false

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

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

if (!EmpName) { //do something }

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

Verwendbar für buchstäblich alles. (Beachten Sie, dass dies auch prüft, ob die Variable verwendbare Werte enthält . Da diese Informationen normalerweise auch benötigt werden, denke ich, dass es sich lohnt, 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.

Bearbeiten. Diese Funktion sollte genau dasselbe tun wie PHPs empty() function (siehe _RETURN VALUES_)

Betrachtet undefined, null, false, _0_, _0.0"0"{}_, _[]_ als leer.

_"0.0"_, NaN, _" "_, true gelten als nicht leer.

Wenn es sich bei der zu überprüfenden Variablen um eine globale Variable handelt, führen Sie Folgendes aus

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

Auf diese Weise wird kein Fehler ausgegeben, auch wenn die Variable yourVarName nicht vorhanden ist.

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

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

Wie das funktioniert:

window ist ein Objekt, das alle globalen Variablen als Eigenschaften enthält. In JavaScript ist es zulässig, auf eine nicht vorhandene Objekteigenschaft zuzugreifen. Wenn history nicht existiert, gibt window.historyundefined zurück. undefined ist falsch, daher wird der Code in einem Block if(undefined){} nicht ausgeführt.

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;

Ich habe gerade dieses Problem gehabt, d. H. 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';
}

jQuery Check-Element ist nicht null

var dvElement = $('#dvElement');

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

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
• undefined
• NaN
• leeren
• zeichenfolge ("")
• false

ich führe diesen Test auf der chrome Konsole aus. Mit (void 0) kannst du undefined ü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

(null == undefined)  // true

(null === undefined) // false

Denn === prüft sowohl den Typ als auch den Wert. Der Typ von beiden ist unterschiedlich, aber der Wert ist der gleiche.

Das kürzeste und einfachste:

if(!EmpName ){
 // DO SOMETHING
}

dies wird als wahr ausgewertet, wenn EmpName ist:

• null
• undefined
• NaN
• leeren
• zeichenfolge ("")
• false

Der einfachste Weg zu überprüfen ist:

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

var i;

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

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

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

}

Bester Weg:

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

/* do your stuff */
}

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

if(typeof value == 'undefined'){