var

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. Jede muss ein legaler JavaScript-Bezeichner oder ein Destructuring-Bindungsmuster sein.

valueN Optional

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

Der Gültigkeitsbereich einer mit var deklarierten Variablen ist eine der folgenden in geschweifte Klammern eingeschlossenen Syntaxen, die die var Anweisung am engsten umschließt:

• Funktionskörper
• Statischer Initialisierungsblock

Oder wenn keine der oben genannten zutrifft:

• Das aktuelle Modul, für Code, der im Modulmodus ausgeführt wird
• Der globale Gültigkeitsbereich, für Code, der im Skriptmodus ausgeführt wird.

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ßlich Blockanweisungen, try...catch, switch, Kopfzeilen von einer der for-Anweisungen, keine Gültigkeitsbereiche für var erzeugen, und Variablen, die mit var innerhalb eines solchen Blocks deklariert wurden, weiterhin außerhalb des Blocks referenziert werden können.

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 hinzugefügt. Das bedeutet, dass ihr Eigenschaftsdeskriptor nicht geändert werden kann und sie nicht mit delete gelöscht werden kann. JavaScript hat eine automatische Speicherverwaltung, und es wäre sinnlos, den delete-Operator auf eine globale Variable anwenden zu können.

"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 Variablendeklarationen auf Module beschränkt und werden nicht als Eigenschaften zum globalen Objekt hinzugefügt.

Die Liste, die dem var Schlüsselwort folgt, wird Bindungsliste genannt und ist durch Kommas getrennt, wobei die Kommas keine Kommaoperatoren und die = Zeichen keine Zuweisungsoperatoren sind. Initialisierer späterer Variablen können sich auf frühere Variablen in der Liste beziehen und den initialisierten Wert erhalten.

var-Deklarationen, egal wo sie in einem Skript auftreten, werden verarbeitet, bevor irgendein Code innerhalb des Skripts ausgeführt wird. Das Deklarieren einer Variablen irgendwo im Code ist gleichbedeutend mit ihrem Deklarieren am Anfang. Das bedeutet auch, dass eine Variable scheinbar verwendet werden kann, bevor sie deklariert wird. Dieses Verhalten wird _hoisting_ genannt, da es so erscheint, als ob die Variablendeklaration an den Anfang der Funktion, des statischen Initialisierungsblocks oder der Skriptquelle, in der sie vorkommt, verschoben wird.

Note: var-Deklarationen werden nur an den Anfang des aktuellen Skripts verschoben. Wenn Sie zwei <script>-Elemente innerhalb eines HTML haben, kann das erste Skript nicht auf Variablen zugreifen, die vom zweiten deklariert wurden, bevor das zweite Skript verarbeitet und ausgeführt wurde.

bla = 2;
var bla;

Dies wird implizit verstanden als:

var bla;
bla = 2;

Aus diesem Grund wird empfohlen, Variablen immer am Anfang ihres Gültigkeitsbereichs zu deklarieren (oben im globalen Code und oben im Funktionscode), damit klar ist, welche Variablen dem aktuellen Funktionsbereich gehören.

Nur die Deklaration einer Variablen wird verschoben, nicht ihre Initialisierung. Die Initialisierung erfolgt erst, 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
}

Doppelte Variablendeklarationen mit var führen nicht zu einem Fehler, selbst 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 können auch im gleichen Gültigkeitsbereich wie eine function-Deklaration stehen. In diesem Fall überschreibt der Initialisierer der var-Deklaration immer den Wert der Funktion, unabhängig von ihrer relativen Position. Dies ist der Fall, weil Funktionsdeklarationen vor jedem Initialisierer ausgewertet werden, sodass der Initialisierer später kommt und den Wert überschreibt.

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

var-Deklarationen können nicht im gleichen Gültigkeitsbereich 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 Blöcke beschränkt sind, gilt dies auch für den folgenden Fall:

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

Es gilt nicht für den folgenden Fall, bei dem let sich in einem untergeordneten Bereich von var befindet, nicht im gleichen Bereich:

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

Eine var-Deklaration innerhalb des Funktionskörpers 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 catch-gebundene Bezeichner haben, jedoch nur, wenn die catch-Bindung ein einfacher Bezeichner ist, nicht ein Destrukturierungsmuster. Dies ist eine veraltete Syntax und Sie sollten sich nicht darauf verlassen. In diesem Fall wird die Deklaration aus dem catch-Block heraus verschoben, aber jeder innerhalb des catch-Blocks zugewiesene Wert ist außerhalb nicht sichtbar.

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

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

Dies entspricht:

var a, b = a = "A";

Beachten Sie die Reihenfolge:

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

Hier werden x und y deklariert, bevor irgendein Code ausgeführt wird, aber die Zuweisungen erfolgen später. Zu dem Zeitpunkt, an dem x = y ausgewertet wird, existiert y, sodass kein ReferenceError ausgelöst wird und sein Wert ist undefined. Daher wird x der Wert undefined zugewiesen. Dann wird y der Wert "A" zugewiesen.

Seien Sie vorsichtig mit der Syntax var x = y = 1 — y wird eigentlich nicht als Variable deklariert, sodass y = 1 eine nicht qualifizierte Bezeichnerzuweisung ist, die eine globale Variable im Nicht-Striktmodus 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 Strikten Modus:

"use strict";

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

console.log(x, y);

Variablen, die scheinbar implizite Globals sind, können Verweise 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 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

Die linke Seite jedes = kann auch ein Bindungsmuster sein. Dies ermöglicht 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"

Für mehr Informationen siehe Destrukturierung.

• let
• const