Quand JavaScript utilise-t-il nul ou non défini? [dupliquer]

je trouve que certaines de ces réponses sont vagues et compliqué, je trouve que la meilleure façon de comprendre ces choses est sûr, c'est qu'à ouvrir la console et de 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

donc c'est certainement l'une des nuances les plus subtiles de JavaScript. Comme vous pouvez le voir, vous pouvez outrepasser la valeur de undefined , ce qui le rend peu fiable par rapport à null . En utilisant l'opérateur == , vous pouvez utiliser de manière fiable null et undefined de façon interchangeable. Cependant, en raison de l'avantage que null ne peut pas être redéfini, je pourrais l'utiliser en utilisant == .

par exemple, variable != null retournera toujours false si variable est égal à null ou undefined , tandis que variable != undefined retournera false si variable est égal à null ou undefined à moins que undefined ne soit réassigné au préalable.

vous pouvez utiliser de manière fiable l'opérateur === pour différencier entre undefined et null , si vous avez besoin de s'assurer qu'une valeur est réellement undefined (plutôt que null ).

selon L'ECMAScript 5 spec:

• les deux Null et Undefined sont deux des six types de construction.

4.3.9 valeur non définie

primitive valeur utilisée lorsqu'une variable n'a pas été affecté une valeur

4.3.11 valeur nulle

valeur primitive qui représente l'absence intentionnelle de toute valeur d'objet

vous obtenez non dé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é d'un objet que vous n'avez jamais ensemble.

var foo = {};
alert(foo.bar); //undefined

vous tentez d'accéder à un argument qui n'a jamais été fourni.

function myFunction (foo) {
  alert(foo); //undefined.
}

comme cwolves l'a souligné dans un commentaire sur une autre réponse, les fonctions qui ne renvoient pas de valeur.

function myFunction () {
}
alert(myFunction());//undefined

null généralement être intentionnellement sur une variable ou une propriété (voir les commentaires pour une affaire dans laquelle il peut apparaître, sans avoir été définie). En outre, un nul est de type object et non défini est de type undefined .

je dois aussi noter que null est valide dans 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 afaik, vous obtenez undefined seulement

mise à jour: Ok, j'ai manqué beaucoup, en essayant de compléter:

vous avez undefined ...

... lorsque vous essayez d'accéder aux propriétés d'un objet qui n'existe pas:

var a = {}
a.foo // undefined

... lorsque 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é adoptée:

function foo (a, b) {
    // something
}

foo(42); // b inside foo is undefined

... lorsqu'une fonction ne renvoie pas une valeur:

function foo() {};
var a = foo(); // a is undefined

il se peut que certaines fonctions intégrées renvoient null sur une erreur, mais si oui, alors il est documenté. null est une valeur concrète en JavaScript, undefined ne l'est pas.

Normalement, vous n'avez pas besoin de distinguer entre ceux-ci. Selon les valeurs possibles d'une variable, il suffit d'utiliser if(variable) pour tester si une valeur est définie ou non (à la fois null et undefined évaluer false ).

aussi différents navigateurs semblent renvoyer ces différents.

Veuillez donner un exemple concret.

en ce qui concerne ce sujet, la spécification (ecma-262) est très claire

Je l'ai trouvé vraiment utile et simple, de sorte que je 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" de mozilla developer site, section sameness.

j'espère vous le trouverez utile.

une propriété, lorsqu'elle n'a pas de définition, n'est pas définie. la valeur null est un objet. Son type est null. undefined n'est pas un objet, son type est indéfini.

c'est un bon article expliquant la différence et donnant aussi quelques exemples.

nul vs non défini