Lernen Sie von mir die undefinierten und null_javascript-Fähigkeiten von Javascript

Wenn es um primitive Datentypen in JavaScript geht, kennen die meisten Leute die Grundlagen von String über Zahl bis Boolean. Diese primitiven Typen sind ziemlich einfach und verhalten sich wie der gesunde Menschenverstand. Dieser Artikel konzentriert sich jedoch mehr auf die einzigartigen primitiven Datentypen Null und Undefiniert und darauf, was sie so ähnlich und dennoch paradox macht.

1. Null und undefiniert verstehen

In JavaScript ist null ein Literal und ein Schlüsselwort in der Sprache, das zur Darstellung nicht erkannter Objektwerte verwendet wird. Mit anderen Worten bedeutet dies „kein Wert“, aber Sie können entscheiden, wann Sie den erwarteten Wert erhalten möchten.

Obwohl es ähnlich ist, stellt undefiniert tatsächlich die Nichtexistenz eines Werts dar, was bedeutet, dass Ihnen etwas fehlt. Beide sind völlig unveränderlich, haben keine Eigenschaften und Methoden und ihren Eigenschaften können keine Werte zugewiesen werden. Tatsächlich wird ein TypeError ausgelöst, wenn Sie versuchen, auf eine Eigenschaft zuzugreifen oder diese zu definieren, die null oder undefiniert ist.

Boolesche Werte, die durch keinen Wert dargestellt werden, sind falsch, was bedeutet, dass sie in einem bedingten Kontext, wie etwa einer if-Anweisung, als falsch ausgewertet werden. Verwenden Sie den Gleichheitsoperator (==), um diese beiden Werte mit anderen falschen Werten zu vergleichen. Sie sind außer sich selbst nicht gleich:

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

Allerdings und andere Ähnlichkeiten sind null und undefiniert nicht gleichwertig. Jedes ist ein eindeutiges Mitglied seines eigenen Typs, undefiniert ist vom Typ Undefiniert und null ist vom Typ Objekt. Vergleichen Sie diese beiden Werte mit dem Gleichheitsoperator (===), der erfordert, dass beide Typen und Werte gleich sind, wie unten gezeigt:

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

Die obige Beschreibung: null Dies ist ein Objekt, aber es ist leer. Und null ist ein für JavaScript reserviertes Schlüsselwort.
Wenn Null außerdem an numerischen Operationen teilnimmt, wird sein Wert automatisch in 0 konvertiert. Daher erhält der folgende Ausdruck nach der Berechnung den korrekten Wert:

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

undefiniert ist eine spezielle Eigenschaft des globalen Objekts (Fensters) und sein Wert ist undefiniert. Aber typeof undefiniert gibt „undefiniert“ zurück.
Obwohl undefiniert eine besondere Bedeutung hat, ist es tatsächlich eine Eigenschaft und eine Eigenschaft des globalen Objekts (Fensters). Bitte schauen Sie sich den folgenden Code an:

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

Daraus ist ersichtlich, dass undefiniert eine Eigenschaft des Fensterobjekts ist, jedoch keine Eigenschaft des anObj-Objekts.
Hinweis:

• Obwohl undefiniert ein Attribut mit besonderer Bedeutung ist, ist es kein reserviertes Schlüsselwort in JavaScript. Wenn undefiniert an einer numerischen Berechnung teilnimmt, muss das Ergebnis NaN sein. NaN ist übrigens eine weitere besondere Eigenschaft des globalen Objekts (Fensters), ebenso wie Infinity. Keines dieser speziellen Attribute sind für JavaScript reservierte Schlüsselwörter!
• Wenn Sie überprüfen, ob ein Wert oder Objekt null ist, müssen Sie „===" verwenden, um festzustellen, ob es null oder undefiniert ist. Wenn Sie nur „==" verwenden, können Sie nicht feststellen, ob es null oder undefiniert ist.

2. Es tritt eine undefinierte Situation ein
Es gibt viele Möglichkeiten, Code mit einem undefinierten Wert zu generieren. Dies tritt normalerweise auf, wenn versucht wird, auf einen Wert zuzugreifen, der nicht vorhanden ist. In diesem Fall wird in einer dynamischen und schwach typisierten Sprache wie JavaScript standardmäßig ein undefinierter Wert zurückgegeben, anstatt einen Fehler auszulösen.

1. Jede ohne Anfangswert deklarierte Variable hat den Standardwert undefiniert:

var foo; // 默认值为 undefined 

2. Beim Versuch, auf eine nicht vorhandene Objekteigenschaft oder ein Array-Element zuzugreifen, wird ein undefinierter Wert zurückgegeben:

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

3. Wenn die Return-Anweisung der Funktion weggelassen wird oder die Return-Anweisung keine Parameter annimmt und undefiniert zurückgibt:

var value = (function(){

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

4. Beim Aufruf der Funktion wird der Parameter, der bereitgestellt werden soll, nicht angegeben und der Parameter ist gleich undefiniert

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

Undefiniert schließlich ist eine vordefinierte globale Variable (im Gegensatz zum Schlüsselwort null), die auf den undefinierten Wert initialisiert wird:

'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变量的原因！

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