Javascript-Studiennotizen – Funktionen (6): Umfang und Namespace_Grundkenntnisse

In der vorherigen Einführung wissen wir bereits, dass Javascript keinen Gültigkeitsbereich auf Blockebene hat, sondern nur einen Gültigkeitsbereich auf Funktionsebene.

Code kopieren Der Code lautet wie folgt:

function test() { // ein Bereich
for(var i = 0; i < 10; i ) { // kein Gültigkeitsbereich
               // zählen
}
console.log(i); // 10
}

Außerdem gibt es in Javascript keine expliziten Namespaces, was bedeutet, dass alles im globalen Bereich definiert ist. Jedes Mal, wenn auf eine Variable verwiesen wird, durchläuft Javascript den gesamten globalen Bereich, bis es die Variable findet. Wenn die Variable nach dem Durchlaufen des gesamten globalen Bereichs nicht gefunden wird, wird ein ReferenceError ausgelöst.

Bitte geben Sie eine Bildbeschreibung ein

Implizite globale Variablen

Code kopieren Der Code lautet wie folgt:

// Skript A
foo = '42';
// Skript B
var foo = '42'

Die beiden oben genannten Beispiele erzeugen unterschiedliche Effekte. Der erste definiert die Variable foo im globalen Bereich, während der zweite die Variable foo im aktuellen Bereich definiert.
Wir müssen beachten, dass die Nichtverwendung des Schlüsselworts var unerwartete Auswirkungen haben wird.

Code kopieren Der Code lautet wie folgt:

// globaler Geltungsbereich
var foo = 42;
Funktionstest() {
// lokaler Geltungsbereich
foo = 21;
}
test();
foo; // 21

Da var nicht zum Definieren der Variablen foo im Funktionstest verwendet wird, wird die globale Variable foo außerhalb der Funktion überschrieben. Obwohl dies kein großes Problem zu sein scheint, kann es bei Tausenden von Codezeilen schwierig sein, diesen Fehler aufzuspüren.

Code kopieren Der Code lautet wie folgt:

// globaler Geltungsbereich
var items = [/* some list */];
for(var i = 0; i < 10; i ) {
subLoop();
}
Funktion subLoop() {
// Umfang von subLoop
for(i = 0; i < 10; i ) { // fehlende var-Anweisung
              // Mach tolle Sachen!
}
}

Im obigen Beispiel stoppt die äußere Schleife bei ihrer ersten Ausführung, da die Variable i innerhalb der Unterschleifenfunktion die äußere globale Variable i überschreibt. Wir müssen nur eine Variable innerhalb der Funktion hinzufügen, um diesen Fehler zu vermeiden. Daher dürfen wir beim Definieren von Variablen nicht vergessen, das Schlüsselwort Var hinzuzufügen. Es sei denn, wir wollen wirklich externe globale Variablen beeinflussen.

Lokale Variablen

Lokale Variablen in Javascript können nur auf zwei Arten generiert werden: Zum einen durch die Deklaration über das Schlüsselwort var und zum anderen als formaler Parameter einer Funktion.

Code kopieren Der Code lautet wie folgt:

// globaler Geltungsbereich
var foo = 1;
var bar = 2;
var i = 2;
Funktionstest(i) {
// lokaler Umfang des Funktionstests
i = 5;
var foo = 3;
bar = 4;
}
test(10);

Zu diesem Zeitpunkt sind die Variablen i und foo im Funktionstest lokale Variablen, und bar überschreibt die externe globale Variable bar.

Heben

Javascript hebt Variablendeklarationen an, was bedeutet, dass Variablenausdrücke und Funktionsdeklarationen an die Spitze des Gültigkeitsbereichs gehoben werden.

Code kopieren Der Code lautet wie folgt:

bar();
var bar = function() {};
var someValue = 42;
test();
Funktionstest(Daten) {
Wenn (falsch) {
         goo = 1;
} sonst {
      var goo = 2;
}
for(var i = 0; i < 100; i ) {
      var e = data[i];
}
}

Bevor der obige Code ausgeführt wird, werden der var-Ausdruck und die Deklaration des Funktionstests nach oben verschoben, sodass das Programm normal ausgeführt wird und kein Fehler gemeldet wird.

Code kopieren Der Code lautet wie folgt:

// var-Anweisungen wurden hierher verschoben
var bar, someValue; // Standardwert ist „undefiniert“
// Die Funktionsdeklaration wurde ebenfalls nach oben verschoben
Funktionstest(Daten) {
var goo, i, e; // fehlender Blockbereich verschiebt diese hierher
Wenn (falsch) {
         goo = 1;
} sonst {
         goo = 2;
}
for(i = 0; i < 100; i ) {
         e = data[i];
}
}
bar(); // schlägt mit einem TypeError fehl, da bar immer noch „undefiniert“ ist
someValue = 42; // Zuweisungen sind vom Hochziehen nicht betroffen
bar = function() {};
test();

