variable === undefined vs typeof variable === “undefined”

Je collerais à l'aide de typeof foo === "undefined" partout. Qui ne peut jamais se tromper.

J'imagine que la raison pour laquelle jQuery recommande les deux différentes méthodes est qu'elles définissent leurs propres undefined variable dans la fonction jQuery code de vie, donc à l'intérieur de cette fonction undefined est à l'abri de la falsification de l'extérieur. J'imagine aussi que quelqu'un, quelque part, a comparé les deux approches différentes et découvert que foo === undefined est plus rapide et, par conséquent, décidé qu'il est le chemin à parcourir. [Mise à JOUR: comme mentionné dans les commentaires, la comparaison avec undefined est également légèrement plus courte, ce qui pourrait être une considération.] Cependant, le gain en situations pratiques serez tout à fait négligeable: cette case ne sera jamais, jamais être une sorte de goulot d'étranglement, et ce que vous perdez est significatif: l'évaluation d'une propriété d'un objet hôte de comparaison peuvent jeter une erreur alors qu'une typeof vérifier le sera jamais.

Par exemple, le texte suivant est utilisé dans IE pour l'analyse XML:

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

Vérifier si elle a un loadXML méthode de sécurité:

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

D'autre part:

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

Mise à JOUR

Un autre avantage de la typeof vérifier que j'ai oublié de mentionner que ça fonctionne aussi avec des variables non déclarées, qui le foo === undefined contrôle n'est pas, et, en fait, jette un ReferenceError. Grâce à @LinusKleen de me le rappeler. Par exemple:

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

Ligne du bas: utilisez toujours le typeof vérifier.

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

Pour les variables locales, en contrôlant avec localVar === undefined va fonctionner, car ils doivent avoir été défini dans la portée locale ou ils ne seront pas considérés comme locaux.

Pour les variables qui ne sont pas locaux et n'est défini nulle part, la vérification de someVar === undefined va jeter l'exception: Uncaught ReferenceError: j n'est pas défini

Voici un code qui permettra de clarifier ce que je dis ci-dessus. S'il vous plaît prêter 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 celui-ci (avec une valeur quelconque 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.

Lorsque vous faites la case comme ceci: typeof x === 'undefined', vous êtes à la demande, en substance, ceci: Veuillez vérifier si la variable x existe (a été défini) quelque part dans le code source. (plus ou moins). Si vous connaissez le C# ou Java, ce type de vérification n'est jamais fait parce que, si elle n'existe pas, il ne compile pas.

<== Tripoter Moi ==>

typeof a === 'undefined' est plus rapide que d' a === 'undefined' par environ 2 fois sur le nœud v6.9.1.