Ceea ce este cel mai potrivit mod de a testa dacă o variabilă este definită în JavaScript? Am'am vazut mai multe moduri posibile:
if (window.myVariable)
Sau
if (typeof(myVariable) != "undefined")
Sau
if (myVariable) //This throws an error if undefined. Should this be in Try/Catch?
Dacă sunteți interesat în a afla dacă o variabilă a fost declarată, indiferent de valoarea acestuia, apoi folosind " în " operatorul este cel mai sigur mod de a merge. Luați în considerare acest exemplu.
// global scope
var theFu; // theFu has been declared, but its value is undefined
typeof theFu; // "undefined"
Dar acest lucru nu poate fi rezultatul destinate pentru unele cazuri, de la o variabilă sau proprietate a fost declarată, ci doar nu este inițializat. Utilizarea " în " operator pentru o mai robust verifica.
"theFu" in window; // true
"theFoo" in window; // false
Dacă sunteți interesat în a ști dacă variabila n't fost declarate sau are valoarea "nedefinit", apoi utilizați typeof
operator.
if (typeof myVar !== 'undefined')
Anii typeof
operator este garantat pentru a întoarce un șir de caractere. Comparații directe împotriva "nedefinit" sunt supărătoare ca "nedefinit" pot fi suprascrise.
window.undefined = "omg";
"omg" == undefined // true
Ca @CMS subliniat, acest lucru a fost patch-uri în ECMAScript 5-a ed., și "nedefinit" este non-scriere.
`dacă (fereastră.myVar) va include, de asemenea, aceste falsy valori, deci's nu foarte solide:
false Zero "" NaN null nedefinit
Datorită @CMS pentru subliniind că al treilea caz - dacă (myVariable) poate, de asemenea, arunca o eroare în două cazuri. Prima este atunci când variabila n't a fost definit care aruncă o ReferenceError
.
// abc was never declared.
if (abc) {
// ReferenceError: abc is not defined
}
Alt caz este atunci când variabila a fost definită, dar are un getter funcție care aruncă o eroare atunci când este invocată. De exemplu,
// or it's a property that can throw an error
Object.defineProperty(window, "myVariable", {
get: function() { throw new Error("W00t?"); },
set: undefined
});
if (myVariable) {
// Error: W00t?
}
Eu personal folosesc
myVar === undefined
Avertisment: vă Rugăm să rețineți că ===
este folosit de peste = = "și că" myVar
a fost anterior declared (nu defined).
Nu-mi place typeof myVar === "nedefinit"
. Cred că este exagerat și inutil. (Nu pot obține aceleași făcut în mai puțin cod.)
Acum, unii oameni s-ar prăbuși în durere, atunci când vor citi asta, țipând: "Stai! WAAITTT!!! "nedefinit" poate fi redefinit!"
Rece. Eu știu acest lucru. Apoi, din nou, cele mai multe variabile în Javascript pot fi redefinite. Ar trebui să nu folosiți niciodată un built-in de identificare care poate fi redefinit?
Dacă urmați această regulă, bună pentru tine: nu't un ipocrit.
Chestia e că, în scopul de a face o mulțime de muncă în JS, dezvoltatorii trebuie să se bazeze pe redefinable identificatori pentru a fi ceea ce sunt. Eu nu't aud oameni care îmi spun că nu ar trebui't folosi setTimeout` pentru că cineva poate
window.setTimeout = function () {
alert("Got you now!");
};
Linia de fund, "acesta poate fi redefinit" argument pentru a nu folosi o prime === undefined
este fals.
(Dacă sunteți încă frică de "nedefinit" fiind redefinit, de ce te orbește integrarea netestat biblioteca codul în codul dumneavoastră de bază? Sau chiar mai simplu: un linting instrument.)
De asemenea, ca tip de abordare, aceasta tehnica poate "detect" nedeclarate variabile:
if (window.someVar === undefined) {
doSomething();
}
Dar ambele aceste tehnici de scurgere în lor de abstractizare. Vă îndemn să nu folosească acest lucru sau chiar
if (typeof myVar !== "undefined") {
doSomething();
}
Ia în considerare:
var iAmUndefined;
Pentru a prinde sau nu această variabilă este declarată sau nu, poate fi necesar să se recurgă la " în " operator. (În multe cazuri, pur și simplu, puteți citi codul O_o).
if ("myVar" in window) {
doSomething();
}
Dar stai! Nu's mai mult! Dacă un lanț prototip magia se întâmplă...? Acum chiar superior " în " operatorul nu este suficient. (Bine, am'm-a terminat aici despre această parte, cu excepția să spun că 99% din timp, === undefined
(și tuse tip
) funcționează foarte bine. Dacă îți pasă cu adevărat, puteți citi despre acest subiect pe cont propriu.)
Folosind typeof
este preferința mea. Acesta va funcționa atunci când variabila nu a fost niciodată declarată, spre deosebire de orice comparație cu ==
sau ===
operatorii sau tip de constrângere, folosind "dacă". ("nedefinit", spre deosebire de null
, de asemenea, pot fi redefinite în ECMAScript 3 medii, face nesigure pentru comparație, deși aproape toate comune medii sunt acum compatibil cu ECMAScript 5 sau mai sus).
if (typeof someUndeclaredVariable == "undefined") {
// Works
}
if (someUndeclaredVariable === undefined) {
// Throws an error
}
L's a fost de aproape cinci ani de când acest post a fost făcut în primul rând, și JavaScript a parcurs un drum lung. În repetarea testelor în original post, nu am gasit nici concordanță diferenta dintre următoarele metode de testare:
abc === undefined
abc === void 0
typeof abc == 'nedefinit'
typeof abc === 'nedefinit'
Chiar și atunci când am modificat teste pentru a preveni Chrome de la optimizarea-le departe, diferențele au fost nesemnificative. Ca atare, am'd acum recomand abc === undefined
pentru claritate.
Conținut Relevant de la chrome://versiune`:
În Google Chrome, următoarele fost vreodată atât de ușor, mai repede decât un tip
de testare:
if (abc === void 0) {
// Undefined
}
Diferența a fost neglijabil. Cu toate acestea, acest cod este mult mai concis și mai clar dintr-o privire la cineva care stie ce nul 0
înseamnă. Rețineți, totuși, că " abc " trebuie să fie declarate.
Ambele `typeof " și "nule au fost în mod semnificativ mai repede decât comparând direct împotriva "nedefinit". Am folosit următoarele test format din Chrome developer console:
var abc;
start = +new Date();
for (var i = 0; i < 10000000; i++) {
if (TEST) {
void 1;
}
}
end = +new Date();
end - start;
Rezultatele au fost după cum urmează:
Test: | abc === undefined abc === void 0 typeof abc == 'undefined'
------+---------------------------------------------------------------------
x10M | 13678 ms 9854 ms 9888 ms
x1 | 1367.8 ns 985.4 ns 988.8 ns
Rețineți că în primul rând este în millisecunde, în timp ce al doilea rand este în nanosecunde. O diferență de 3.4 nanosecunde este nimic. Vremurile erau destul de consistente în testele ulterioare.
Dacă nu este definit, el nu va fi egal cu un șir care conține caractere "nedefinit", ca șirul nu este nedefinit.
Puteți verifica tipul de variabila:
if (typeof(something) != "undefined") ...
Uneori n't chiar trebuie să verificați tipul. Dacă valoarea variabilei poate't evaluează la false atunci când vine's set (de exemplu, dacă-l's-o funcție), atunci puteți doar să evalue variabila. Exemplu:
if (something) {
something(param);
}
Unele scenarii care ilustrează rezultatele de diverse răspunsuri:
(Rețineți că utilizarea de var `pentru " in " teste a face o diferență atunci când într-un domeniu wrapper)
Cod de referință:
(function(undefined) {
var definedButNotInitialized;
definedAndInitialized = 3;
someObject = {
firstProp: "1"
, secondProp: false
// , undefinedProp not defined
}
// var notDefined;
var tests = [
'definedButNotInitialized in window',
'definedAndInitialized in window',
'someObject.firstProp in window',
'someObject.secondProp in window',
'someObject.undefinedProp in window',
'notDefined in window',
'"definedButNotInitialized" in window',
'"definedAndInitialized" in window',
'"someObject.firstProp" in window',
'"someObject.secondProp" in window',
'"someObject.undefinedProp" in window',
'"notDefined" in window',
'typeof definedButNotInitialized == "undefined"',
'typeof definedButNotInitialized === typeof undefined',
'definedButNotInitialized === undefined',
'! definedButNotInitialized',
'!! definedButNotInitialized',
'typeof definedAndInitialized == "undefined"',
'typeof definedAndInitialized === typeof undefined',
'definedAndInitialized === undefined',
'! definedAndInitialized',
'!! definedAndInitialized',
'typeof someObject.firstProp == "undefined"',
'typeof someObject.firstProp === typeof undefined',
'someObject.firstProp === undefined',
'! someObject.firstProp',
'!! someObject.firstProp',
'typeof someObject.secondProp == "undefined"',
'typeof someObject.secondProp === typeof undefined',
'someObject.secondProp === undefined',
'! someObject.secondProp',
'!! someObject.secondProp',
'typeof someObject.undefinedProp == "undefined"',
'typeof someObject.undefinedProp === typeof undefined',
'someObject.undefinedProp === undefined',
'! someObject.undefinedProp',
'!! someObject.undefinedProp',
'typeof notDefined == "undefined"',
'typeof notDefined === typeof undefined',
'notDefined === undefined',
'! notDefined',
'!! notDefined'
];
var output = document.getElementById('results');
var result = '';
for(var t in tests) {
if( !tests.hasOwnProperty(t) ) continue; // bleh
try {
result = eval(tests[t]);
} catch(ex) {
result = 'Exception--' + ex;
}
console.log(tests[t], result);
output.innerHTML += "\n" + tests[t] + ": " + result;
}
})();
Și rezultatele:
definedButNotInitialized in window: true
definedAndInitialized in window: false
someObject.firstProp in window: false
someObject.secondProp in window: false
someObject.undefinedProp in window: true
notDefined in window: Exception--ReferenceError: notDefined is not defined
"definedButNotInitialized" in window: false
"definedAndInitialized" in window: true
"someObject.firstProp" in window: false
"someObject.secondProp" in window: false
"someObject.undefinedProp" in window: false
"notDefined" in window: false
typeof definedButNotInitialized == "undefined": true
typeof definedButNotInitialized === typeof undefined: true
definedButNotInitialized === undefined: true
! definedButNotInitialized: true
!! definedButNotInitialized: false
typeof definedAndInitialized == "undefined": false
typeof definedAndInitialized === typeof undefined: false
definedAndInitialized === undefined: false
! definedAndInitialized: false
!! definedAndInitialized: true
typeof someObject.firstProp == "undefined": false
typeof someObject.firstProp === typeof undefined: false
someObject.firstProp === undefined: false
! someObject.firstProp: false
!! someObject.firstProp: true
typeof someObject.secondProp == "undefined": false
typeof someObject.secondProp === typeof undefined: false
someObject.secondProp === undefined: false
! someObject.secondProp: true
!! someObject.secondProp: false
typeof someObject.undefinedProp == "undefined": true
typeof someObject.undefinedProp === typeof undefined: true
someObject.undefinedProp === undefined: true
! someObject.undefinedProp: true
!! someObject.undefinedProp: false
typeof notDefined == "undefined": true
typeof notDefined === typeof undefined: true
notDefined === undefined: Exception--ReferenceError: notDefined is not defined
! notDefined: Exception--ReferenceError: notDefined is not defined
!! notDefined: Exception--ReferenceError: notDefined is not defined
În acest articol am citit cadre, cum ar fi Underscore.js utilizați această funcție:
function isUndefined(obj){
return obj === void 0;
}
Personal, eu folosesc întotdeauna următoarele:
var x;
if( x === undefined) {
//Do something here
}
else {
//Do something else here
}
Fereastra.nedefinit proprietate este non-scriere în toate browserele moderne (JavaScript 1.8.5 sau mai târziu). Din Opera's documentație: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined am vedea acest lucru: Un motiv de a folosi typeof() este ca nu arunca o eroare dacă variabila nu a fost definit.
Prefer să abordez folosind
x === undefined
pentru că nu și explodează în față, mai degrabă decât în tăcere trece/nu dacă x nu a fost declarată înainte. Asta mă avertizează că x nu este declarat. Cred că toate variabilele utilizate în JavaScript trebuie să fie declarate.
Cel mai de încredere știu de verificare pentru "nedefinit" este de a utiliza nul 0
.
Acest lucru este compatibil cu versiuni mai noi și mai vechi browsere, deopotrivă, și nu pot fi suprascrise ca fereastra.nedefinit
poate în unele cazuri.
if( myVar === void 0){
//yup it's undefined
}
Dimpotrivă de @Thomas Eding răspuns:
Dacă am uitat să declare myVar în codul meu, apoi m-am'll
myVar nu este definit`.
Las's ia un exemplu real:
Am'am un nume de variabilă, dar eu nu sunt sigur dacă acesta este declarat undeva sau nu.
Apoi @Anurag's raspunsul va va ajuta:
var myVariableToCheck = 'myVar';
if (window[myVariableToCheck] === undefined)
console.log("Not declared or declared, but undefined.");
// Or you can check it directly
if (window['myVar'] === undefined)
console.log("Not declared or declared, but undefined.");
var x;
if (x === undefined) {
alert ("I am declared, but not defined.")
};
if (typeof y === "undefined") {
alert ("I am not even declared.")
};
/* One more thing to understand: typeof ==='undefined' also checks
for if a variable is declared, but no value is assigned. In other
words, the variable is declared, but not defined. */
// Will repeat above logic of x for typeof === 'undefined'
if (x === undefined) {
alert ("I am declared, but not defined.")
};
/* So typeof === 'undefined' works for both, but x === undefined
only works for a variable which is at least declared. */
/* Say if I try using typeof === undefined (not in quotes) for
a variable which is not even declared, we will get run a
time error. */
if (z === undefined) {
alert ("I am neither declared nor defined.")
};
// I got this error for z ReferenceError: z is not defined
Am folosi-o ca o funcție parametru și să-l excludă pe funcția de execuție care pot obține "reală" nedefinit. Deși are nevoie de tine pentru a pune codul în interiorul unei funcții. Am găsit asta în timp ce citesc jQuery sursa.
undefined = 2;
(function (undefined) {
console.log(undefined); // prints out undefined
// and for comparison:
if (undeclaredvar === undefined) console.log("it works!")
})()
Desigur, ai putea folosi doar typeof
totuși. Dar toate meu de cod este, de obicei, în interiorul unui conțin funcția oricum, deci, folosind această metodă, probabil, salvează-mă câteva bytes aici și acolo.