Frage Wie kann man in JavaScript nach "undefiniert" suchen? [Duplikat]


Diese Frage hat hier bereits eine Antwort:

Was ist der beste Weg zu testen, ob eine Variable in JavaScript nicht definiert ist? Ich habe mehrere Möglichkeiten gesehen:

if (window.myVariable)

Oder

if (typeof(myVariable) != "undefined")

Oder

if (myVariable) //This throws an error if undefined. Should this be in Try/Catch?

1872
2017-08-02 17:53


Ursprung


Antworten:


Wenn Sie herausfinden möchten, ob eine Variable unabhängig von ihrem Wert deklariert wurde, dann verwenden Sie die in Betreiber ist der sicherste Weg zu gehen. Betrachten Sie dieses Beispiel.

// global scope
var theFu; // theFu has been declared, but its value is undefined
typeof theFu; // "undefined"

In einigen Fällen ist dies jedoch nicht das beabsichtigte Ergebnis, da die Variable oder Eigenschaft deklariert, aber nicht initialisiert wurde. Benutze die in Operator für eine robustere Prüfung.

"theFu" in window; // true
"theFoo" in window; // false

Wenn Sie wissen möchten, ob die Variable nicht deklariert wurde oder den Wert hat undefined, dann benutze die typeof Operator.

if (typeof myVar != 'undefined')

Das typeof Der Operator gibt garantiert einen String zurück. Direkte Vergleiche gegen undefined sind lästig wie undefined kann überschrieben werden.

window.undefined = "omg";
"omg" == undefined // true

Wie @CMS darauf hingewiesen hat, wurde dies in ECMAScript 5th ed. Und undefined ist nicht beschreibbar.

if (window.myVar) wird auch diese Falsy-Werte enthalten, also ist es nicht sehr robust:

falsch
0
""
NaN
Null
nicht definiert

Danke an @CMS für den Hinweis, dass Ihr dritter Fall - if (myVariable) kann in zwei Fällen auch einen Fehler auslösen. Die erste ist, wenn die Variable nicht definiert wurde, die ein wirft ReferenceError.

// abc was never declared.
if (abc) {
    // ReferenceError: abc is not defined
} 

Der andere Fall ist, wenn die Variable definiert wurde, aber eine Getter-Funktion hat, die beim Aufruf einen Fehler auslöst. Beispielsweise,

// 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?
}

2156
2017-08-02 17:58



Ich persönlich benutze

myVar === undefined

Warnung: Bitte beachten Sie, dass === wird über gebraucht == und das myVar war vorher erklärt (nicht definiert).


ich mag nicht typeof myVar === "undefined". Ich denke, es ist langatmig und unnötig. (Ich kann das gleiche in weniger Code machen.)

Jetzt werden einige Leute vor Schmerz umkippen, wenn sie das lesen und schreien: "Warte! WAAITTT !!! undefined kann neu definiert werden! "

Cool. Ich weiß das. Andererseits können die meisten Variablen in Javascript neu definiert werden. Sollten Sie nie eine eingebaute ID verwenden, die neu definiert werden kann?

Wenn du dieser Regel folgst, gut für dich: du bist kein Heuchler.

Um wirklich viel Arbeit in JS zu verrichten, müssen sich Entwickler auf redefinierbare Bezeichner verlassen, um genau das zu sein, was sie sind. Ich höre nicht, dass Leute mir sagen, dass ich nicht benutzen soll setTimeout weil jemand kann

window.setTimeout = function () {
    alert("Got you now!");
};

Bottom line, das Argument "es kann neu definiert werden", um kein rohe zu verwenden === undefined ist falsch.

(Wenn Sie immer noch Angst vor haben undefined neu definiert werden, warum integrieren Sie blind nicht getesteten Bibliothekscode in Ihre Codebasis? Oder noch einfacher: ein Linting-Tool.)


Auch, wie die typeof Ansatz kann diese Technik nicht deklarierte Variablen "erkennen":

if (window.someVar === undefined) {
    doSomething();
}

Aber beide Techniken verlieren ihre Abstraktion. Ich fordere Sie dringend auf, dies oder gar nicht zu verwenden

if (typeof myVar !== "undefined") {
    doSomething();
}

Erwägen:

var iAmUndefined;

Um zu erfassen, ob diese Variable deklariert ist oder nicht, müssen Sie möglicherweise auf die in Operator. (In vielen Fällen können Sie einfach den Code O_o lesen).

if ("myVar" in window) {
    doSomething();
}

Aber warte! Es gibt mehr! Was ist, wenn etwas Prototypenkettenmagie passiert ...? Jetzt auch der Vorgesetzte in Betreiber reicht nicht aus. (Okay, ich bin hier über diesen Teil fertig, außer zu sagen, dass in 99% der Zeit, === undefined (und **** Husten **** typeof) funktioniert gut. Wenn es Ihnen wirklich wichtig ist, können Sie dieses Thema selbst lesen.)


888
2017-08-02 18:26



Verwenden typeof ist meine Vorliebe. Es funktioniert, wenn die Variable nie deklariert wurde, anders als jeder Vergleich mit der == oder === Operatoren oder Typ Nötigung mit if. (undefined, nicht wie null, kann auch in ECMAScript 3-Umgebungen neu definiert werden, was es für Vergleiche unzuverlässig macht, obwohl fast alle gängigen Umgebungen jetzt mit ECMAScript 5 oder höher kompatibel sind).

if (typeof someUndeclaredVariable == "undefined") {
    // Works
}

if (someUndeclaredVariable === undefined) { 
    // Throws an error
}

149
2017-08-02 18:05



Sie müssen verwenden typeof .

if (typeof something != "undefined") {
    // ...
}

51
2018-06-06 20:22



Wenn es nicht definiert ist, ist es nicht gleich einer Zeichenfolge, die die Zeichen "undefined" enthält, da die Zeichenfolge nicht definiert ist.

Sie können den Typ der Variablen überprüfen:

if (typeof(something) != "undefined") ...

Manchmal müssen Sie nicht einmal den Typ überprüfen. Wenn der Wert der Variablen nicht als falsch ausgewertet werden kann (wenn es sich beispielsweise um eine Funktion handelt), können Sie die Variable einfach auswerten. Beispiel:

if (something) {
  something(param);
}

20
2018-06-06 20:23



Einige Szenarien veranschaulichen die Ergebnisse der verschiedenen Antworten: http://jsfiddle.net/drzaus/UVjM4/

(Beachten Sie, dass die Verwendung von var zum in Tests machen einen Unterschied, wenn in einem Umriss-Wrapper)

Referenzcode:

(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;
    }
})();

Und Ergebnisse:

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

17
2018-01-13 15:39



if (typeof foo == 'undefined') {
 // Do something
};

Beachten Sie, dass strikte Vergleich (!==) ist in diesem Fall nicht notwendig, da typeof gibt immer einen String zurück.


16
2018-06-06 20:26



Im Dieser Artikel Ich lese diese Frameworks wie Underscore.js benutze diese Funktion:

function isUndefined(obj){
    return obj === void 0;
}

15
2017-12-19 10:42



Die zuverlässigste Art, nach der ich suche undefined ist zu benutzen void 0.

Dies ist kompatibel mit neueren und älteren Browsern und kann nicht überschrieben werden window.undefined kann in einigen Fällen.

if( myVar === void 0){
    //yup it's undefined
}

9
2018-02-19 13:20