Vraag Hoe te controleren op "undefined" in JavaScript? [duplicaat]


Deze vraag heeft hier al een antwoord:

Wat is de meest geschikte manier om te testen of een variabele ongedefinieerd is in JavaScript? Ik heb verschillende manieren gezien:

if (window.myVariable)

Of

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

Of

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

1872
2017-08-02 17:53


oorsprong


antwoorden:


Als u wilt weten of een variabele is gedeclareerd, ongeacht de waarde, dan gebruikt u de in operator is de veiligste manier om te gaan. Overweeg dit voorbeeld.

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

Maar dit is misschien niet het beoogde resultaat voor sommige gevallen, omdat de variabele of eigenschap is gedeclareerd maar niet is geïnitialiseerd. Gebruik de in operator voor een meer robuuste controle.

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

Als u geïnteresseerd bent om te weten of de variabele niet is gedeclareerd of de waarde heeft undefined, gebruik dan de typeof operator.

if (typeof myVar != 'undefined')

De typeof operator krijgt gegarandeerd een tekenreeks. Directe vergelijkingen tegen undefined zijn lastig als undefined kan worden overschreven.

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

Zoals @CMS opmerkt, is dit gepatcht in ECMAScript 5th ed., And undefined is niet-schrijfbaar.

if (window.myVar) zal ook deze valse waarden bevatten, dus het is niet erg robuust:

vals
0
""
NaN
nul
onbepaald

Bedankt aan @CMS om erop te wijzen dat je derde zaak - if (myVariable) kan ook in twee gevallen een fout veroorzaken. De eerste is wanneer de variabele niet is gedefinieerd die gooit ReferenceError.

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

Het andere geval is wanneer de variabele is gedefinieerd, maar een getterfunctie heeft die een fout genereert wanneer deze wordt aangeroepen. Bijvoorbeeld,

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



Ik persoonlijk gebruik

myVar === undefined

Waarschuwing: houd er rekening mee dat === wordt gebruikt == en dat myVar was eerder verklaard (niet bepaald).


ik hou niet van typeof myVar === "undefined". Ik denk dat het langdradig en onnodig is. (Ik kan hetzelfde gedaan krijgen in minder code.)

Sommige mensen zullen nu pijn hebben als ze dit lezen, schreeuwend: "Wacht! WAAITTT !!! undefined kan opnieuw worden gedefinieerd! "

Koel. Ik weet dit. Aan de andere kant kunnen de meeste variabelen in Javascript opnieuw worden gedefinieerd. Zou u nooit een ingebouwde identifier moeten gebruiken die geherdefinieerd kan worden?

Als u deze regel volgt, is dat goed voor u: u bent geen huichelaar.

Het punt is dat ontwikkelaars, om veel echt werk in JS te doen, moeten vertrouwen op herdefinieerbare identificaties om te zijn wat ze zijn. Ik hoor mensen niet zeggen dat ik ze niet moet gebruiken setTimeout omdat iemand dat kan

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

Waar het op neerkomt, is het argument "it can be gedefineded" om geen raw te gebruiken === undefined is nep.

(Als je nog steeds bang bent undefined wordt geherdefinieerd, waarom integreer je blind geteste bibliotheekcode in je codebasis? Of nog eenvoudiger: een pluizig hulpmiddel.)


Ook, zoals de typeof benadering, kan deze techniek niet-verklaarde variabelen "detecteren":

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

Maar deze beide technieken lekken in hun abstractie. Ik dring er bij u op aan dit niet te gebruiken of zelfs niet

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

Overwegen:

var iAmUndefined;

Om vast te stellen of die variabele al dan niet wordt aangegeven, moet u mogelijk een beroep doen op de in operator. (In veel gevallen kunt u eenvoudig de code lezen O_o).

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

Maar wacht! Er is meer! Wat als er een prototype kettingmagie plaatsvindt ...? Nu zelfs de meerdere in operator is niet voldoende. (Oké, ik ben hier klaar met dit deel behalve om dat voor 99% van de tijd te zeggen, === undefined (en **** hoest **** typeof) werkt prima. Als het je echt iets kan schelen, kun je dit alleen lezen.)


888
2017-08-02 18:26



Gebruik makend van typeof is mijn voorkeur. Het werkt als de variabele nooit is opgegeven, in tegenstelling tot een vergelijking met de == of === operatoren of type dwang met if. (undefined, in tegenstelling tot null, kan ook worden geherdefinieerd in ECMAScript 3-omgevingen, waardoor het onbetrouwbaar is voor vergelijking, hoewel bijna alle gangbare omgevingen nu compatibel zijn met ECMAScript 5 of hoger).

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

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

149
2017-08-02 18:05



Je moet gebruiken typeof .

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

51
2018-06-06 20:22



Als het ongedefinieerd is, is het niet gelijk aan een tekenreeks die de tekens "undefined" bevat, omdat de reeks niet ongedefinieerd is.

U kunt het type van de variabele controleren:

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

Soms hoeft u niet eens het type te controleren. Als de waarde van de variabele niet kan worden geëvalueerd als deze is ingesteld (bijvoorbeeld als het een functie is), kunt u de variabele gewoon evalueren. Voorbeeld:

if (something) {
  something(param);
}

20
2018-06-06 20:23



Enkele scenario's ter illustratie van de resultaten van de verschillende antwoorden: http://jsfiddle.net/drzaus/UVjM4/

(Merk op dat het gebruik van var voor in testen maken het verschil in een scoped wikkel)

Code voor referentie:

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

En resultaten:

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

Merk op dat een strikte vergelijking (!==) is in dit geval niet nodig, omdat typeof zal altijd een string retourneren.


16
2018-06-06 20:26



In Dit artikel Ik las dat raamwerken zoals Underscore.js gebruik deze functie:

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

15
2017-12-19 10:42