Explication détaillée des types de données primitifs Null et Undefined dans les techniques JavaScript_javascript

Lorsqu'on discute des types de données primitifs en JavaScript, la plupart des gens connaissent les bases, de la chaîne, du nombre au booléen. Ces types primitifs sont assez simples et se comportent comme du bon sens. Cependant, cet article se concentrera davantage sur les types de données primitifs uniques Null et Undefined, et sur ce qui les rend si similaires et pourtant paradoxaux.

1. Comprendre Null et Indéfini
En JavaScript, null est un littéral et un mot-clé dans le langage, utilisé pour représenter des valeurs d'objet non reconnues. En d’autres termes, cela signifie « aucune valeur ». Bien que similaire, undefined représente en réalité la non-existence d’une valeur. Ils sont complètement immuables, n'ont ni propriétés ni méthodes et ne peuvent pas attribuer de valeurs à leurs propriétés. En fait, essayer d’accéder ou de définir une propriété déclenchera une TypeError. Comme leur nom l’indique, ce sont des valeurs totalement invalides.

Les valeurs booléennes représentées par aucune valeur sont fausses, ce qui signifie qu'elles seront évaluées comme fausses dans un contexte conditionnel, tel qu'une instruction if. Utilisez l'opérateur d'égalité (==) pour comparer ces deux valeurs avec d'autres fausses valeurs, elles ne sont égales qu'elles-mêmes :

null == 0; // false
undefined == ""; // false
null == false; // false
undefined == false; // false
null == undefined; // true

Cependant, et d'autres similitudes, null et indéfini ne sont pas équivalentes. Chacun est un membre unique de son propre type, undéfini est le type Undéfini et null est le type Null. Comparez ces deux valeurs à l'aide de l'opérateur d'égalité (===), qui nécessite que les types et les valeurs soient égaux, comme indiqué ci-dessous :

undefined === null; // false

Il s’agit d’une distinction importante qui sert différents objectifs et raisons. Pour faire la distinction entre ces deux valeurs, vous pouvez considérer undefined comme représentant une valeur nulle inattendue et null comme représentant une valeur nulle attendue.
2. Générer un défini
Il existe de nombreuses façons de générer du code avec une valeur non définie. Cela se produit généralement lorsque l’on tente d’accéder à une valeur qui n’existe pas. Dans ce cas, dans un langage dynamique et faiblement typé comme JavaScript, une valeur non définie sera renvoyée par défaut au lieu de générer une erreur.
Toute variable déclarée sans valeur initiale aura une valeur par défaut de non définie :

 var foo; // 默认值为 undefined

Lorsque vous essayez d'accéder à une propriété d'objet ou à un élément de tableau inexistant, renvoyez une valeur non définie :

var array = [1, 2, 3];
var foo = array.foo; // foo 属性不存在, 返回 undefined
var item = array[5]; // 数组中没有索引为5的项，返回 undefined

Si l'instruction return de la fonction est omise, undefined est renvoyé :

var value = (function(){})(); // 返回 undefined

Les valeurs non fournies lors de l'appel de la fonction entraîneront des valeurs de paramètres non définies :

(function(undefined){
  // 参数是 undefined
})();

L'opérateur void peut également renvoyer une valeur non définie. Les bibliothèques comme Underscore l'utilisent comme vérification de type défensive car elle est immuable et on peut s'y fier dans n'importe quel contexte pour renvoyer undefined :

function isUndefined(obj){
  return obj === void 0;
}

Enfin, undéfini est une variable globale prédéfinie (contrairement au mot-clé null) initialisée à la valeur undéfini :

'undefined' in window; // true

Dans ECMAScript 5, cette variable est en lecture seule, ce qui n'était pas le cas auparavant.

