Les mots précédents
Dans les langages de programmation généraux, seuls Null signifie vide, mais le concepteur JavaScript Brendan Eich a conçu un indéfini, ce qui augmente sans aucun doute la complexité du programme, mais il y a une certaine raison de le faire. Cet article introduira en détail les indéfinis et nuls en JavaScript
Raisons historiques
Lorsque JavaScript est né en 1995, il a été initialement défini comme Java, seul Null a été défini comme une valeur indiquant "aucun". Selon la tradition du langage C, Null est conçu pour se tourner automatiquement vers 0
Cependant, le concepteur de JavaScript Brendan Eich pense que cela ne suffit pas, pour deux raisons. Tout d'abord, Null est traité comme un objet comme dans Java. Cependant, les valeurs JavaScript sont divisées en deux catégories: types primitifs et types d'objets. Brendan Eich pense que la valeur qui signifie «aucune» n'est mieux pas un objet. Deuxièmement, la version initiale de JavaScript n'incluait pas de mécanisme de gestion des erreurs. Lorsque l'inadéquation du type de données se produit, elle convertit souvent automatiquement le type ou échoue silencieusement. Brendan Eich pense que si Null se transforme automatiquement vers 0, il est difficile de trouver des erreurs
Par conséquent, Brendan Eich a conçu un autre indéfini. Il le distingue comme ceci: Null est un objet qui représente "aucun", qui est 0 lorsqu'il est converti en une valeur numérique; Undefined est une valeur d'origine qui représente "aucun", qui est nan lorsqu'elle est convertie en une valeur numérique
Cependant, actuellement nul et non défini sont essentiellement synonymes, les deux sont des types primitifs et il n'y a que de légères différences.
indéfini
Le type non défini n'a qu'une seule valeur, qui n'est pas définie. Lorsque la variable déclarée n'est pas initialisée, la valeur par défaut de la variable n'est pas définie. Donc, généralement, non défini signifie que la variable n'est pas initialisée
Var Test; // UndefinedConsole.log (test == Undefined); // TrueVar Test = Undefined; // Undefined
Pour les variables qui n'ont pas été déclarées, une seule opération peut être effectuée, en utilisant le type d'opérateur pour détecter leurs types de données, mais cela entraînera une erreur en mode strict
typeof (test); // non défini
【Apparence de scène】
【1】 Variables non alimentées déclarées
【2】 Obtenez les attributs qui n'existent pas dans l'objet
【3】 Résultat d'exécution de la fonction sans valeur de retour
【4】 Les paramètres de fonction ne sont pas passés dans
【5】 vide (expression)
var i; console.log (i); // undefinedvar o = {}; console.log (op); // undefinedFunction f () {}; console.log (f ()); // non défini f (x) {return x;} console.log (f ()); // undefinedConsole.log (Void (0));【Type Conversion】
Booléen (indéfini): falSenumber (non défini): nanstring (non défini): «non défini»
nul
Il n'y a qu'une seule valeur pour le type nul, qui est nul. Null est un mot-clé dans la langue javascript. Il représente une valeur spéciale et est souvent utilisé pour décrire la "valeur nulle".
Logiquement, la valeur nulle représente un pointeur d'objet vide
[Remarque] Null est un pointeur d'objet vide, tandis que [] est un tableau vide, {} est un objet vide, les trois sont différents
console.log (typeof null); // 'objet'
Bien que NULL et UNDEFINED soient différents, ils représentent tous deux "vide de valeur", NULL représente "Null Value", et Undefined représente "Undefined". Les deux sont souvent interchangeables. Opérateur d'égalité du juge == Pensez que les deux sont égaux
Console.log (null == Undefined); // Vrai
En fait, comme les non définis et les nuls ne sont pas des types de constructeurs, ils n'ont pas de propriétés et de méthodes. En utilisant . et [] pour accéder aux membres ou aux méthodes des deux valeurs produiront une erreur de type.
【Type Conversion】
Booléen (null): falSenumber (null): 0string (null): 'null'
Ci-dessous, je présenterai la différence entre null et indéfini dans JavaScript
Undefined représente la valeur lorsque la variable est déclarée mais non initialisée, et NULL représente la valeur prête à être utilisée pour enregistrer l'objet, mais n'a pas vraiment enregistré l'objet. D'un point de vue logique, la valeur nul représente un pointeur d'objet vide.
Il existe 5 types de base dans JavaScript (ECMascript Standard): Undefined, Null, Boolean, Number, String et un objet de type complexe. On peut voir que null et non défini appartiennent à différents types. La valeur non initialisée est détectée par typeof comme "non définie" (chaîne), tandis que la valeur nul est détectée par typeof comme "objet" (chaîne).
Il n'est pas recommandé de définir explicitement une variable à tout moment, mais si la variable qui enregistre l'objet n'a pas vraiment enregistré l'objet, il doit être défini sur NULL.
En fait, la valeur non définie est dérivée d'une valeur nulle. La norme ECMAScript stipule que le test d'égalité des deux doit être renvoyé vrai, c'est-à-dire,
alerte (null == non défini); // vrai