In der vorherigen Einführung wissen wir bereits, dass JavaScript keine Funktion auf Blockebene hat, sondern nur den Umfang auf Funktionsebene.
Die Codekopie lautet wie folgt:
Funktionstest () {// Ein Umfang
für (var i = 0; i <10; i ++) {// kein Umfang
// zählen
}
console.log (i); // 10
}
In JavaScript wird auch kein Namespace angezeigt, was bedeutet, dass im globalen Bereich alles definiert ist. Jedes Mal, wenn auf eine Variable verwiesen wird, durchquert JavaScript den gesamten globalen Umfang, bis er gefunden wird. Wenn die Variable noch nicht durch den vollständigen globalen Bereich gefunden wird, wird ein ReferenzErrorfehler geworfen.
Bitte geben Sie eine Bildbeschreibung ein
Implizite globale Variablen
Die Codekopie lautet wie folgt:
// Skript a
foo = '42';
// Skript b
var foo = '42'
Die obigen zwei Beispiele haben unterschiedliche Effekte. Der erste wird das variable Foo im globalen Bereich definieren, während der zweite den variablen Foo im aktuellen Bereich definiert.
Wir müssen beachten, dass es unerwartete Auswirkungen hat, wenn Sie das Keyword VAR nicht verwenden.
Die Codekopie lautet wie folgt:
// globaler Umfang
var foo = 42;
Funktionstest () {
// Lokaler Bereich
foo = 21;
}
prüfen();
foo; // 21
Da Var nicht verwendet wird, um den variablen Foo im Funktionstest zu definieren, wird die globale variable FOO außerhalb der Funktion überschrieben. Obwohl es kein großes Problem erscheint, ist es ein schwieriger Fehler, Tausende von Codezeilen zu verfolgen.
Die Codekopie lautet wie folgt:
// globaler Umfang
var items = [/ * eine Liste */];
für (var i = 0; i <10; i ++) {
Subloloop ();
}
Funktion subloop () {
// Umfang der Subloop
für (i = 0; i <10; i ++) {// fehlende var Anweisung
// Erstaunliche Sachen machen!
}
}
Im obigen Beispiel hört die externe Schleife beim Ausführen der ersten Ausführung auf, da die Variable I in der SublololoP -Funktion die externe globale Variable i überschreibt. Wir müssen nur eine VAR in der Funktion hinzufügen, um diesen Fehler zu vermeiden. Daher müssen wir nicht vergessen, das Schlüsselwort var beim Definieren von Variablen hinzuzufügen. Es sei denn, wir möchten einen Einfluss auf externe globale Variablen haben.
Lokale Variablen
Lokale Variablen in JavaScript können nur auf zwei Arten generiert werden, einer wird über das Schlüsselwort var deklariert und der andere wird als formale Parameter der Funktion verwendet.
Die Codekopie lautet wie folgt:
// globaler Umfang
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 innerhalb des Funktionstests lokale Variablen, und die Bar überschreibt die externe globale Variable.
Heben
JavaScript fördert variable Deklarationen, was bedeutet, dass sowohl Varizen- als auch Funktionserklärungen an die Spitze des Geltungsbereichs gefördert werden.
Die Codekopie lautet wie folgt:
Bar();
var bar = function () {};
var irgendwann = 42;
prüfen();
Funktionstest (Daten) {
if (false) {
goo = 1;
} anders {
var goo = 2;
}
für (var i = 0; i <100; i ++) {
var e = data [i];
}
}
Bevor der obige Code ausgeführt wird, wird die Erklärung des VAR -Ausdrucks und des Funktionstests nach oben beworben, sodass das Programm normal ausgeführt wird und keinen Fehler meldet.
Die Codekopie lautet wie folgt:
// VAR -Anweisungen wurden hierher verschoben
var bar, etwas Wert; // standardmäßig nicht definiert '
// Die Funktionserklärung wurde ebenfalls nach oben verschoben
Funktionstest (Daten) {
var goo, ich, e; // Fehlender Blockbereich bewegt diese hier diese
if (false) {
goo = 1;
} anders {
goo = 2;
}
für (i = 0; i <100; i ++) {
e = Daten [i];
}
}
Bar(); // scheitert mit einem TypenError, da die Bar immer noch nicht definiert ist.
irgendwann = 42; // Zuordnungen sind nicht durch das Heben betroffen
bar = function () {};
prüfen();
Da JavaScript keinen Umfang auf Blockebene aufweist, verbessert dies nicht nur den VAR-Ausdruck, sondern auch die If-Struktur weniger intuitiv.
Im obigen Beispiel scheint die lokale Variable, obwohl die variable GoO gefördert wird, zwar in der Tat anscheinend, wenn der globale Variable -Goo arbeitet, geändert.
Wenn Sie die Höhenregeln nicht verstehen, denken Sie möglicherweise, dass der folgende Code einen ReferenzErrorfehler wirft.
Die Codekopie lautet wie folgt:
// Überprüfen Sie, ob eine Art von irgendeiner Portierung initialisiert wurde
if (!
var maryMportanththing = {};
}
Natürlich ist der obige Code nicht falsch, da der VaR -Ausdruck vor dem Ausführen des Codes nach oben befördert wurde.
Die Codekopie lautet wie folgt:
var machportant;
// Ein anderer Code kann hier irgendeine Art und Weise initialisieren oder nicht oder nicht
// stellen Sie sicher, dass es da ist
if (!
Irgendwelche portanthing = {};
}
Hier möchte ich den Blog -Beitrag von @Nightire Fan GE "Undering JavaScript (ii)" empfehlen, was die Verbesserung sehr gründlich erklärt.
Namensauflösung
Bei dem Versuch, in einem Funktionsbereich auf eine FOO -Variable zuzugreifen, sucht JavaScript in der folgenden Reihenfolge danach:
Ob es eine Definition von Var Foo im aktuellen Bereich gibt.
Ob im Funktionsparameter eine FOO -Variable vorhanden ist.
Ob die Funktion selbst foo ist.
Springen Sie in die äußere Definitionsdomäne und schauen Sie vom ersten Teil auf.
Namespace
Eines der häufigsten Probleme ist die Benennung von Konflikten, da JavaScript nur einen globalen Bereich hat. Dieses Problem kann jedoch durch anonyme externe Funktionen gelöst werden.
Die Codekopie lautet wie folgt:
(function () {
// ein selbst enthaltenes "Namespace"
window.foo = function () {
// eine freiliegende Schließung
};
}) (); // Die Funktion sofort ausführen
Die anonymen Funktionen im obigen Beispiel werden als Ausdrücke betrachtet, sodass sie ausgeführt werden.
Die Codekopie lautet wie folgt:
(// die Funktion innerhalb der Eltern bewerten
function () {}
) // und geben Sie das Funktionsobjekt zurück
() // nennen Sie das Ergebnis der Bewertung
Natürlich können wir auch andere Methoden verwenden, um Funktionsausdrücke, unterschiedliche Strukturen, aber denselben Effekt aufzurufen.
Die Codekopie lautet wie folgt:
// ein paar andere Stile, um die direkt aufzurufen
!Funktion(){}()
+function () {} ()
(Funktion(){}());
// und so weiter...
Zusammenfassen
Es wird empfohlen, anonyme externe Funktionen zu verwenden, um den Code in den Raum zu integrieren, der nicht nur Namespace -Konflikte löst, sondern auch die Modularisierung des Programms erleichtert.
Darüber hinaus ist die Verwendung globaler Variablen keine gute Angewohnheit, die hohe Wartungskosten bringt und anfällig für Fehler ist.
Namespaces haben die gleichen Typen, Funktionen, Variablen, Vorlagen usw., alle gehören zu Entitäten.
Die Hauptgemeinheit einer Entität ist, dass es einen Namen haben kann. (Darüber hinaus kann ein Tag auch einen Namen haben, aber es ist keine Entität.)
Der Namespace Scope ist ein allgemeiner Begriff im Bereich, der parallel zum Umfang, Klassenbereich, Funktionsprototyp und Funktionsumfang (nur für Beschriftungen gültig) blockiert wird. Die im Namespace deklarierten Namen befinden sich im Namespace -Bereich. Globale Namen werden im impliziten globalen Namespace -Bereich berücksichtigt.
Die Funktion eines Namespace ist in der Tat umfangreich, unterscheidet sich jedoch von einem einfachen Bereich. Sie können denselben Namespace an mehreren Stellen mehrmals an mehreren Stellen deklarieren, aber der Inhalt im Inhalt kann nicht neu definiert werden. Sie werden schließlich einen Namespace synthetisieren, genau wie STD, Makrodefinitionen überall.