Quand est-ce que null ou undefined est utilisé en JavaScript?
Je suis vraiment confus quant à quand JavaScript retourne null ou undefined. De plus, différents navigateurs semblent les retourner différemment.
Pourriez-vous s'il vous plaît donner quelques exemples de null/undefined avec les navigateurs qui les renvoient.
Alors que je suis maintenant clair sur l'aspect undefined, je ne suis toujours pas clair à 100% sur null. Est-ce similaire à une valeur vide?
Par exemple. Vous avez une zone de texte qui n'a aucune valeur définie. Maintenant, lorsque vous essayez d'accéder à sa valeur, sera-t-il null ou undefined et sont-ils similaires?
Les méthodes DOM getElementById(), nextSibling(), childNodes[n], parentNode() et ainsi de suite renvoient null (défini mais sans valeur) lorsque l'appel ne renvoie pas d'objet de noeud.
La propriété est définie, mais l'objet auquel elle fait référence n'existe pas.
C’est l’une des rares fois où vous pouvez ne pas vouloir tester l’égalité-
if(x!==undefined) sera vraie pour une valeur nulle
mais if(x!= undefined) sera vrai (uniquement) pour les valeurs qui ne sont ni undefined ni null.
Je trouve que certaines de ces réponses sont vagues et compliquées. Je pense que le meilleur moyen de comprendre ces choses est de simplement ouvrir la console et de la tester vous-même.
var x;
x == null // true
x == undefined // true
x === null // false
x === undefined // true
var y = null;
y == null // true
y == undefined // true
y === null // true
y === undefined // false
typeof x // 'undefined'
typeof y // 'object'
var z = {abc: null};
z.abc == null // true
z.abc == undefined // true
z.abc === null // true
z.abc === undefined // false
z.xyz == null // true
z.xyz == undefined // true
z.xyz === null // false
z.xyz === undefined // true
null = 1; // throws error: invalid left hand assignment
undefined = 1; // works fine: this can cause some problems
C'est donc certainement l'une des nuances les plus subtiles de JavaScript. Comme vous pouvez le constater, vous pouvez remplacer la valeur de undefined, ce qui la rend peu fiable par rapport à null. En utilisant le == _ opérateur, vous pouvez utiliser _ de manière fiable null et undefined de façon interchangeable pour autant que je sache. Cependant, étant donné que null ne peut pas être redéfini, je pourrais l’utiliser lorsqu’on utilise ==.
Par exemple, variable != null retournera TOUJOURS faux si variable est égal à null ou undefined alors que variable != undefined retournera false si variable est égal à null ou undefined UNLESS undefined est préalablement réaffecté.
Vous pouvez utiliser le === opérateur pour différencier undefined et null, si vous devez vous assurer qu'une valeur est bien undefined (plutôt que null).
Selon la spécification ECMAScript 5:
- Les deux
NulletUndefinedsont deux des six types intégrés.
4.3.9 valeur non définie
valeur primitive utilisée lorsqu'une valeur n'a pas été affectée à une variable
4.3.11 valeur nulle
valeur primitive qui représente l'absence intentionnelle de toute valeur d'objet
Vous obtenez indéfini pour les différents scénarios:
Vous déclarez une variable avec var mais ne la définissez jamais.
var foo;
alert(foo); //undefined.
Vous tentez d'accéder à une propriété sur un objet que vous n'avez jamais défini.
var foo = {};
alert(foo.bar); //undefined
Vous essayez d'accéder à un argument qui n'a jamais été fourni.
function myFunction (foo) {
alert(foo); //undefined.
}
Comme le font remarquer les loups dans un commentaire sur une autre réponse, les fonctions qui ne renvoient pas de valeur.
function myFunction () {
}
alert(myFunction());//undefined
Un null doit généralement être défini intentionnellement sur une variable ou une propriété (voir les commentaires d'un cas dans lequel il peut apparaître sans avoir été défini). De plus, un null est de type object et undefined est de type undefined.
Je devrais également noter que null est valide en JSON mais non défini n'est pas:
JSON.parse(undefined); //syntax error
JSON.parse(null); //null
Il se peut que je manque quelque chose, mais autant que je sache, vous obtenez undefined seulement
Mise à jour: Ok, j'ai beaucoup manqué, en essayant de terminer:
Vous obtenez undefined...
... lorsque vous essayez d'accéder aux propriétés d'un objet qui n'existent pas:
var a = {}
a.foo // undefined
... quand vous avez déclaré une variable mais que vous ne l'avez pas initialisée:
var a;
// a is undefined
... lorsque vous accédez à un paramètre pour lequel aucune valeur n'a été transmise:
function foo (a, b) {
// something
}
foo(42); // b inside foo is undefined
... lorsqu'une fonction ne renvoie pas de valeur:
function foo() {};
var a = foo(); // a is undefined
Il se peut que certaines fonctions intégrées renvoient null après une erreur, mais si c'est le cas, cela est documenté. null est une valeur concrète en JavaScript, undefined ne l'est pas.
Normalement, vous n'avez pas besoin de faire la distinction entre ceux-ci. En fonction des valeurs possibles d'une variable, il suffit d'utiliser if(variable) pour tester si une valeur est définie ou non (null et undefined évaluer à false).
De plus, différents navigateurs semblent les retourner différemment.
S'il vous plaît donner un exemple concret.
En ce qui concerne ce sujet, la spécification (ecma-262) est assez claire
Je l’ai trouvé très utile et simple, de sorte que je le partage: - Ici vous trouverez algorithme d’égalité - Ici vous trouverez algorithme d’égalité stricte
Je suis tombé dessus en lisant "égalité abstraite, égalité stricte et même valeur" sur le site de développeur de mozilla, section identique.
J'espère que tu trouves cela utile.
Une propriété, quand elle n'a pas de définition, est indéfinie. null est un objet. Son type est nul. undefined n'est pas un objet, son type est indéfini.
Ceci est un bon article expliquant la différence et donnant également quelques exemples.