3. Cas d'utilisation de Null
Le cas d'utilisation de null est le principal aspect qui le différencie, car contrairement à undefined, null est considéré comme plus utile. C'est pourquoi l'opérateur typeof renvoie « objet » lorsqu'il est appliqué à une valeur nulle. La justification initiale était, et est toujours, qu'une référence nulle est généralement utilisée comme un objet nul est attendu, tout comme un espace réservé. Ce comportement de typeof a été confirmé comme un bug, et bien qu'un correctif ait été proposé, celui-ci est resté inchangé à des fins de compatibilité ascendante.
C'est pourquoi l'environnement JavaScript ne définit jamais une valeur sur null ; cela doit être fait par programme. Comme le dit la documentation MDN :
Dans l'API, null est souvent attendu là où les objets sont récupérés, mais il n'y a aucun objet associé.
Cela s'applique au DOM, qui est indépendant du langage et hors du champ d'application de la spécification ECMAScript. Puisqu'il s'agit d'une API externe, essayer d'obtenir un élément qui n'existe pas renvoie une valeur nulle, non indéfinie.
De manière générale, si vous devez attribuer une valeur immuable à une variable ou une propriété, la transmettre à une fonction ou renvoyer null à partir d'une fonction, null est presque toujours le meilleur choix. En bref, JavaScript utilise undefined et les programmeurs devraient utiliser null.
Un autre cas d'utilisation possible de null, qui est également considéré comme une bonne pratique, consiste à désigner explicitement une variable comme invalide (object= null) lorsqu'une référence n'est plus requise. En attribuant une valeur nulle, la référence est effectivement effacée et, en supposant que l'objet n'est pas référencé par un autre code, un garbage collection est spécifié pour garantir que la mémoire est récupérée.
4. Creusez plus profondément
Ce qui rend les trous noirs nuls et indéfinis n'est pas seulement leur comportement, mais la façon dont ils sont gérés en interne dans l'environnement JavaScript. Ils ne semblent souvent pas avoir les mêmes caractéristiques associées que d'autres objets natifs ou intégrés.
Dans ES5, la méthode Object.prototype.toString est devenue la norme de vérification de type de facto, qui s'est avérée cohérente avec null et undefined :

Object.prototype.toString.call(null); // [object Null]
Object.prototype.toString.call(undefined); // [object Undefined]

Cependant, la méthode Object.prototype.toString ne récupère pas réellement la propriété interne [[Class]] de null ou le constructeur public de undefined. Selon la documentation, les étapes suivantes se produisent dans le processus appelé :

Si la valeur n'est pas définie, renvoyez "[objet non défini]".

• Si cette valeur est nulle, renvoyez "[object Null]".
• Soit O la valeur résultante de l'appel de ToObject en passant cette valeur en paramètre.
• Soit class la valeur de la propriété interne de O [[Class]].
• Le résultat renvoyé est la valeur de chaîne du résultat de la concaténation des trois chaînes "[objet", classe et "]".
  

Cette méthode effectue une valeur de retour de chaîne simple si elle détecte des fonctions nulles ou indéfinies et d'autres fonctions uniformes d'objet. Ceci est courant dans toute la spécification, car la plupart des méthodes contiennent un simple catch et return lorsque des valeurs nulles et indéfinies sont rencontrées. En fait, rien n’indique qu’ils contiennent des propriétés internes associées à des objets natifs. C’est comme si ce n’étaient pas des objets. Je suis curieux de savoir ce qui se passerait si une solution explicite existait réellement dans l'environnement natif de JavaScript ? Peut-être que quelqu'un de plus familier avec une implémentation pourrait s'impliquer.

Conclusion
Aussi inhabituels que puissent être ces objets natifs, comprenez la différence entre null et non défini, ainsi que leurs rôles distincts dans les fondements du langage JavaScript. Cela ne fera peut-être pas décoller votre application, mais en général cela ne s'avérera bénéfique qu'à long terme lors du développement et du débogage.

Ce qui précède est une introduction aux types de données primitifs Null et Undefined en JavaScript. J'espère que cela sera utile à l'apprentissage de chacun.