JavaScript: undefined! == undefined?

Question

REMARQUE: Comme par ECMAScript5.1, section 15.1.1.3, fenêtre.undefined est en lecture seule.

• Les navigateurs modernes de mettre en œuvre correctement. par exemple: Safari 5.1, Firefox 7, Chrome 20, etc.
• Undefined est toujours changeantes: Chrome 14, ...

Quand j'ai récemment intégré Facebook se Connecter avec Tersus, j'ai d'abord reçu les messages d'erreur Invalid Enumeration Value et Handler already exists lorsque vous essayez d'appeler Facebook fonctions de l'API.

Il s'est avéré que la cause du problème a été

object.x === undefined

retourner false lorsqu'il n'y a pas de propriété " x " en "objet".

J'ai contourné le problème en remplaçant la stricte égalité avec régulièrement de l'égalité dans les deux Facebook fonctions:

FB.Sys.isUndefined = function(o) { return o == undefined;};
FB.Sys.containsKey = function(d, key) { return d[key] != undefined;};

De ce fait des choses pour moi, mais semble faire allusion à une sorte de collision entre Facebook du code JavaScript et la mienne.

Quelle pourrait en être la cause?

Astuce: Il est bien documenté que undefined == null tout undefined !== null. Ce n'est pas la question ici. La question est de savoir comment vient nous obtenons undefined !== undefined.

Answer 1

Le problème est que non défini par rapport à null en utilisant == donne true. La vérification commune pour undefined se fait donc comme suit:

 typeof x == "undefined"
 

Cela garantit que le type de la variable est vraiment indéfini.

Answer 2

Il s'avère que vous pouvez définir window.undefined sur ce que vous voulez, et obtenir ainsi object.x !== undefined lorsque object.x est le véritable indéfini. Dans mon cas, j’ai par inadvertance mis undefined à null.

Le moyen le plus simple de voir cela se produire est:

 window.undefined = null;
alert(window.xyzw === undefined); // shows false
 

Bien sûr, cela n’est pas susceptible de se produire. Dans mon cas, le bogue était un peu plus subtil et équivalait au scénario suivant.

 var n = window.someName; // someName expected to be set but is actually undefined
window[n]=null; // I thought I was clearing the old value but was actually changing window.undefined to null
alert(window.xyzw === undefined); // shows false
 

Answer 3

J'aimerais poster quelques informations importantes à propos de undefined,, les débutants peuvent pas connaître.

Regardez le code suivant:

 /* 
  * Consider there is no code above. 
  * The browser runs these lines only.
  */

   // var a;  
   // --- commented out to point that we've forgotten to declare `a` variable 

   if ( a === undefined ) {
       alert('Not defined');
   } else {
       alert('Defined: ' + a);
   }

   alert('Doing important job below');

Si vous exécutez ce code, où la variable a n'A JAMAIS ÉTÉ DÉCLARÉE à l'aide d' var, vous obtiendrez un message d'ERREUR d'EXCEPTION, et étonnamment, voir pas d'alertes à tous.

Au lieu de "Faire travail important d'en bas", le script sera terminé de façon INATTENDUE, en jetant exception non gérée sur la première ligne.

---

Ici est le seul pare-balles moyen de vérifier la undefined l'aide typeof mot-clé, qui a été conçu justement à cet effet:

   /* 
    * Correct and safe way of checking for `undefined`: 
    */

   if ( typeof a === 'undefined' ) {
       alert(
           'The variable is not declared in this scope, \n' +
           'or you are pointing to unexisting property, \n' +
           'or no value has been set yet to the variable, \n' + 
           'or the value set was `undefined`. \n' +
           '(two last cases are equivalent, don\'t worry if it blows out your mind.'
           );
   }

   /* 
    *  Use `typeof` for checking things like that
    */

Cette méthode fonctionne dans tous les cas possibles.

Le dernier argument c'est qu' undefined peut être remplacée dans les versions antérieures de Javascript:

     /* @ Trollface @ */
        undefined = 2;
     /* Happy debuging! */  

Espère que j'ai été assez clair.

Answer 4

C'est une mauvaise pratique d'utiliser l' == opérateur d'égalité au lieu de ===.

undefined === undefined // true
null == undefined // true
null === undefined // false

L' object.x === undefined doit renvoyer true si x est inconnu de la propriété.

Dans le chapitre de Mauvaises Pièces de JavaScript: Les Bonnes Parties, Crockford écrit ce qui suit:

Si vous essayez d'extraire une valeur de un objet, et si l'objet n' avoir un membre de ce nom, il renvoie la valeur undefined place.

En plus indéfini, JavaScript a une valeur similaire appelé null. Ils sont tellement similaires qu' == pense qu'ils sont de l'égalité. Qui confond certains programmeurs en pensant qu'ils sont interchangeables, conduisant à un code comme

value = myObject[name];
if (value == null) {
    alert(name + ' not found.');
}

C'est en comparant la valeur faux avec le mal de l'opérateur. Ce code fonctionne parce qu'il contient deux erreurs qui annuler les uns les autres. C'est un fou façon de programmer. Il est mieux écrit comme ceci:

value = myObject[name];
if (value === undefined) {
    alert(name + ' not found.');
}

Answer 5

De - JQuery_Core_Style_Guidelines

• Variables globales:
  typeof variable === "undefined"

• Variables locales:
  variable === undefined

• Propriétés:
  object.prop === undefined