Apprenez les compétences non définies et null_javascript de javascript avec moi

Lorsqu'on discute des types de données primitifs en JavaScript, la plupart des gens connaissent les bases, de la chaîne au nombre en passant par le 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 nul 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 », mais vous pouvez décider quand obtenir la valeur attendue.

Bien que similaire, undefined représente en fait la non-existence d'une valeur, ce qui signifie qu'il vous manque quelque chose. Les deux sont complètement immuables, n’ont ni propriétés ni méthodes, et leurs propriétés ne peuvent pas se voir attribuer de valeurs. En fait, une TypeError sera déclenchée lorsque vous tenterez d'accéder ou de définir une propriété nulle ou non définie.

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 de type Undéfini et null est de type Objet. 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 :

null === undefined; //false
typeof null; //"object"
typeof undefined; //"undefined"

La description ci-dessus : null Ceci est un objet, mais il est vide. Et null est un mot-clé réservé JavaScript.
De plus, lorsque null participe à des opérations numériques, sa valeur sera automatiquement convertie en 0. Par conséquent, l'expression suivante obtiendra la valeur correcte après calcul :

123 + null;　　　//123 
123 * null;　　　//0 

undefined est une propriété spéciale de l'objet global (fenêtre), et sa valeur est indéfinie. Mais typeof undefined renvoie 'undefined' .
Bien qu'indéfini ait une signification particulière, il s'agit bien d'une propriété, et c'est une propriété de l'objet global (fenêtre). Veuillez regarder le code ci-dessous :

alert('undefined' in window);//输出：true 
var anObj = {}; 
alert('undefined' in anObj); //输出：false 

On peut voir à partir de cela qu'undefined est une propriété de l'objet window, mais ce n'est pas une propriété de l'objet anObj.
Remarque :

• Bien qu'indéfini soit un attribut ayant une signification particulière, ce n'est pas un mot-clé réservé en JavaScript. Lorsqu'undéfini participe à un calcul numérique, le résultat doit être NaN. Soit dit en passant, NaN est une autre propriété spéciale de l'objet global (fenêtre), tout comme Infinity. Aucun de ces attributs spéciaux n'est un mot-clé réservé à JavaScript !
• Lors de la vérification qu'une valeur ou un objet est nul, vous devez utiliser "===" pour déterminer. Si vous utilisez uniquement "==", vous ne pouvez pas déterminer s'il est nul ou indéfini.

2. Une situation non définie se produit
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.

1. Toute variable déclarée sans valeur initiale aura une valeur par défaut de non définie :

var foo; // 默认值为 undefined 

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

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

3. Si l'instruction return de la fonction est omise, ou si l'instruction return ne prend aucun paramètre et renvoie undéfini :

var value = (function(){

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

4. Lors de l'appel de la fonction, le paramètre qui doit être fourni n'est pas fourni et le paramètre est égal à undefined

function f(x){
  console.log(x)
}
f(); // undefined

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 

ECMAScript 5中，这个变量是只读的，以前并非如此。

三、null的用例

null的用例是使他与众不同的主要方面，因为不像undefined，null被认为是更有用。这正是为什么typeof操作符作用于null值 时返回“object”。最初的理由是，现在仍然是，通常用作一个空引用一个空对象的预期,就像一个占位符。typeof的这种行为已经被确认为一个错 误，虽然提出了修正，出于后兼容的目的，这一点已经保持不变。

一般来说,如果你需要给一个变量或属性指定一个不变值，将它传递给一个函数，或者从一个函数返回null，null几乎总是最好的选择。简而言之，JavaScript使用undefined并且程序员应该使用null。

null的另一个可行的用例，也被认为是良好的实践是一个显式指定变量为无效(object= null)当一个引用不再是必需的。通过分配null值，有效地清除引用，并假设对象没有引用其他代码，指定垃圾收集，确保回收内存。

四、提高undefined性能

当我们在程序中使用undefined值时，实际上使用的是window对象的undefined属性。 同样，当我们定义一个变量但未赋予其初始值，例如：

var aValue; 

这时，JavaScript在所谓的预编译时会将其初始值设置为对window.undefined属性的引用， 于是，当我们将一个变量或值与undefined比较时，实际上是与window对象的undefined属性比较。这个比较过程中，JavaScript会搜索window对象名叫‘undefined'的属性，然后再比较两个操作数的引用指针是否相同。

由于window对象的属性值是非常多的，在每一次与undefined的比较中，搜索window对象的undefined属性都会花费时 间。在需要频繁与undefined进行比较的函数中，这可能会是一个性能问题点。因此，在这种情况下，我们可以自行定义一个局部的undefined变 量，来加快对undefined的比较速度。例如：

function anyFunc() { 
  var undefined; 
  //自定义局部undefined变量 
  if(x == undefined) 
  //作用域上的引用比较 
  while(y != undefined) 
  //作用域上的引用比较 
}; 

其中，定义undefined局部变量时，其初始值会是对window.undefined属性值的引用。新定义的局部undefined变 量存在与该函数的作用域上。在随后的比较操作中，JavaScript代码的书写方式没有任何的改变，但比较速度却很快。因为作用域上的变量数量会远远少 于window对象的属性，搜索变量的速度会极大提高。

这就是许多前端JS框架为什么常常要自己定义一个局部undefined变量的原因！

以上就是本文的全部内容，希望对大家的学习有所帮助。