it-swarm.com.de

variable === undefined vs. Typ der Variablen === "undefined"

Die jQuery Core Style-Richtlinien schlagen zwei verschiedene Methoden vor, um zu prüfen, ob eine Variable definiert ist.

  • Globale Variablen: typeof variable === "undefined"
  • Lokale Variablen: variable === undefined
  • Eigenschaften: object.prop === undefined

Warum verwendet jQuery einen Ansatz für globale Variablen und einen anderen für Einheimische und Eigenschaften?

249

Für nicht deklarierte Variablen gibt typeof foo das String-Literal "undefined" zurück, wohingegen die Identitätsprüfung foo === undefined den Fehler "foo ist nicht definiert" auslösen würde.

Bei lokalen Variablen (von denen Sie know irgendwo deklariert sind) tritt kein solcher Fehler auf, daher die Identitätsprüfung.

308
Linus Kleen

Ich würde typeof foo === "undefined" überall verwenden. Das kann niemals schief gehen.

Ich kann mir vorstellen, dass der Grund, warum jQuery die beiden verschiedenen Methoden empfiehlt, darin besteht, dass sie ihre eigene Variable undefined innerhalb der Funktion definieren, in der jQuery-Code untergebracht ist. In dieser Funktion ist undefined vor Manipulationen von außen geschützt. Ich könnte mir auch vorstellen, dass irgendjemand irgendwo die beiden verschiedenen Ansätze getestet hat und festgestellt hat, dass foo === undefined schneller ist und deshalb entschieden hat, dass es der Weg ist. [UPDATE: Wie in den Kommentaren erwähnt, ist der Vergleich mit undefined auch etwas kürzer, was eine Überlegung sein könnte.] In praktischen Situationen ist der Gewinn jedoch völlig unbedeutend: Diese Prüfung wird niemals und nirgends möglich sein Engpässe, und was Sie verlieren, ist bedeutsam: Wenn Sie eine Eigenschaft eines Host-Objekts zum Vergleich auswerten, kann dies zu einem Fehler führen, während eine typeof-Prüfung dies niemals tun wird.

Zum Beispiel wird in IE Folgendes zum Parsen von XML verwendet:

var x = new ActiveXObject("Microsoft.XMLDOM");

So prüfen Sie, ob es sicher eine loadXML-Methode hat:

typeof x.loadXML === "undefined"; // Returns false

Auf der anderen Seite:

x.loadXML === undefined; // Throws an error

UPDATE

Ein weiterer Vorteil des typeof-Checks, den ich vergessen habe zu erwähnen, war, dass er auch mit nicht deklarierten Variablen funktioniert, was der foo === undefined-Check nicht tut und tatsächlich eine ReferenceError wirft. Danke an @LinusKleen für die Erinnerung an mich. Zum Beispiel:

typeof someUndeclaredVariable; // "undefined"
someUndeclaredVariable === undefined; // throws a ReferenceError

Fazit: Verwenden Sie immer die typeof-Prüfung.

106
Tim Down

Ein weiterer Grund für die Verwendung der typeof-Variante: undefined kann neu definiert werden.

undefined = "foo";
var variable = "foo";
if (variable === undefined)
  console.log("eh, what?!");

Das Ergebnis von typeof variable kann nicht.

Update : Beachten Sie, dass dies in ES5 nicht der Fall ist.

26
Jakob

Wer sich für den Leistungsgewinn von variable === undefined interessiert, kann hier einen Blick darauf werfen, aber es scheint nur eine Chromoptimierung zu sein.

6
RiZKiT

Da undefined nicht immer deklariert ist, deklariert jQuery undefined in seiner Hauptfunktion. Daher verwenden sie intern den sicheren undefined-Wert, außerhalb jedoch den typeof-Stil.

6
Struppi

Zusammenfassung:

Bei globalem Gültigkeitsbereich möchten wir tatsächlich true zurückgeben, wenn die Variable nicht deklariert ist oder den Wert undefined hat:

var globalVar1;

// This variable is declared, but not defined and thus has the value undefined
console.log(globalVar1 === undefined);

// This variable is not declared and thus will throw a referenceError
console.log(globalVar2 === undefined);

