Pourquoi y a-t-il une valeur `null` en JavaScript?

Question

En JavaScript, il y a deux valeurs qui disent en substance: "je ne suis pas exister' - undefined et null.

Une propriété à laquelle un programmeur n'a pas reçu de quoi que ce soit sera undefined, mais pour une propriété afin de devenir l' null, null doit être explicitement attribuée.

Une fois, j'ai pensé qu'il y avait un besoin pour null car undefined est une valeur primitive et null un objet. Ce n'est pas, même si typeof null rendement 'object': en Fait, les deux sont des valeurs primitives, ce qui signifie ni undefined ni null peut être retourné par une fonction constructeur, car les deux seront convertis en un objet vide (on s'lève une erreur à proclamer l'échec dans les constructeurs).

Elles ont aussi évaluer d' false booléennes contextes. La seule vraie différence, je pense, que l'on évalue à NaN, l'autre pour 0 dans des contextes numériques.

Alors, pourquoi est-il à la fois undefined et null si cette confond tout simplement programmeurs qui sont mal vérifiant null lorsque vous essayez de trouver si une propriété a été définie ou pas?

edit: Ce que je voudrais savoir c'est si quelqu'un a une raisonnable exemple où il est nécessaire d'utiliser null qui ne pouvaient pas être exprimées à l'aide d' undefined à la place.

edit2+3: de Sorte que le consensus général semble être que undefined signifie "il n'y a pas de telle propriété" tandis qu' null "la propriété n'existe pas, mais n'a aucune valeur'.

Je pourrais vivre avec ça si les implémentations JavaScript serait que l'application effective de ce comportement - mais undefined est parfaitement valide de valeur primitive, de sorte qu'il peut facilement être attribuée aux propriétés existantes pour rompre ce contrat. Par conséquent, si vous voulez vous assurer que si une propriété existe, vous devez utiliser l' in de l'opérateur ou de l' hasOwnProperty() de toute façon. Donc encore une fois: quelle est l'utilisation pratique pour séparer les valeurs de undefined et null?

J'utilise en fait undefined quand je veux annuler les valeurs de propriétés n'est plus en usage, mais que je ne veux pas d' delete. Dois-je utiliser null à la place?

Answer 1

La question n'est pas vraiment "pourquoi il y a une valeur null dans JS" - il existe une valeur nulle, de la sorte, dans la plupart des langues, et il est généralement considéré comme très utile.

La question est de savoir "pourquoi il y a un pas défini la valeur en JS". Principaux lieux où il est utilisé:

1. lorsque vous déclarez 'var x;' mais ne pas lui attribuer, x détient pas défini;
2. lorsque votre fonction est de moins en moins d'arguments qu'il le déclare;
3. lorsque vous accédez à un objet inexistant propriété.

'null' aurait certainement travaillé aussi bien pour les (1) et (2)*. (3) devraient vraiment jeter une exception tout de suite, et le fait qu'il n'a pas, au lieu de retourner ce bizarre 'undefined' qui ne manquera pas de plus tard, est une grande source de débogage de la difficulté.

*: on pourrait aussi soutenir que (2) doit lever une exception, mais vous devrez alors fournir un meilleur, plus de mécanisme explicite de défaut/variable d'arguments.

Cependant JavaScript n'est pas à l'origine des exceptions, ou de toute façon de demander à un objet, si elle avait un membre en vertu d'un certain nom - la seule façon d'été (et sont encore parfois), pour accéder à la partie et voir ce que vous obtenez. Étant donné que la valeur 'null' avait déjà un but et que vous souhaiterez peut-être définir un membre, un autre out-of-band valeur a été nécessaire. Nous avons donc 'undefined', c'est problématique, comme vous le soulignez, et c'est une autre grande JavaScript 'fonctionnalité' nous ne serons jamais en mesure de se débarrasser de.

J'utilise en fait pas défini quand je veux annuler les valeurs de propriétés n'est plus en usage, mais dont je ne veux pas supprimer. Dois-je utiliser la valeur null à la place?

Oui. Garder 'undefined' comme une valeur spéciale pour la signalisation lorsque d'autres langues peut lever une exception à la place.

'null', est généralement préférable, sauf sur IE DOM interfaces où la définition de quelque chose de 'null', peut vous donner une erreur. Souvent, dans ce cas, le réglage de la chaîne vide a tendance à fonctionner.

Answer 2

Mieux décrit ici , mais en résumé:

indéfini est l’absence de type et de valeur et null est l’absence de valeur.

De plus, si vous faites des comparaisons simples ==, vous avez raison, elles sont identiques. Mais essayez ===, qui compare à la fois le type et la valeur, et vous remarquerez la différence.

Answer 3

Je ne pense pas qu'il n'y a aucune raison d'avoir à la fois null et undefined, parce que la seule raison pour laquelle beaucoup de gens ont suggéré ("undefined signifie qu'il y a pas de variable et de la propriété") n'est pas valide, au moins en JavaScript. undefined ne peux pas vous dire si la variable/propriété existe ou pas.

console.log(foo);               // "ReferenceError: foo is not defined"
                                // foo does not exist
var foo;
console.log(foo);               // "undefined", a different response
console.log(foo === undefined); // "true", but it does exist

var obj = {};
console.log(obj.hasOwnProperty("foo")); // "false", no such property
obj.foo = undefined;
console.log(obj.hasOwnProperty("foo")); // "true", it exists and has the value "undefined"
console.log(obj.foo === undefined);     // "true", but it does exist

obj.bar = "delete me";
obj.bar = undefined;
console.log(obj.hasOwnProperty("bar")); // "true", not actually deleted
delete obj.bar;
console.log(obj.hasOwnProperty("bar")); // "false", deleted

Comme vous pouvez le voir, en vérifiant foo === undefined ne pas vous dire si foo existe, et le paramètre obj.bar = undefined n'efface bar.

Il est peut-être le JavaScript de l'auteur original de l'intention qu' undefined devrait représenter la "non-existence". Cependant, la mise en œuvre n'est pas de cette façon.

Answer 4

Il est tout à fait possible d'avoir besoin des deux. Par exemple, si vous interrogez WMI, il est tout à fait possible qu'une classe renvoie des propriétés qui ont une valeur null. Ils sont définis, ils arrivent juste à être nuls à l’époque.

Answer 5

Je pense que votre conclusion est que javascript définit pas défini comme "il n'est aucun de propriété et la valeur null comme" la propriété n'a pas de valeur " est parfaitement correct. Et dans une langue que dynamique de javascript, il est une distinction très importante. L'utilisation de duck-typing signifie que nous avons besoin d'être capable de différencier entre une propriété n'existe pas et n'ayant pas de valeur. C'est notre principal moyen de calculer les informations de type. dans un langage statiquement typé il y a une nette distinction entre un champ nul et un champ existant. En javascript ce n'est pas différent. Toutefois, il est vérifié au moment de l'exécution, et peut être modifié jusqu'à ce temps.

Im va être d'accord que la mise en œuvre est étrange que beaucoup de temps, la distinction est floue. Cependant, je pense qu'en javascript, la distinction est importante. Et d'être en mesure d'affecter undefined est essentiel.

Je me souviens avoir lu un post de blog il y a un moment sur un RPG en ligne écrit en Javascript. Il a utilisé des exemples où les objets ont été créés comme des copies des instances existantes plutôt que de prototypes (classes, fonctions, peu importe), et ont été ensuite modifié. Cela m'a vraiment fait comprendre comment puissant indéfini, peut-être lors de la modification d'un objet existant, mais je ne me souviens plus qui l'a écrit.