JavaScript: Variabler Bereich. Variablenbereich Js globale Variable in der Funktion

Hallo! Heute werden wir über den Umfang der Variablen sprechen (lesen Sie, was eine Variable ist). Tatsache ist, dass es beim Erstellen einer Variablen in einer Funktion, deren Name mit dem Namen einer Variablen außerhalb der Funktion übereinstimmt, verschiedene interessante Situationen geben kann, die sich auf den globalen und lokalen Bereich der Variablen beziehen.

Damit werden wir diese Lektion verstehen.

Globale Variable

Alle Variablen, die Sie außerhalb der Funktion erstellen, sind global. Und es ist unbedingt erforderlich, eine Variable mit dem Schlüsselwort var zu erstellen. Andernfalls wird die Variable überall im Programm angezeigt. Wenn der strikte Modus aktiviert ist, führt dies zu einem Fehler. Um den strengen Modus zu aktivieren, reicht es aus, die Zeile "use strict" am Anfang Ihres Skripts zu schreiben. Dadurch wird der JavaScript-Interpreter angewiesen, den JavaScript-Standard strikt einzuhalten. Hier ist ein Beispiel mit einer globalen Variablen

Var a \u003d 6; // globale Variablenfunktion double () (Rückgabewarnung (a * a); // Verwendung einer globalen Variablen) double ();

Das Beispiel deklariert eine globale Variable a, der der Wert 6 zugewiesen ist. In der Funktion können wir auf diese Variable zugreifen und noch mehr ihren Wert ändern, und dieser Wert wird sich überall ändern.

Schauen wir uns ein Beispiel an, in dem der Wert einer globalen Variablen in einer Funktion geändert wird. Anschließend greifen wir auf die globale Variable außerhalb der Funktion zu und sehen den Wert, der in der Funktion selbst festgelegt wurde.