Da Javascript keinen Gültigkeitsbereich auf Blockebene hat, erhöht dies nicht nur den var-Ausdruck, sondern macht auch die if-Struktur weniger intuitiv.
Obwohl es im obigen Beispiel so aussieht, als ob die globale Variable goo bearbeitet wird, handelt es sich tatsächlich um eine lokale Variable, die geändert wird, da die Variable goo heraufgestuft wird.
Ohne die Heberegeln zu verstehen, könnten Sie denken, dass der folgende Code einen ReferenceError auslöst.

Code kopieren Der Code lautet wie folgt:

// prüfen, ob SomeImportantThing initialisiert wurde
if (!SomeImportantThing) {
var SomeImportantThing = {};
}

Natürlich ist der obige Code fehlerfrei, da der var-Ausdruck vor der Ausführung des Codes nach oben verschoben wurde.

Code kopieren Der Code lautet wie folgt:

var SomeImportantThing;
// Anderer Code könnte SomeImportantThing hier initialisieren oder auch nicht
// Stellen Sie sicher, dass es da ist
if (!SomeImportantThing) {
SomeImportantThing = {};
}

Ich möchte den Blogbeitrag „Understanding JavaScript (2)“ von @nightire Fan Ge empfehlen, in dem die Verbesserung sehr ausführlich erklärt wird.
Reihenfolge der Namensauflösung

Beim Versuch, innerhalb eines Funktionsbereichs auf eine foo-Variable zuzugreifen, sucht Javascript in der folgenden Reihenfolge:

Ob es im aktuellen Geltungsbereich eine Definition von var foo gibt.
Ob der Funktionsparameter eine foo-Variable enthält.
Ob die Funktion selbst foo heißt.
Springen Sie zur äußeren Domäne und suchen Sie ab dem ersten Teil.
Namensraum

Eines der häufigsten Probleme sind Namenskonflikte, die dadurch verursacht werden, dass Javascript nur einen globalen Gültigkeitsbereich hat. Dieses Problem kann jedoch durch anonyme externe Funktionen gelöst werden.

Code kopieren Der Code lautet wie folgt:

(function() {
// ein eigenständiger „Namespace“
window.foo = function() {
                // ein freigelegter Verschluss
};
})(); // Funktion sofort ausführen

Die anonymen Funktionen im obigen Beispiel gelten als Ausdrücke und werden daher ausgeführt.

Code kopieren Der Code lautet wie folgt:

( // Werte die Funktion innerhalb der Klammern aus
function() {}
) // und das Funktionsobjekt zurückgeben
() // Ergebnis der Auswertung aufrufen

Natürlich können wir Funktionsausdrücke auch auf andere Weise aufrufen, mit unterschiedlicher Struktur, aber gleicher Wirkung.

Code kopieren Der Code lautet wie folgt:

// Ein paar andere Stile zum direkten Aufrufen von
!function(){}()
function(){}()
(function(){}());
// und so weiter...

Zusammenfassung

Es wird empfohlen, anonyme externe Funktionen zu verwenden, um den Code in einen Raum zu kapseln. Dies kann nicht nur Namespace-Konflikte lösen, sondern auch die Modularisierung des Programms erleichtern.
Darüber hinaus ist die Verwendung globaler Variablen keine gute Praxis, da die Wartung kostspielig und fehleranfällig ist.

Namespace-Typen, Funktionen, Variablen, Vorlagen usw. gehören alle zu Entitäten.
Das Wichtigste, was Entitäten gemeinsam haben, ist, dass sie Namen haben können. (Außerdem kann ein Label auch einen Namen haben, ist aber keine Entität.)
Der Namespace-Bereich ist ein allgemeiner Begriff für einen Bereichstyp, der dem Block-Bereich, dem Klassen-Bereich, dem Funktions-Prototyp-Bereich und dem Funktions-Bereich gegenübergestellt wird (nur gültig für Labels). Innerhalb eines Namespace deklarierte Namen liegen im Namespace-Gültigkeitsbereich. Globale Namen gelten als im impliziten globalen Namespacebereich liegend.

Die Rolle eines Namespace ist zwar ein Bereich, unterscheidet sich jedoch von einem einfachen Bereich. Sie können denselben Namespace mehrmals an mehreren Stellen deklarieren, der Inhalt kann jedoch nicht neu definiert werden. Sie werden schließlich zu einem Namen zusammengefasst. Leerzeichen, genau wie Standard, Makrodefinitionen überall