Wie bestimme ich, ob die Variable undefined
oder null
ist? 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>
In diesem Fall hält der JavaScript-Interpreter die Ausführung an.
Sie können die Eigenschaften des abstrakter Gleichheitsoperator verwenden, um dies zu tun:
if (variable == null){
// your code here.
}
Da null == undefined
wahr ist, erfasst der obige Code sowohl null
als auch undefined
.
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
.
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.
if (window.history) {
history.back();
}
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.history
undefined
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:
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:
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'){