variable === undefiniert vs. typeof variable === "undefiniert"

Question

En jQuery Core Style-Richtlinien schlagen zwei verschiedene Möglichkeiten 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 lokale Variablen und Eigenschaften?

Answer 1

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

Bei Variablen, die nicht lokal und nirgends definiert sind, wird die Prüfung someVar === undefined wird eine Ausnahme auslösen: Ungefangener ReferenceError: j ist nicht definiert

Hier ist ein Code, der verdeutlichen soll, was ich oben gesagt habe. Bitte beachten Sie die Inline-Kommentare für mehr Klarheit .

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 wie folgt aussehen:

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 (eigentlich mit jedem 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 Prüfung auf diese Weise durchführen: typeof x === 'undefined' fragen Sie im Wesentlichen dies: Bitte prüfen Sie, ob die Variable x irgendwo im Quellcode existiert (definiert wurde). (mehr oder weniger). Wenn Sie sich mit C# oder Java auskennen, wird diese Art von Prüfung nie durchgeführt, denn wenn sie nicht vorhanden ist, wird sie nicht kompiliert.

<== Fiddle Me ==>

Answer 2

Zusammenfassung:

Im globalen Bereich wollen wir eigentlich true zurückgeben, wenn die Variable nicht deklariert ist oder den Wert undefined :

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 im globalen Bereich nicht 100%ig sicher sind, ob eine Variable deklariert ist, kann dies zu einem ReferenceError führen. Wenn wir die typeof Operator auf die unbekannte Variable anwenden, tritt dieses Problem nicht auf, wenn die Variable nicht deklariert ist:

var globalVar1;

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

Dies ist auf die Tatsache zurückzuführen, dass die typeof Operator gibt die Zeichenkette undefined wenn eine Variable nicht deklariert ist oder gerade den Wert enthält undefined was genau das ist, was wir wollen.

---

• Bei lokalen Variablen haben wir dieses Problem nicht, weil wir schon vorher wissen, dass diese Variable existieren wird. Wir können einfach in der jeweiligen Funktion nachsehen, ob die Variable vorhanden ist.

• Mit Objekteigenschaften haben wir dieses Problem nicht, denn wenn wir versuchen, eine Objekteigenschaft zu suchen, die nicht existiert, erhalten wir auch den Wert undefined

  var obj = {};

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

Answer 3

typeof a === 'undefined' ist schneller als a === 'undefined' um etwa 2 Mal auf dem Knoten v6.9.1.