var

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 gltiger JavaScript-Bezeichner oder ein Destrukturierungsmuster sein.

valueN Optional

Anfangswert der Variablen. Es kann jeder gltige Ausdruck sein. Standardwert ist undefined.

Beschreibung

Der Geltungsbereich einer mit var deklarierten Variablen ist eine der folgenden geschweift-klammer-umgebenen Strukturen, die die var-Anweisung am engsten umfasst:

• Funktionskrper
• Statischer Initialisierungsblock

Oder wenn nichts davon zutrifft:

• Das aktuelle Modul, fr Code im Modul-Modus
• Der globale Geltungsbereich, fr Code im Skript-Modus.

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, einschlielich Blockanweisungen, try...catch, switch, sowie die Kpfe von einer der for-Schleifenanweisungen keine Geltungsbereiche fr var erstellen, und dass Variablen, die mit var innerhalb eines solchen Blocks deklariert werden, weiterhin auerhalb des Blocks referenziert werden knnen.

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

In einem Skript wird eine mit var deklarierte Variable als nicht konfigurierbare Eigenschaft des globalen Objekts hinzugefgt. Das bedeutet, dass der Eigenschafts-Deskriptor nicht gendert werden kann und dass sie nicht mit delete gelscht werden kann. JavaScript verfgt ber eine automatische Speicherverwaltung, und es wre sinnlos, den delete-Operator auf eine globale Variable anwenden zu knnen.

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

In sowohl NodeJS CommonJS-Modulen als auch nativen ECMAScript-Modulen sind top-level Variablendeklarationen auf das Modul angewiesen und werden nicht als Eigenschaften des globalen Objekts hinzugefgt.

Die Liste, die dem var-Schlsselwort folgt, wird Bindung-Liste genannt und durch Kommata getrennt, wobei die Kommata keine Kommaoperatoren sind und die =-Zeichen keine Zuweisungsoperatoren sind. Initialisierungen spterer Variablen knnen sich auf frhere Variablen in der Liste beziehen und den initialisierten Wert erhalten.

Hoisting

var-Deklarierungen werden, egal wo sie in einem Skript auftreten, verarbeitet, bevor irgendein Code im Skript ausgefhrt wird. Wenn eine Variable irgendwo im Code deklariert wird, ist das gleichbedeutend damit, sie am Anfang zu deklarieren. Das bedeutet auch, dass eine Variable scheinbar verwendet werden kann, bevor sie deklariert ist. Dieses Verhalten wird Hoisting genannt, da es scheint, als ob die Variablendeklaration an den Anfang der Funktion, des statischen Initialisierungsblocks oder des Skriptquelltexts, in dem sie vorkommt, verschoben wird.

bla = 2;
var bla;

Dies wird implizit verstanden als:

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), um klarzustellen, welche Variablen im aktuellen Funktionsbereich festgelegt sind.

Nur die Deklaration einer Variablen wird gehoben, nicht ihre Initialisierung. Die Initialisierung erfolgt nur, wenn die Zuweisungsanweisung erreicht wird. Bis dahin bleibt die Variable undefined (aber deklariert):

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

Dies wird implizit verstanden als:

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

Mehrfachdeklarationen

Mehrfache Variablendeklarationen mit var lsen keinen Fehler aus, auch nicht im strikten 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); // 2
var a;
console.log(a); // 2; not undefined

var-Deklarationen knnen auch im selben Geltungsbereich wie eine function-Deklaration vorkommen. Sowohl die Funktionsdeklaration als auch die var-Deklaration werden an die Spitze verschoben, sodass der Funktionswert nur vom Anfang seines Geltungsbereichs bis zum Initialisierer oder der ersten Zuweisung der Variable zugnglich ist, unabhngig von den relativen Positionen der beiden Deklarationen im Quellcode.

console.log(typeof a); // "function"
function a() {}
var a;
console.log(typeof a); // "function"

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

var-Deklarationen knnen nicht im selben Geltungsbereich wie eine let, const, class, oder import-Deklaration sein.

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

Da var-Deklarationen nicht auf Blcke beschrnkt sind, gilt dies auch fr den folgenden Fall:

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

Es gilt nicht fr den folgenden Fall, bei dem let in einem Kindbereich von var und nicht im selben Bereich ist:

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

Eine var-Deklaration innerhalb des Krpers einer Funktion kann denselben Namen wie ein Parameter haben.

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

foo(2); // Logs 1

Eine var-Deklaration innerhalb eines catch-Blocks kann denselben Namen wie der im catch gebundene Bezeichner haben, jedoch nur, wenn die catch-Bindung ein einfacher Bezeichner und kein Destrukturierungsmuster ist. Dies ist eine veraltete Syntax und sollte nicht darauf vertraut werden. In diesem Fall wird die Deklaration nach auerhalb des catch-Blocks gehoben, aber ein innerhalb des catch-Blocks zugewiesener Wert ist auerhalb nicht sichtbar.

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

Beispiele

Deklarieren und Initialisieren zweier Variablen

var a = 0,
  b = 0;

Zuweisen zweier 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 werden x und y deklariert, bevor irgendein Code ausgefhrt wird, aber die Zuweisungen erfolgen spter. Zu dem Zeitpunkt, an dem x = y ausgewertet wird, existiert y, sodass kein ReferenceError ausgelst wird und sein Wert undefined ist. Somit wird x der undefined-Wert zugewiesen. Dann wird y der Wert "A" zugewiesen.

Initialisierung mehrerer Variablen

Achten Sie auf die Syntax var x = y = 1 y wird tatschlich nicht als Variable deklariert, daher ist y = 1 eine unangeschlossene Bezeichnerzuweisung, die im nicht-strikten Modus eine globale Variable 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, jedoch im strikten Modus:

"use strict";

var x = 0;
function f() {
  var x = y = 1; // ReferenceError: y is not defined
}
f();

console.log(x, y);

Implizite Globals und uerer Funktionsbereich

Variablen, die wie implizite Globals erscheinen, knnen Verweise auf Variablen in einem ueren 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 yet

function 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 5
console.log(typeof y); // "undefined", as y is local to function a

Deklaration mit Destrukturierung

Die linke Seite jedes = kann auch ein Bindungsmuster sein. Dies ermglicht das Erstellen mehrerer Variablen auf einmal.

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

Fr weitere Informationen siehe Destrukturierung.

Spezifikationen

Browser-Kompatibilitt

Siehe auch

• let
• const