Question Comment vérifier "indéfini" en JavaScript? [dupliquer]


Cette question a déjà une réponse ici:

Quelle est la manière la plus appropriée de tester si une variable n'est pas définie en JavaScript? J'ai vu plusieurs façons possibles:

if (window.myVariable)

Ou

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

Ou

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

1872
2017-08-02 17:53


origine


Réponses:


Si vous souhaitez savoir si une variable a été déclarée indépendamment de sa valeur, utilisez le in l'opérateur est le moyen le plus sûr d'y aller. Considérez cet exemple.

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

Mais ce n'est peut-être pas le résultat escompté dans certains cas, puisque la variable ou la propriété a été déclarée mais n'a tout simplement pas été initialisée. Utilisez le in opérateur pour un contrôle plus robuste.

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

Si vous souhaitez savoir si la variable n'a pas été déclarée ou si elle a la valeur undefined, puis utilisez le typeof opérateur.

if (typeof myVar != 'undefined')

le typeof L'opérateur est garanti pour retourner une chaîne. Comparaisons directes contre undefined sont gênants comme undefined peut être écrasé.

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

Comme @CMS l'a fait remarquer, ceci a été corrigé dans ECMAScript 5th ed., Et undefined est non-inscriptible.

if (window.myVar) inclura également ces valeurs de fausseté, donc ce n'est pas très robuste:

faux
0
""
NaN
nul
indéfini

Merci à @CMS pour avoir signalé que votre troisième cas - if (myVariable) peut aussi lancer une erreur dans deux cas. Le premier est quand la variable n'a pas été définie qui jette un ReferenceError.

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

L'autre cas est quand la variable a été définie, mais a une fonction de getter qui jette une erreur quand invoquée. Par exemple,

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



J'utilise personnellement

myVar === undefined

Attention: Veuillez noter que === est utilisé sur == et cela myVar a été précédemment déclaré (ne pas défini).


Je n'aime pas typeof myVar === "undefined". Je pense que c'est long et inutile. (Je peux obtenir la même chose en moins de code.)

Maintenant, certaines personnes vont souffrir de douleur lorsqu'elles lisent ceci, en criant: "Attends! WAAITTT !!! undefined peut être redéfini! "

Cool. Je sais ça. Là encore, la plupart des variables de Javascript peuvent être redéfinies. Ne devriez-vous jamais utiliser un identifiant intégré pouvant être redéfini?

Si vous suivez cette règle, c'est bon pour vous: vous n'êtes pas un hypocrite.

Le fait est que, pour faire beaucoup de travail réel dans JS, les développeurs doivent s'appuyer sur des identifiants redéfinissables pour être ce qu'ils sont. Je n'entends pas les gens me dire que je ne devrais pas utiliser setTimeout parce que quelqu'un peut

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

Bottom line, l'argument "il peut être redéfini" pour ne pas utiliser un brut === undefined est faux.

(Si vous avez encore peur de undefined En cours de redéfinition, pourquoi intégrez-vous aveuglément du code de bibliothèque non testé dans votre base de code? Ou encore plus simple: un outil de peluchage.)


Aussi, comme le typeof approche, cette technique peut "détecter" des variables non déclarées:

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

Mais ces deux techniques coulent dans leur abstraction. Je vous exhorte à ne pas utiliser cela ou même

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

Considérer:

var iAmUndefined;

Pour savoir si cette variable est déclarée ou non, vous devrez peut-être recourir à in opérateur. (Dans de nombreux cas, vous pouvez simplement lire le code O_o).

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

Mais attendez! Il y a plus! Que se passe-t-il si une magie de chaîne prototype se produit ...? Maintenant même le supérieur in l'opérateur ne suffit pas. (D'accord, je suis fait ici à propos de cette partie, sauf pour dire que pour 99% du temps, === undefined (et **** toux **** typeof) fonctionne très bien. Si vous vous souciez vraiment, vous pouvez lire sur ce sujet tout seul.)


888
2017-08-02 18:26



En utilisant typeof est ma préférence. Il fonctionnera quand la variable n'a jamais été déclarée, contrairement à toute comparaison avec le == ou === les opérateurs ou la coercition de type en utilisant if. (undefined, contrairement à null, peut également être redéfini dans les environnements ECMAScript 3, ce qui le rend peu fiable pour la comparaison, bien que presque tous les environnements courants soient maintenant compatibles avec ECMAScript 5 ou supérieur).

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

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

149
2017-08-02 18:05



Vous devez utiliser typeof .

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

51
2018-06-06 20:22



Si elle n'est pas définie, elle ne sera pas égale à une chaîne contenant les caractères "indéfini", car la chaîne n'est pas indéfinie.

Vous pouvez vérifier le type de la variable:

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

Parfois, vous n'avez même pas à vérifier le type. Si la valeur de la variable ne peut pas être évaluée à false lorsqu'elle est définie (par exemple s'il s'agit d'une fonction), vous pouvez simplement évaluer la variable. Exemple:

if (something) {
  something(param);
}

20
2018-06-06 20:23



Quelques scénarios illustrant les résultats des différentes réponses: http://jsfiddle.net/drzaus/UVjM4/

(Notez que l'utilisation de var pour in les tests font la différence quand ils sont dans une enveloppe portée)

Code de référence:

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

Et les résultats:

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

Notez que la comparaison stricte (!==) n'est pas nécessaire dans ce cas, typeof retournera toujours une chaîne.


16
2018-06-06 20:26



Dans Cet article J'ai lu que les cadres comme Underscore.js utilisez cette fonction:

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

15
2017-12-19 10:42