Da wir uns im globalen Bereich nicht zu 100% sicher sind, ob eine Variable deklariert wird, kann dies zu einem referenceError führen. Wenn wir den Operator typeof für die unbekannte Variable verwenden, wird dieses Problem nicht angezeigt, wenn die Variable nicht deklariert ist:

var globalVar1;

console.log(typeof globalVar1 === 'undefined');
console.log(typeof globalVar2 === 'undefined');

Dies liegt daran, dass der Operator typeof die Zeichenfolge undefined zurückgibt, wenn eine Variable nicht deklariert ist oder aktuell den Wert undefined enthält, der genau den gewünschten Wert hat.


  • Bei lokalen Variablen haben wir dieses Problem nicht, weil wir vorher wissen, dass diese Variable existiert. Wir können einfach in die jeweilige Funktion schauen, ob die Variable vorhanden ist.
  • Bei Objekteigenschaften haben wir dieses Problem nicht, da wir bei der Suche nach einer nicht vorhandenen Objekteigenschaft auch den Wert undefined erhalten.

var obj = {};

console.log(obj.myProp === undefined);

1

Bei lokalen Variablen funktioniert die Überprüfung mit localVar === undefined, da sie irgendwo innerhalb des lokalen Bereichs definiert worden sein müssen oder sie nicht als lokal betrachtet werden.

Bei Variablen, die nicht lokal und nirgendwo definiert sind, gibt die Prüfung someVar === undefined eine Ausnahme aus: Uncught ReferenceError: j ist nicht definiert

Hier ist ein Code, der klarstellt, was ich oben sage. Bitte achten Sie auf Inline-Kommentare, um mehr Klarheit zu schaffen.

function f (x) {
    if (x === undefined) console.log('x is undefined [x === undefined].');
    else console.log('x is not undefined [x === undefined.]');

    if (typeof(x) === 'undefined') console.log('x is undefined [typeof(x) === \'undefined\'].');
    else console.log('x is not undefined [typeof(x) === \'undefined\'].');

    // This will throw exception because what the hell is j? It is nowhere to be found.
    try
    {
        if (j === undefined) console.log('j is undefined [j === undefined].');
        else console.log('j is not undefined [j === undefined].');
    }
    catch(e){console.log('Error!!! Cannot use [j === undefined] because j is nowhere to be found in our source code.');}

    // However this will not throw exception
    if (typeof j === 'undefined') console.log('j is undefined (typeof(x) === \'undefined\'). We can use this check even though j is nowhere to be found in our source code and it will not throw.');
    else console.log('j is not undefined [typeof(x) === \'undefined\'].');
};

Wenn wir den obigen Code wie folgt aufrufen:

f();

Die Ausgabe würde folgendes sein:

x is undefined [x === undefined].
x is undefined [typeof(x) === 'undefined'].
Error!!! Cannot use [j === undefined] because j is nowhere to be found in our source code.
j is undefined (typeof(x) === 'undefined'). We can use this check even though j is nowhere to be found in our source code and it will not throw.

Wenn wir den obigen Code wie folgt aufrufen (tatsächlich mit einem beliebigen Wert):

f(null); 
f(1);

Die Ausgabe wird sein:

x is not undefined [x === undefined].
x is not undefined [typeof(x) === 'undefined'].
Error!!! Cannot use [j === undefined] because j is nowhere to be found in our source code.
j is undefined (typeof(x) === 'undefined'). We can use this check even though j is nowhere to be found in our source code and it will not throw.

Wenn Sie die Überprüfung wie folgt durchführen: typeof x === 'undefined', fragen Sie im Wesentlichen Folgendes: Bitte überprüfen Sie, ob die Variable x irgendwo im Quellcode existiert (definiert wurde). (mehr oder weniger). Wenn Sie C # oder Java kennen, wird diese Art von Überprüfung niemals durchgeführt, da sie nicht kompiliert wird, wenn sie nicht vorhanden ist. 

<== Fiddle Ich ==>

1
CodingYoshi

typeof a === 'undefined' ist auf Knoten v6.9.1 etwa 2-mal schneller als a === 'undefined'.

0
Eduard Popov