variable = = = non définie vs. typeof variable = = = " non définie"

les jQuery Core Style Guidelines suggèrent deux façons différentes de vérifier si une variable est définie.

  • Variables Globales: typeof variable === "undefined"
  • Variables Locales: variable === undefined
  • propriétés: object.prop === undefined

pourquoi jQuery utilise-t-il une approche pour les variables globales et une autre pour les locaux et les propriétés?

225
demandé sur Patrick McElhaney 2011-01-18 18:02:56
la source

7 ответов

pour les variables non déclarées, typeof foo renvoie la chaîne littérale "undefined" , tandis que le contrôle d'identité foo === undefined déclenche l'erreur " foo n'est pas défini " .

pour les variables locales (que vous savez sont déclarées quelque part), aucune erreur de ce type ne se produirait, d'où le contrôle d'identité.

283
répondu Linus Kleen 2016-02-26 18:37:49
la source

Je m'en tiendrais à utiliser typeof foo === "undefined" partout. Qui ne peut jamais se tromper.

j'imagine que la raison pour laquelle jQuery recommande les deux méthodes différentes est qu'elles définissent leur propre variable undefined dans la fonction dans laquelle le code jQuery vit, donc dans cette fonction undefined est à l'abri de toute altération de l'extérieur. J'imagine aussi que quelqu'un quelque part a comparé les deux approches différentes et a découvert que foo === undefined est plus rapide et par conséquent décidé que c'est le chemin à parcourir. [mise à JOUR: comme mentionné dans les commentaires, la comparaison avec les undefined est également légèrement plus courte, ce qui pourrait être une considération.] cependant, le gain dans les situations pratiques sera tout à fait insignifiant: ce contrôle ne sera jamais, jamais n'importe quelle sorte de goulot d'étranglement, et ce que vous perdez est significatif: évaluer une propriété d'un objet hôte pour la comparaison peut jeter une erreur tandis qu'un typeof contrôle ne sera jamais.

par exemple, ce qui suit est utilisé dans IE pour l'analyse XML:

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

pour vérifier s'il existe une méthode loadXML sûre:

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

d'autre part:

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

mise à JOUR

un autre avantage du contrôle typeof que j'ai oublié de mentionner est qu'il fonctionne aussi avec des variables non déclarées, ce que le contrôle foo === undefined fait non, et en fait jette un ReferenceError . Merci à @LinusKleen de me le rappeler. Par exemple:

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

résultat net: toujours utiliser la vérification typeof .

99
répondu Tim Down 2014-06-17 11:54:37
la source

encore une autre raison d'utiliser la variante de type: undefined peut être redéfini.

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

le résultat de typeof variable ne peut pas.

Update : notez que ce n'est pas le cas dans ES5.

24
répondu Jakob 2015-01-26 14:33:57
la source

qui est intéressé par le gain de performance de variable === undefined , peut jeter un oeil ici, mais il semble être une optimisation chrome seulement.

4
répondu RiZKiT 2014-02-19 15:06:49
la source

parce que undefined n'est pas toujours déclaré, mais jQuery déclare undefined dans sa fonction principale. Ils utilisent donc la valeur sûre undefined à l'interne, mais à l'extérieur, ils utilisent le style typeof pour être sûrs.

4
répondu Struppi 2018-03-31 18:52:09
la source

pour les variables locales, vérifier avec localVar === undefined fonctionnera parce qu'elles doivent avoir été définies quelque part dans la portée locale ou elles ne seront pas considérées comme locales.

pour les variables qui ne sont pas locales et qui ne sont définies nulle part, le contrôle someVar === undefined fera exception: Référenceerror Uncaught: j n'est pas défini

voici un code qui clarifiera ce que je dis ci-dessus. s'il vous plaît payer attention aux commentaires en ligne pour plus de clarté .

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\'].');
};

si nous appelons le code ci-dessus comme ceci:

f();

La sortie serait celui-ci:

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.

si nous appelons le code ci-dessus comme ceci (avec n'importe quelle valeur en fait):

f(null); 
f(1);

la sortie sera:

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.

: typeof x === 'undefined' , vous demandez essentiellement ceci: veuillez vérifier si la variable x existe (a été définie) quelque part dans le code source. (plus ou moins). Si vous connaissez C# ou Java, ce type de vérification n'est jamais fait car s'il n'existe pas, il ne compilera pas.

<== Tripoter Moi ==>

0
répondu CodingYoshi 2017-10-09 00:55:13
la source

typeof a === 'undefined' est plus rapide que a === 'undefined' par environ 2 fois sur le noeud v6.9.1.

-1
répondu Eduard Popov 2017-05-23 01:01:59
la source

Autres questions sur javascript jquery undefined