Var a \u003d 6; Funktion double () (a \u003d 5; // ändere den Wert der globalen Variablen in der Funktionsrückgabewarnung (a * a);) double (a); // rufe die Funktion document.write (a) auf; // Wert der globalen Variablen

Wie Sie dem Beispiel entnehmen können, bleibt der Wert einer globalen Variablen in einer Funktion bereits überall erhalten, sowohl in der Funktion als auch außerhalb.

Lokale Variable.

Wenn Sie eine Variable in einer Funktion deklarieren, wird sie lokal und kann nur innerhalb der Funktion aufgerufen werden. Es ist zu beachten, dass die Anweisungen if / else, for, while, do ... while den Umfang der Variablen nicht beeinflussen.

Es stellt sich also heraus, dass Sie in einer Funktion auf eine globale Variable zugreifen können, aber global außerhalb einer Funktion nicht auf eine lokale Variable, die im Hauptteil der Funktion erstellt wurde. Schauen wir uns ein Beispiel an.

Funktion double () (var a \u003d 6; Rückgabewarnung (a * a);) double (); document.write (a); // versucht auf eine lokale Variable zuzugreifen

Im Beispiel wird die Variable nicht global deklariert, sondern in der Funktion, dh lokal. Dann rufen wir die Funktion auf und versuchen, auf die lokale Variable zuzugreifen. Infolgedessen passiert nichts und in der Konsole wird ein Fehler angezeigt, dass die Variable nicht definiert ist.

Und die letzte Option ist, wenn sowohl eine globale als auch eine lokale Variable mit demselben Namen erstellt werden, was dann passiert. Sehen wir uns ein Beispiel an.

Var a \u003d 7; Funktion double () (var a \u003d 6; Rückgabewarnung (a * a);) document.write (a);

Wie Sie hier sehen können, ist es in der Funktion so, als würde eine andere Variable erstellt, obwohl ihr Name mit dem globalen übereinstimmt und es die lokale Variable ist, die in der Funktion verfügbar ist. Sie kann die globale Variable nicht überschreiben, wie dieses Beispiel zeigt.

Welche Schlussfolgerung kann daraus gezogen werden? Aus diesem Grund wird versucht, Variablen mit unterschiedlichen Namen sowohl innerhalb als auch außerhalb der Funktion zu verwenden. Sie müssen jedoch die lokalen und globalen Bereiche kennen.

Ergebnisse.

Eine außerhalb einer Funktion erstellte Variable ist global.

Über die Funktion können Sie auf die globale Variable zugreifen und ihren Wert ändern.

Variablen dienen als "Container" zum Speichern von Informationen.

Erinnerst du dich an die Schulalgebra?

Erinnerst du dich an die Schulalgebra? x \u003d 5, y \u003d 6, z \u003d x + y

Erinnern Sie sich, dass ein Buchstabe (wie x) zum Speichern eines Werts (wie 5) verwendet worden sein könnte und dass Sie die obigen Informationen verwenden könnten, um zu berechnen, dass z 11 ist?

Diese Buchstaben heißen variablenund Variablen können zum Speichern von Werten (x \u003d 5) oder Ausdrücken (z \u003d x + y) verwendet werden.

JavaScript-Variablen

Genau wie in der Algebra werden JavaScript-Variablen zum Speichern von Werten oder Ausdrücken verwendet.

Eine Variable kann einen Kurznamen wie x oder einen aussagekräftigeren Namen wie carname haben.

Regeln für JavaScript-Variablennamen:

• Bei Variablennamen wird zwischen Groß- und Kleinschreibung unterschieden (y und Y sind zwei verschiedene Variablen).
• Variablennamen müssen mit einem Buchstaben oder Unterstrich beginnen

Kommentar: Da bei JavaScript zwischen Groß- und Kleinschreibung unterschieden wird, wird bei Variablennamen auch zwischen Groß- und Kleinschreibung unterschieden.

Beispiel

Der Wert einer Variablen kann sich während der Skriptausführung ändern. Sie können eine Variable anhand ihres Namens referenzieren, um ihren Wert anzuzeigen oder zu ändern.

Deklarieren (Erstellen) von JavaScript-Variablen

Das Erstellen von Variablen in JavaScript wird häufiger als "Deklarieren" von Variablen bezeichnet.

Sie deklarieren JavaScript-Variablen mit dem Schlüsselwort var:

Nach dem Ausführen der obigen Anweisungen wird die Variable x wird den Wert enthalten 5 und autoname wird den Wert enthalten Mercedes.

Kommentar: Wenn Sie einer Variablen einen Textwert zuweisen, setzen Sie ihn in Anführungszeichen.

Kommentar: Wenn Sie eine Variable erneut deklarieren, verliert sie ihren Wert nicht.

Lokale JavaScript-Variablen

Eine in einer JavaScript-Funktion deklarierte Variable wird LOKAL und wird nur innerhalb dieser Funktion verfügbar sein. (Die Variable hat einen lokalen Gültigkeitsbereich).

Sie können lokale Variablen mit demselben Namen in verschiedenen Funktionen deklarieren, da lokale Variablen in der Funktion erkannt werden, in der sie deklariert sind.

Lokale Variablen werden beim Beenden der Funktion zerstört.

Weitere Informationen zu Funktionen finden Sie in späteren JavaScript-Lektionen.

Globale JavaScript-Variablen

Außerhalb einer Funktion deklarierte Variablen werden GLOBALAlle Skripte und Funktionen auf der Seite können darauf zugreifen.

Globale Variablen werden beim Schließen der Seite zerstört.

Wenn Sie eine Variable ohne Verwendung von "var" deklarieren, wird die Variable immer GLOBAL.

Nicht deklarierten JavaScript-Variablen Werte zuweisen

Wenn Sie Variablen, die noch nicht deklariert wurden, Werte zuweisen, werden die Variablen automatisch als globale Variablen deklariert.

Diese Vorschläge:

Weitere Informationen zu Operatoren finden Sie im nächsten JavaScript-Tutorial.

Globale Variablen in Javascript

Was sind globale Variablen? Variablen sind zu jedem Zeitpunkt der Programmausführung "sichtbar", überall dort, wo sie gelesen und überschrieben werden können.
Normalerweise werden globale Variablen am Anfang des Programms außerhalb von Blöcken (()) definiert.
Im Fall von Js werden sie nach dem Skript oder allen anderen Funktionen festgelegt

hallo \u003d "Hallo"; // setze eine globale Variable und überprüfe sie
document.writeln ("-\u003e 1" + hallo + "jeder
"); // -\u003e 1 Hallo allerseits

Wenn wahr)
// if (false)
{
var hello \u003d "Hallo Dolly und"; // das ist auch global
Welt \u003d "Welt"; // global
var cont \u003d ", wir fahren fort" // global
document.writeln ("-\u003e 1.2" + hallo + world + cont + "
");
//1.
}
document.writeln ("-\u003e 2" + hallo + world + cont + "
");
// -\u003e 2 Hallo Dolly und Welt, wir machen weiter

Wenn das stimmt, bekommen wir die Antwort

-\u003e 1 Hallo an alle
-\u003e 1.2 Hallo Dolly und Welt, wir machen weiter
-\u003e 2 Hallo Dolly und Welt, wir machen weiter

Die Ausführung wird abgebrochen

Somit stellt sich heraus, dass die Verwendung von var den globalen Bereich in keiner Weise beeinflusst. Eine Variable, die in einem Skript außerhalb von Prozeduren erwähnt wird, wird als global betrachtet, selbst wenn sie in Klammern () des if while für Block- und andere Bereiche eingeschlossen ist, bleibt auch innerhalb von Schleifen global

Schlussfolgerungen in Kürze

* Für Variablen, die im globalen Bereich verwendet werden, ist das Vorhandensein von var nicht wichtig.
* Blöcke nach if while for erstellen keinen lokalen Bereich (wie in anderen Sprachen)

Lokale Variablen sind Variablen, die innerhalb des ausführbaren Blocks (der Funktion) festgelegt sind und andere Funktionen nicht beeinflussen. und die äußere Umgebung, d.h. globaler Geltungsbereich.

Junge \u003d "Jhone";
did \u003d "tötet Kenny"; // Wir haben also 2 globale Variablen
Funktion doit ()
{
// Drucken hat bereits --1 bestanden, und wir ändern die Daten, ändern die Daten
var boy \u003d "Gary"; // Erstelle ein Gebietsschema
did \u003d "hilft Anny"; // ändere das globale
;
document.writeln ("- 2" + boy + "" + did + "
");
// - 2 Gary hilft Anny
;
// Jetzt innerhalb der Funktion lokale und globale Variablen setzen
var good \u003d "Er war ein guter Junge
"; // Gebietsschema!
schlecht \u003d "er mag böse Mädchen
"; // global
}
;
document.writeln ("- 1" + Junge + "" + tat + "
");
// - 1 Jhone tötet Kenny
Tu es ();
// - 2 Gary hilft Anny
document.writeln ("- 3" + Junge + "" + tat + "
");
// - 3 Jhone hilft Anny
;
Wenn wahr)
// if (! false)
{
document.writeln ("- 4" + gut);
// Die Ausführung dieses Blocks verursacht einen Fehler.
// Wir befinden uns derzeit außerhalb des lokalen Bereichs
// doit () Funktion, also für uns, gegeben über var
// Variable gut existiert einfach nicht
}
document.writeln ("- 5" + schlecht);
// - 5 er mag böse Mädchen

Ergebnis:

1 Jhone tötet Kenny
--2 Gary hilft Anny
--3 Jhone hilft Anny
--5 Er mag böse Mädchen

Lokale Variablen in Javascript

* var arbeitet innerhalb einer Funktion, indem eine lokale Variable deklariert wird. Dies ist seine Hauptaufgabe.

* Javascrip unterscheidet sich stark von B darin, dass nur (?) Innerhalb einer Funktion lokale Variablen möglich sind.
* Die Verwendung von var oder die Nichtverwendung im globalen Bereich hängt nur von Ihrer persönlichen Erfahrung ab. Aber für mich ist es besser, nicht faul zu sein. in Perle heißt es Gebrauch streng

\u003e\u003e\u003e var ist für Variablen, die im globalen Bereich verwendet werden, nicht wichtig

Wichtig. Erstens können "vars" nicht gelöscht werden (mit delete). Zweitens erfolgt ihre Instanziierung in der "Nulllinie" (vor Arbeitsbeginn "zeilenweise"), wo ihnen sofort der undefinierte Wert zugewiesen wird und nur dann die Variable einen neuen Wert empfangen kann (oder nicht):

Var glb_1 \u003d 1;
if (false) (var glb_2 \u003d 2; glb_3 \u003d 3;)

Alert (glb_1) // instanziiert und hat den Wert 1 erhalten
alert (glb_2) // werde spezifisch und erhalte den Wert 'undefined'
alert (glb_3) // überhaupt keine Variable (keine var), ein Fehler beim Aufruf

Letzte Aktualisierung: 05.04.2018

Alle JavaScript-Variablen haben einen bestimmten Bereich, in dem sie agieren können.

Globale Variablen

Alle Variablen, die außerhalb von Funktionen deklariert werden, sind global:

Hier sind die Variablen x und d global. Sie sind von überall im Programm zugänglich.

Die Variable z ist jedoch nicht global, da sie innerhalb der Funktion definiert ist.

Lokale Variablen

Eine in einer Funktion definierte Variable ist lokal:

Funktion displaySquare () (var z \u003d 10; console.log (z); sei b \u003d 8; console.log (b);)

Die Variablen z und b sind lokal, sie existieren nur innerhalb der Funktion. Sie können nicht außerhalb einer Funktion verwendet werden:

Funktion displaySquare () (var z \u003d 10; console.log (z);) console.log (z); // Fehler, weil z undefiniert ist

Wenn die Funktion ihre Arbeit beendet hat, werden alle in der Funktion definierten Variablen zerstört.

Variablen ausblenden

Was ist, wenn wir zwei Variablen haben, eine globale und eine lokale, die denselben Namen haben:

Var z \u003d 89; Funktion displaySquare () (var z \u003d 10; console.log (z); // 10) displaySquare (); // zehn

In diesem Fall verwendet die Funktion die Variable z, die direkt in der Funktion definiert ist. Das heißt, die lokale Variable verbirgt die globale.

var oder lassen

Bei Verwendung der let-Anweisung definiert jeder Codeblock einen neuen Bereich, in dem die Variable vorhanden ist. Zum Beispiel können wir eine Variable gleichzeitig auf Blockebene und auf Funktionsebene definieren:

Sei z \u003d 10; Funktion displayZ () (sei z \u003d 20; (sei z \u003d 30; console.log ("Block:", z);) console.log ("Funktion:", z);) displayZ (); console.log ("Global:", z);

Hier wird innerhalb der Funktion displayZ ein Codeblock definiert, in dem die Variable z definiert ist. Es verbirgt die globale Variable und die z-Variable auf Funktionsebene. In einem realen Programm kann ein Block eine verschachtelte Funktion, eine for-Schleife oder if-Anweisungen darstellen. In jedem Fall definiert ein solcher Block einen neuen Bereich, außerhalb dessen die Variable nicht existiert.

In diesem Fall erhalten wir die folgende Konsolenausgabe:

Block: 30 Funktion: 20 Global: 10

Mit der Anweisung var können wir nicht gleichzeitig eine Variable mit demselben Namen sowohl in einer Funktion als auch in einem Codeblock in dieser Funktion definieren:

Funktion displaySquare () (var z \u003d 20; (var z \u003d 30; // Fehler! Variable z ist bereits definiert console.log ("Block:", z);) console.log ("Function:", z);)

Das heißt, mit var können wir eine Variable mit demselben Namen entweder auf Funktionsebene oder auf Codeblockebene definieren.

Konstanten

Alles an der let-Anweisung gilt auch für die const-Anweisung, mit der Sie Konstanten definieren können. Codeblöcke definieren den Umfang von Konstanten, und in verschachtelten Codeblöcken definierte Konstanten verbergen externe Konstanten mit demselben Namen:

Const z \u003d 10; Funktion displayZ () (const z \u003d 20; (const z \u003d 30; console.log ("Block:", z); // 30) console.log ("Funktion:", z); // 20) displayZ ( ); console.log ("Global:", z); // zehn

Nicht deklarierte Variablen

Wenn wir dieses Schlüsselwort beim Definieren einer Variablen in einer Funktion nicht verwenden, ist eine solche Variable global. Zum Beispiel:

Funktionsleiste () (foo \u003d "25";) bar (); console.log (foo); // 25

Obwohl foo nirgendwo außerhalb der Balkenfunktion definiert ist, ist es im externen Kontext weiterhin außerhalb der Funktion verfügbar.

Es wäre anders, wenn wir den Wert der Variablen nicht nur zuweisen, sondern auch definieren würden:

Funktionsleiste () (var foo \u003d "25";) bar (); console.log (foo); // Error

strikter Modus

Das Definieren globaler Variablen in Funktionen kann zu potenziellen Fehlern führen. Um sie zu vermeiden, wird der strikte Modus oder der strikte Modus verwendet:

"benutze streng"; Funktionsleiste () (foo \u003d "25";) bar (); console.log (foo);

In diesem Fall erhalten wir einen SyntaxError: Unexpected identifier error, der angibt, dass die Variable foo nicht definiert ist.

Es gibt zwei Möglichkeiten, den strengen Modus festzulegen:

fügen Sie den Ausdruck "use strict" am Anfang des JavaScript-Codes hinzu. Der strikte Modus wird dann auf den gesamten Code angewendet

fügen Sie den Ausdruck "use strict" am Anfang des Funktionskörpers hinzu. Der strikte Modus wird dann nur für diese Funktion angewendet

In dieser vierteiligen Lektion erfahren Sie, wie Sie hochwertigen JavaScript-Code schreiben, der einfach zu warten und zu entwickeln ist, auch wenn Sie nach langer Zeit wieder zum Projekt zurückkehren müssen.

Schreiben Sie Code mit der Erwartung, dass er beibehalten werden muss

Softwarefehler sind mit Kosten verbunden. Ihre Kosten werden in Form der Zeit ausgedrückt, die zur Behebung benötigt wird. Fehler in öffentlich gestarteten Projekten sind besonders kostspielig. Es ist sehr gut, wenn Sie Fehler sofort beheben können, wenn die Struktur des Codes noch frisch im Speicher ist und Sie den Problembereich schnell finden können. Wenn Sie jedoch zu anderen Aufgaben gewechselt sind und die Funktionen eines bestimmten Codes bereits vergessen haben, müssen Sie zum Projekt zurückkehren:

• Zeit, das Problem zu studieren und zu verstehen.
• Zeit, den Code zu verstehen, der die Ursache des Problems ist.

Ein weiteres Problem, das große Projekte oder Unternehmen betrifft, besteht darin, dass die Person, die die Fehler behebt, nicht die Person ist, die sie erstellt (und häufig nicht die Person, die sie im Projekt findet). Daher wird die Verkürzung der Zeit zum Verstehen des Codes zu einem kritischen Problem, unabhängig davon, ob Sie den Code vor einiger Zeit selbst geschrieben haben oder ob er von einem anderen Entwickler in Ihrem Team geschrieben wurde. Die Antwort auf die Frage wirkt sich sowohl auf das finanzielle Ergebnis des Projekts als auch auf die Zufriedenheit der Entwickler erheblich aus, da es manchmal besser ist, alles auf eine neue Art und Weise zu tun, als Stunden und Tage damit zu verbringen, alten unverständlichen Code zu pflegen.

Eine weitere Tatsache im Zusammenhang mit der Softwareentwicklung ist, dass sie normalerweise länger dauert lesen Code, nicht erstellen. Bei der anfänglichen Einstellung des Problems konzentriert sich der Entwickler und taucht in die Frage ein. Anschließend setzt er sich und kann an einem Abend wichtigen Code schreiben. Dann funktioniert der Code wahrscheinlich, aber aufgrund der natürlichen Natur von Softwareprodukten treten Situationen auf, die eine wiederholte Überarbeitung des Codes erfordern. Zum Beispiel:

• Fehler werden erkannt.
• Dem Projekt werden neue Funktionen hinzugefügt.
• Die Anwendung muss in einer neuen Umgebung gestartet werden (z. B. wurde ein neuer Browser angezeigt).
• Der Zweck des Codes ändert sich.
• Der Code muss vollständig neu geschrieben oder auf eine andere Architektur oder Programmiersprache portiert werden.

Infolgedessen dauert das Schreiben des Codes mehrere Mannstunden und das Lesen des Codes mehrere Manntage. Daher ist das Erstellen von leicht zu wartendem Code entscheidend für den Erfolg Ihrer Anwendung.

Einfach zu pflegender Code bietet die folgenden Funktionen:

• Es ist leicht zu lesen.
• Es ist gut strukturiert und die Teile passen zusammen.
• Es ist vorhersehbar.
• Es sieht so aus, als ob es von einer Person geschrieben wurde.
• Dokumentiert.

Minimierung der Verwendung globaler Variablen

JavaScript verwendet Funktionen zum Bearbeiten des Kontexts. Innerhalb von Funktionen deklarierte Variablen sind lokal für sie und außerhalb von Funktionen nicht verfügbar. Globale Variablen werden außerhalb von Funktionen deklariert oder einfach ohne Deklaration verwendet.

Jede JavaScript-Umgebung verfügt über ein globales Objekt, das außerhalb von Funktionen verwendet wird. Jede von Ihnen erstellte globale Variable wird zu einer Eigenschaft des globalen Objekts. Der Einfachheit halber verfügen Browser über eine zusätzliche Eigenschaft des globalen Objekts namens window, die (normalerweise) auf das globale Objekt selbst verweist. Der folgende Code zeigt ein Beispiel für das Erstellen und Zugreifen auf globale Variablen in der Browserumgebung:

Var myglobal \u003d "Hallo"; console.log (myglobal); // "Hallo" console.log (window.myglobal); // "Hallo" console.log (window ["myglobal"]); // "Hallo" console.log (this.myglobal); // "Hallo"

Probleme mit globalen Variablen

Das Problem mit globalen Variablen besteht darin, dass sie im gesamten JavaScript-Code Ihrer Anwendung oder Seite verfügbar sind. Sie befinden sich im globalen Namespace, und es besteht immer die Möglichkeit, Kollisionen zu benennen, wenn zwei verschiedene Teile der Anwendung globale Variablen mit demselben Namen, jedoch für unterschiedliche Zwecke definieren.

Außerdem enthält eine Webseite normalerweise Code, der von anderen Entwicklern geschrieben wurde. Zum Beispiel:

• Andere JavaScript-Bibliotheken.
• Skripte für Werbepartner.
• Benutzerverfolgungs- und Analysecode.
• Verschiedene Widgets, Buttons und Plugins.

Angenommen, eines der Skripte von Drittanbietern definiert eine globale Variable, die beispielsweise als Ergebnis bezeichnet wird. Anschließend definieren Sie in einer Ihrer Funktionen eine andere globale Variable und nennen sie result. Infolgedessen überschreibt die letzte Deklaration der Ergebnisvariablen die erste, und das Skript eines Drittanbieters funktioniert möglicherweise nicht mehr.

Daher ist es wichtig, so wenige globale Variablen wie möglich zu verwenden, um unterschiedlichen Code auf derselben Seite erfolgreich zu kombinieren. In dieser Frage spielt die Verwendung der var-Direktive beim Deklarieren von Variablen eine wesentliche Rolle.

Leider ist es aufgrund zweier Funktionen sehr einfach, versehentlich eine globale Variable in JavaScript zu erstellen. Erstens können Sie eine Variable verwenden, ohne sie zu deklarieren. Zweitens hat JavaScript eine implizite globale Definition, was bedeutet, dass jede Variable, die nicht deklariert ist, eine Eigenschaft des globalen Objekts wird (und als ordnungsgemäß deklarierte globale Variable verfügbar sein wird). Zum Beispiel:

Funktionssumme (x, y) (// schlecht: implizites globales Ergebnis \u003d x + y; Ergebnis zurückgeben;)

In diesem Code wird die Ergebnisvariable ohne Deklaration verwendet. Der Code funktioniert hervorragend, aber nach dem Aufrufen der Funktion erhalten Sie eine weitere Ergebnisvariable im globalen Namespace, was zu Problemen führen kann.

Die Minimierungsregel besteht darin, Variablen mithilfe der var-Direktive zu definieren. Das Folgende ist eine verbesserte Version der Funktion sum ():

Funktionssumme (x, y) (var result \u003d x + y; Ergebnis zurückgeben;)

Eine weitere schlechte Option zum Erstellen impliziter Globals ist die Verkettung eines Werts innerhalb einer var-Deklaration. Im folgenden Beispiel ist die Variable a lokal und die Variable b wird global, was wahrscheinlich nicht in der Liste der Ziele des Codeerstellers enthalten ist:

// schlecht, benutze nicht die Funktion foo () (var a \u003d b \u003d 0; // ...)

Wenn Sie von dem, was passiert, überrascht sind, handelt es sich um eine Berechnung von rechts nach links. Der Ausdruck b \u003d 0 wird zuerst ausgeführt, und daher wird die Variable b nicht deklariert. Der Rückgabewert des Ausdrucks ist 0 und wird der neuen lokalen Variablen a zugewiesen, die von der var-Direktive deklariert wird. Diese Definition von Variablen entspricht der folgenden Notation:

Var a \u003d (b \u003d 0);

Wenn Sie bereits Variablen deklariert haben, funktioniert die verkettete Ansicht einwandfrei und erzeugt keine unerwünschten Globals:

Funktion foo () (var a, b; a \u003d b \u003d 0; // beide Variablen sind lokal)

Ein weiterer Grund, die Verwendung globaler Variablen zu vermeiden, ist die Portabilität. Wenn Sie planen, Ihren Code in einer anderen Umgebung auszuführen, können globale Variablen Objekte überschreiben, die sich nicht in der ursprünglichen Umgebung befinden (daher scheint der verwendete Name sicher zu sein).

Nebeneffekt der vergessenen Var-Deklaration

Es gibt einen kleinen Unterschied zwischen explizit definierten und implizierten Globalen. Es besteht in der Möglichkeit, eine Variable mit dem Löschoperator zu löschen:

• Eine globale Variable, die mit einer var-Deklaration deklariert wurde (außerhalb von Funktionen im Programm erstellt), kann nicht gelöscht werden.
• Eine implizite globale Variable, die ohne Deklaration erstellt wurde (unabhängig davon, wo sie erstellt wurde), kann gelöscht werden.

Technisch gesehen ist eine implizite globale Variable eine Eigenschaft des globalen Objekts und keine Variable. Eigenschaften können mit dem Löschoperator gelöscht werden, Variablen jedoch nicht:

// definiere drei globale Variablen var global_var \u003d 1; global_novar \u003d 2; // bad (function () (global_fromfunc \u003d 3; // bad) ()); // Versuch zu löschen delete global_var; // false delete global_novar; // true delete global_fromfunc; // true // Auf Löschtyp prüfen von global_var; // "number" typeof global_novar; // "undefined" typeof global_fromfunc; // "nicht definiert"

Zugriff auf das globale Objekt

In Browsern ist das globale Objekt über die Fenstereigenschaft an einer beliebigen Stelle im Code verfügbar (es sei denn, Sie tun etwas Besonderes oder Unerwartetes, z. B. das Deklarieren einer lokalen Variablen mit dem Namen window). In anderen Umgebungen kann diese praktische Eigenschaft jedoch auf andere Weise verfügbar sein (oder dem Programmierer überhaupt nicht zur Verfügung stehen). Wenn Sie Zugriff auf das globale Objekt benötigen, ohne die Fensterkennung zu verwenden, können Sie die folgende Methode auf jeder Ebene des Namespace für verschachtelte Funktionen verwenden:

Var global \u003d (function () (return this;) ());

Somit ist es immer möglich, auf das globale Objekt zuzugreifen, da dies innerhalb einer Funktion, die als Funktion (und nicht als Konstruktor mit einer neuen Deklaration) aufgerufen wird, immer auf das globale Objekt verweist.

Vorlage für eine einzelne Var-Deklaration

Die Verwendung einer einzelnen var-Deklaration am oberen Rand Ihrer Funktion ist eine sehr nützliche Vorgehensweise. Diese Methode hat folgende Vorteile:

• Bietet einen einzigen Ort zum Deklarieren aller lokalen Variablen einer Funktion.
• Boolesche Fehler werden verhindert, wenn eine Variable verwendet wird, bevor sie deklariert wird.
• Hilft Ihnen, sich daran zu erinnern, lokale Variablen zu deklarieren, und reduziert daher die Anzahl der globalen Variablen.

Eine Vorlage mit einer einzelnen var-Deklaration sieht folgendermaßen aus:

Funktion func () (var a \u003d 1, b \u003d 2, sum \u003d a + b, myobject \u003d (), i, j; // Funktionscode ...)

Sie verwenden eine var-Deklaration, um mehrere durch Komma getrennte Variablen zu deklarieren. Eine hervorragende Ergänzung wäre, Variablen mit den Originaldaten zu initialisieren, wenn sie deklariert werden. Dies verhindert logische Fehler (alle nicht initialisierten Variablen sind standardmäßig nicht definiert) und verbessert die Lesbarkeit des Codes. Wenn Sie sich den Code später ansehen, wie Sie den Zweck einer Variablen anhand ihres Anfangswertes bestimmen können (z. B. sehen Sie sofort, dass es sich um ein Objekt oder eine Ganzzahl handelt).

Sie können auch eine Operation ausführen, wenn Sie eine Variable deklarieren, z. B. sum \u003d a + b aus dem vorherigen Beispielcode. Die DOM-Manipulation ist ein weiteres Arbeitsbeispiel. Sie können lokalen Variablen Verweise auf DOM-Elemente zuweisen, wenn Sie Folgendes deklarieren:

Funktion updateElement () (var el \u003d document.getElementById ("result"), style \u003d el.style; // Operationen mit el und style ausführen ...)

Heben: das Problem mit verstreuten Var-Deklarationen

JavaScript erlaubt mehrere var-Deklarationen an einer beliebigen Stelle in einer Funktion und sie funktionieren unabhängig davon, wo sie platziert sind, gleich. Diese Funktion wird als "Heben" bezeichnet. Dieses Verhalten kann zu logischen Fehlern führen, wenn Sie eine Variable verwenden und sie dann für weiteren Funktionscode deklarieren. Da sich eine Variable in JavaScript im selben Namespace (in derselben Funktion) befindet, wird angenommen, dass sie deklariert ist, auch wenn sie vor der var-Direktive verwendet wird. zum Beispiel

// bad myname \u003d "global"; // globale Variablenfunktion func () (alert (mein Name); // "undefiniert" var myname \u003d "local"; alert (mein Name); // "local") func ();

In diesem Beispiel wird erwartet, dass der erste Aufruf von alert () die Nachricht "global" und der zweite Aufruf "local" erzeugt. Dies ist eine vernünftige Erwartung, da beim ersten Aufruf die lokale Variable myname nicht deklariert wird und die Funktion die globale Variable myname verwenden muss. In Wirklichkeit funktioniert alles anders. Der erste Aufruf von alert () gibt "undefined" zurück, da myname in der Funktion als deklarierte lokale Variable behandelt wird (obwohl sie später deklariert wird). Alle Variablendeklarationen werden in die Funktion aufgenommen. Um diese Art von Fehler zu vermeiden, müssen Sie daher alle Variablen oben in der Funktion deklarieren.

Das vorherige Beispiel verhält sich so, als ob es folgendermaßen implementiert wäre:

Myname \u003d "global"; // globale Variablenfunktion func () (var myname; // wie -\u003e var myname \u003d undefined; alert (meinname); // "undefined" myname \u003d "local"; alert (meinname); // " lokal ") func ();

Erwähnenswert ist, dass die eigentliche Implementierung des Codes komplexer ist. Es gibt zwei Stufen der Codeverarbeitung. In der ersten Phase werden Variablen, Funktionsdeklarationen und formale Parameter erstellt und der Kontext definiert. Die zweite Stufe führt Code aus, wertet Funktionen aus und erstellt nicht qualifizierte Bezeichner (nicht deklarierte Variablen). Für den praktischen Gebrauch kann jedoch das Konzept des Hebens verwendet werden, das das Verhalten des Codes gut beschreibt.