Lorsque JavaScript renvoie null & non définie?

Question

J'utilise JavaScript pour deux ans et n'a jamais pris soin de la différence entre null et undefined plus tôt, je l'utilise toujours undefined pour valider l'existence d'un objet.

Mais récemment, je suis venu par cet article . Ici, ils ont dit

  

JavaScript établit une distinction entre nulle, ce qui est un objet de type « objet » qui indique un volontaire non-valeur, et non définie, qui est qui indique une valeur non initialisée un objet de type « non défini » - qui est une valeur n » même pas encore été attribué. Nous parlerons des variables plus tard, mais en JavaScript il est possible de déclarer une variable sans lui attribuer une valeur. Si vous faites cela, le type de la variable est définie.

Je suis complètement confus maintenant, ce qui est non-valeur exactement ici. Comment cette non-valeur est différente de undefined. Et quelles sont les circonstances javascript renvoie null.

J'ai essayé l'exemple ci-dessous

var sam;
alert(sam);  // returns undefined

try {
    //var sam;
    alert(sam);  
} catch(ex) { }   // exception says: sam is undefined

Je ne suis pas sûr quand js retour nulls. Quelqu'un peut-il me préciser.

Answer 1

  

alert (SAM); // retourne undefined

Nope, c'est une exception.

Vous obtenez undefined lorsque vous accédez à une propriété unset; vous obtenez une erreur lorsque vous utilisez un nom unset directement.

Les variables globales sont intéressantes parce qu'elles sont accessibles soit à l'aide d'un simple nom de variable, ou en utilisant les propriétés de l'objet global window:

alert(window.sam);      // undefined
alert(window['sam']);   // undefined
alert('sam' in window); // false
alert(sam);             // ERROR

Si sam est déclarée mais non initialisées, l'accès window.sam vous obtient toujours undefined, mais pour une autre raison: il y a une entrée dans l'objet window pour sam, mais il pointe vers le même objet undefined que vous obtenez lorsque vous accédez à un propriété non existant.

var sam;
alert(window.sam);      // undefined
alert(window['sam']);   // undefined
alert('sam' in window); // ** true
alert(sam);             // ** undefined

Ceci est bien sûr un désordre sanglant confus; undefined est l'une des pires erreurs dans la conception du langage JavaScript.

null d'autre part est très bien et travaille à peu près la même chose que nul / nul / vide / valeurs Aucun dans d'autres langues. Il ne vient pas dans l'une de ce qui précède.

Answer 2

<script type="text/javascript">
// variable with an unasigned value
var a;
if (a == undefined) {
  alert('a is undefined');
}

if (a == null) {
  alert('a is undefined');
}

// this will produce an error
if (b == undefined) {
  alert('b is undefined');
}

// this is the right way to handle not defined variables
if (typeof(c) == 'undefined') {
  alert('c is blabla');
}
</script>

Answer 3

Pour une variable pour recevoir une valeur nulle doit être affectée. null est utilisé pour indiquer un inconnu ou ne se soucient pas valeur. undefined d'autre part est conçu pour indiquer que le propery en cours d'accès n'a jamais ben attribué une valeur. Cela diffère de null.

Avec un null est délibérément en disant: « Je ne sais pas quelle valeur cela devrait avoir encore » ou « Je ne se soucient pas quelle valeur cela est en ce moment ». OTH à undefined est en train de dire « Êtes-vous sûr que vous devriez utiliser cette valeur, il n'a pas été affectée ».

Answer 4

La façon dont je distinguais les est indéfini étant « Je ne l'ai pas défini cette valeur », et nulle étant « Je l'ai défini cette valeur, mais je ne sais pas ou ne peut pas comprendre ce que la valeur devrait être. »