Dievar-Anweisung deklariert funktions- oder global-gescoped Variablen und initialisiert optional jede mit einem Wert.

Probieren Sie es aus

var x = 1;if (x === 1) {  var x = 2;  console.log(x);  // Expected output: 2}console.log(x);// Expected output: 2

Syntax

var name1;var name1 = value1;var name1 = value1, name2 = value2;var name1, name2 = value2;var name1 = value1, name2, /* …, */ nameN = valueN;

nameN

Der Name der zu deklarierenden Variablen. Jeder muss ein legaler JavaScript-Bezeichner oder einDestructuring-Bindungsmuster sein.

valueNOptional

Initialwert der Variablen. Es kann jeder legale Ausdruck sein. Der Standardwert istundefined.

Beschreibung

Der Geltungsbereich einer mitvar deklarierten Variablen ist eine der folgenden geschweiften Klammer-Synaxen, die dievar-Anweisung am engsten einschließt:

• Funktionskörper
• Statischer Initialisierungsblock

Oder, wenn keine der obigen zutrifft:

• Das aktuelleModul für Code im Modulmodus
• Der globale Geltungsbereich für Code im Skriptmodus.

function foo() {  var x = 1;  function bar() {    var y = 2;    console.log(x); // 1 (function `bar` closes over `x`)    console.log(y); // 2 (`y` is in scope)  }  bar();  console.log(x); // 1 (`x` is in scope)  console.log(y); // ReferenceError, `y` is scoped to `bar`}foo();

Wichtig ist, dass andere Blockkonstrukte, einschließlichBlockanweisungen,try...catch,switch, Header voneiner derfor-Anweisungen keine Geltungsbereiche fürvar erstellen, und Variablen, die mitvar innerhalb eines solchen Blocks deklariert werden, können weiterhin außerhalb des Blocks referenziert werden.

for (var a of [1, 2, 3]);console.log(a); // 3

In einem Skript wird eine mitvar deklarierte Variable als nicht konfigurierbares Property des globalen Objekts hinzugefügt. Das bedeutet, dass ihr Property-Deskriptor nicht geändert und nicht mitdelete gelöscht werden kann. JavaScript hat eine automatische Speicherverwaltung, und es würde keinen Sinn ergeben, dendelete-Operator auf eine globale Variable anzuwenden.

"use strict";var x = 1;Object.hasOwn(globalThis, "x"); // truedelete globalThis.x; // TypeError in strict mode. Fails silently otherwise.delete x; // SyntaxError in strict mode. Fails silently otherwise.

In sowohl NodeJSCommonJS Modulen als auch nativenECMAScript-Modulen sind Top-Level-Variablendeklarationen auf das Modul beschränkt und werden nicht als Eigenschaften zum globalen Objekt hinzugefügt.

Die Liste, die auf dasvar-Schlüsselwort folgt, wird alsBindungsliste bezeichnet und durch Kommas getrennt, wobei die Kommas keineKomma-Operatoren und die=-Zeichen keineZuweisungsoperatoren sind. Initialisierungen späterer Variablen können sich auf frühere Variablen in der Liste beziehen und deren initialisierten Wert erhalten.

Hoisting

var-Deklarationen, wo immer sie in einem Skript vorkommen, werden verarbeitet, bevor jeglicher Code im Skript ausgeführt wird. Eine Variable an beliebiger Stelle im Code zu deklarieren, ist gleichbedeutend damit, sie oben zu deklarieren. Das bedeutet auch, dass eine Variable scheinbar vor ihrer Deklaration verwendet werden kann. Dieses Verhalten wird_Hoisting_ genannt, da es scheint, als ob die Variablendeklaration an die Spitze der Funktion, des statistischen Initialisierungsblocks oder des Skript-Quellcodes verschoben wird, in dem sie vorkommt.

bla = 2;var bla;

Dies wird implizit wie folgt verstanden:

var bla;bla = 2;

Aus diesem Grund wird empfohlen, Variablen immer am Anfang ihres Geltungsbereichs zu deklarieren (am Anfang des globalen Codes und am Anfang des Funktionscodes), damit klar ist, welche Variablen zum aktuellen Funktionsbereich gehören.

Nur die Deklaration einer Variablen wird gehoben, nicht ihre Initialisierung. Die Initialisierung erfolgt erst, wenn die Zuweisung ausgeführt wird. Bis dahin bleibt die Variableundefined (aber deklariert):

function doSomething() {  console.log(bar); // undefined  var bar = 111;  console.log(bar); // 111}

Dies wird implizit wie folgt verstanden:

function doSomething() {  var bar;  console.log(bar); // undefined  bar = 111;  console.log(bar); // 111}

Neudeklarationen

Doppelte Variablendeklarationen mitvar lösen keinen Fehler aus, selbst im strengen Modus, und die Variable verliert ihren Wert nicht, es sei denn, die Deklaration hat einen Initialisierer.

var a = 1;var a = 2;console.log(a); // 2var a;console.log(a); // 2; not undefined

var-Deklarationen können sich auch im gleichen Geltungsbereich wie einefunction-Deklaration befinden. In diesem Fall überschreibt der Initialisierer dervar-Deklaration immer den Funktionswert, unabhängig von ihrer relativen Position. Das liegt daran, dass Funktionsdeklarationen vor jedem Initialisierer gehoben werden, sodass der Initialisierer später kommt und den Wert überschreibt.

var a = 1;function a() {}console.log(a); // 1

var-Deklarationen können sich nicht im gleichen Geltungsbereich wie einelet,const,class oderimport-Deklaration befinden.

var a = 1;let a = 2; // SyntaxError: Identifier 'a' has already been declared

Davar-Deklarationen nicht an Blöcke gebunden sind, gilt dies auch für folgenden Fall:

let a = 1;{  var a = 1; // SyntaxError: Identifier 'a' has already been declared}

Es gilt nicht für den folgenden Fall, bei demlet in einem untergeordneten Bereich vonvar ist, nicht im gleichen Bereich:

var a = 1;{  let a = 2;}

Einevar-Deklaration im Funktionskörper kann denselben Namen wie ein Parameter haben.

function foo(a) {  var a = 1;  console.log(a);}foo(2); // Logs 1

Einevar-Deklaration innerhalb einescatch-Blocks kann denselben Namen wie der imcatch-Block gebundene Bezeichner haben, aber nur, wenn diecatch-Bindung ein einfacher Bezeichner und kein Destructuring-Muster ist. Dies ist eineveraltete Syntax und sollte nicht darauf vertraut werden. In diesem Fall wird die Deklaration außerhalb descatch-Blocks gehoben, aber ein imcatch-Block zugewiesener Wert ist außerhalb nicht sichtbar.

try {  throw new Error();} catch (e) {  var e = 2; // Works}console.log(e); // undefined

Beispiele

Deklarieren und Initialisieren von zwei Variablen

var a = 0,  b = 0;

Zuweisen von zwei Variablen mit einem einzigen String-Wert

var a = "A";var b = a;

Dies entspricht:

var a, b = a = "A";

Achten Sie auf die Reihenfolge:

var x = y,  y = "A";console.log(x, y); // undefined A

Hier werdenx undy deklariert, bevor Code ausgeführt wird, aber die Zuweisungen erfolgen später. Zu dem Zeitpunkt, an demx = y ausgewertet wird, existierty also wird keinReferenceError ausgelöst und sein Wert istundefined. Daher wirdx der undefined-Wert zugewiesen. Dann erhälty den Wert"A".

Initialisierung mehrerer Variablen

Seien Sie vorsichtig mit dervar x = y = 1-Syntax —y wird nicht tatsächlich als Variable deklariert, daher isty = 1 einenicht qualifizierte Identifier-Zuweisung, die eine globale Variable im nicht-strengen Modus erstellt.

var x = 0;function f() {  var x = y = 1; // Declares x locally; declares y globally.}f();console.log(x, y); // 0 1// In non-strict mode:// x is the global one as expected;// y is leaked outside of the function, though!

Dasselbe Beispiel wie oben, aber im strengen Modus:

"use strict";var x = 0;function f() {  var x = y = 1; // ReferenceError: y is not defined}f();console.log(x, y);

Implizite Globale und äußerer Funktionsbereich

Variablen, die scheinbar implizite Globale sind, können Referenzen auf Variablen in einem äußeren Funktionsbereich sein:

var x = 0; // Declares x within file scope, then assigns it a value of 0.console.log(typeof z); // "undefined", since z doesn't exist yetfunction a() {  var y = 2; // Declares y within scope of function a, then assigns it a value of 2.  console.log(x, y); // 0 2  function b() {    x = 3; // Assigns 3 to existing file scoped x.    y = 4; // Assigns 4 to existing outer y.    z = 5; // Creates a new global variable z, and assigns it a value of 5.    // (Throws a ReferenceError in strict mode.)  }  b(); // Creates z as a global variable.  console.log(x, y, z); // 3 4 5}a(); // Also calls b.console.log(x, z); // 3 5console.log(typeof y); // "undefined", as y is local to function a

Deklaration mit Destructuring

Die linke Seite jedes= kann auch ein Bindungsmuster sein. Dies ermöglicht die Erstellung mehrerer Variablen auf einmal.

const result = /(a+)(b+)(c+)/.exec("aaabcc");var [, a, b, c] = result;console.log(a, b, c); // "aaa" "b" "cc"

Für weitere Informationen sieheDestructuring.

Spezifikationen

Browser-Kompatibilität

Siehe auch

• let
• const