JavaScript untersucht das Vorparsen von Variablen und Nebenwirkungen

Nebenwirkungen von var

Es gibt einen kleinen Unterschied zwischen impliziten globalen Variablen und explizit definierten globalen Variablen, nämlich die Möglichkeit, Variablen durch den Löschoperator undefiniert zu lassen.

Globale Variablen, die über var erstellt wurden (in einem anderen Programm als Funktionen erstellt wurden), können nicht gelöscht werden.

Implizite globale Variablen, die ohne var erstellt wurden (unabhängig davon, ob sie in einer Funktion erstellt wurden), können gelöscht werden.

Dies zeigt, dass implizite globale Variablen technisch gesehen keine wirklich globalen Variablen sind, sondern Eigenschaften des globalen Objekts. Eigenschaften können über den Löschoperator gelöscht werden, Variablen jedoch nicht:

// 定义三个全局变量
var global_var = 1;
global_novar = 2;       // 反面教材
(function () {
   global_fromfunc = 3; // 反面教材
}());
 
// 试图删除
delete global_var;      // false
delete global_novar;    // true
delete global_fromfunc; // true
 
// 测试该删除
typeof global_var;      // "number"
typeof global_novar;    // "undefined"
typeof global_fromfunc; // "undefined"

Im strengen ES5-Modus führen nicht deklarierte Variablen (wie die beiden negativen Beispiele im vorherigen Codeausschnitt) zu einem Fehler.

Einzelne Variablenform

Die Verwendung einer einzelnen Variablenanweisung am Anfang einer Funktion ist eine nützlichere Form. Der Vorteil besteht darin, dass:

einen einzigen Ort zum Suchen bietet Funktion. Alle benötigten lokalen Variablen

Verhindert Logikfehler, wenn Variablen vor der Definition verwendet werden

Hilft Ihnen, sich deklarierte globale Variablen zu merken, sodass es weniger globale Variablen gibt //zxx: Hier bin ich etwas verwirrt ...

Weniger Code (Typ, Wert und einzeilige Vervollständigung)

Das einzelne var-Formular sieht folgendermaßen aus:

function func() {
   var a = 1,
       b = 2,
       sum = a + b,
       myobject = {},
       i,
       j;
   // function body...
}

Sie können eine var-Anweisung verwenden um mehrere durch Kommas getrennte Variablen zu deklarieren. Es ist eine gute Idee, Variablen und Werte gleichzeitig auf diese Weise zu initialisieren. Dies verhindert Logikfehler (der Anfangswert aller nicht initialisierten, aber deklarierten Variablen ist undefiniert) und erhöht die Lesbarkeit des Codes. Nachdem Sie den Code gesehen haben, können Sie anhand der initialisierten Werte den allgemeinen Zweck dieser Variablen erkennen, z. B. ob sie als Objekte oder als Ganzzahlen verwendet werden sollen.

Sie können beim Deklarieren auch einige tatsächliche Arbeiten ausführen, z. B. sum = a + b im vorherigen Code. Ein weiteres Beispiel ist, dass Sie bei der Verwendung von DOM-Referenzen (Document Object Model) eine einzelne Variable zum Angeben verwenden können die DOM-Referenz zusammen als lokale Variable, wie im folgenden Code gezeigt:

function updateElement() {
   var el = document.getElementById("result"),
       style = el.style;
   // 使用el和style干点其他什么事...
}

vars variable preparsing

In JavaScript können Sie an einer beliebigen Stelle in der Funktion mehrere var-Anweisungen deklarieren und diese verwenden Funktion, als ob sie oben in einer Funktion deklariert worden wäre, wird als Heben bezeichnet. Logikfehler können auftreten, wenn Sie eine Variable verwenden und sie später in einer Funktion erneut deklarieren. Solange sich Ihre Variable in JavaScript im selben Gültigkeitsbereich (dieselbe Funktion) befindet, gilt sie als deklariert, auch wenn sie vor der var-Deklaration verwendet wird. Schauen Sie sich das folgende Beispiel an:

// 反例
myname = "global"; // 全局变量
function func() {
    alert(myname); // "undefined"
    var myname = "local";
    alert(myname); // "local"
}
func();

In diesem Beispiel denken Sie vielleicht, dass die erste Warnung „global“ und die zweite Warnung „loacl“ angezeigt wird. Diese Erwartung ist verständlich, da myname zum Zeitpunkt der ersten Warnung noch nicht deklariert war. Zu diesem Zeitpunkt muss die Funktion natürlich auf die globale Variable myname achten, aber das ist nicht die tatsächliche Funktionsweise. Die erste Warnung wird als „undefiniert“ angezeigt, da myname als lokale Variable der Funktion behandelt wird (auch wenn sie später deklariert wird) und alle Variablendeklarationen am Anfang der Funktion angehalten werden. Um diese Verwirrung zu vermeiden, ist es daher am besten, alle Variablen, die Sie verwenden möchten, im Voraus zu deklarieren.

Der obige Codeausschnitt könnte sich wie folgt verhalten:

myname = "global"; // global variable
function func() {
   var myname; // 等同于 -> var myname = undefined;
   alert(myname); // "undefined"
   myname = "local";
   alert(myname); // "local"}
func();

Der Vollständigkeit halber erwähnen wir etwas etwas Komplexeres auf der Ausführungsebene. Die Codeverarbeitung ist in zwei Phasen unterteilt: Variablen, Funktionsdeklaration und Parametererstellung im Normalformat. Dies ist eine Phase des Parsens und der Eingabe von Kontext. Die zweite Phase ist die Codeausführung, in der Funktionsausdrücke und unqualifizierte Bezeichner (für deklarierte Variablen) erstellt werden. Aus praktischen Gründen werden wir jedoch das Konzept des „Hebens“ übernehmen, das im ECMAScript-Standard nicht definiert ist und im Allgemeinen zur Beschreibung von Verhalten verwendet wird.

Zugriff auf globale Objekte

Im Browser kann über das Fensterattribut überall im Code auf das globale Objekt zugegriffen werden (es sei denn, Sie tun etwas Unverschämtes, wie zum Beispiel die Deklaration einer lokalen Variablen von window). Aber in anderen Kontexten könnte diese praktische Eigenschaft anders heißen (oder im Programm sogar nicht verfügbar sein). Wenn Sie ohne eine hartcodierte Fensterkennung auf das globale Objekt zugreifen müssen, können Sie im Funktionsumfang auf jeder Ebene Folgendes tun:

var global = (function () {
   return this;
}());

这种方法可以随时获得全局对象，因为其在函数中被当做函数调用了（不是通过new构造），this总是指向全局对象。实际上这个病不适用于ECMAScript 5严格模式，所以，在严格模式下时，你必须采取不同的形式。例如，你正在开发一个JavaScript库，你可以将你的代码包裹在一个即时函数中，然后从全局作用域中，传递一个引用指向this作为你即时函数的参数。