var
Baseline Widely available
This feature is well established and works across many devices and browser versions. It’s been available across browsers since July 2015.
Die var
-Anweisung deklariert funktions- oder global-scopierte Variablen und kann optional jeder Variablen einen Wert zuweisen.
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 deklarierten Variable. Jeder muss ein gültiger JavaScript-Bezeichner oder ein Destructuring-Bindungsmuster sein.
valueN
Optional-
Der Initialwert der Variablen. Dies kann jeder gültige Ausdruck sein. Der Standardwert ist
undefined
.
Beschreibung
Der Gültigkeitsbereich einer mit var
deklarierten Variable befindet sich im am nächsten liegenden, geschweiften Klammern eingeschlossenen Syntaxblock, der die var
-Anweisung enthält:
- Funktionskörper
- Statischer Initialisierungsblock
Oder, wenn keines der obigen Szenarien zutrifft:
- Das aktuelle Modul im Modus "Modulverarbeitung".
- Der globale Gültigkeitsbereich im Modus "Skriptverarbeitung".
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: Andere Blockkonstrukte, einschließlich Blockanweisungen, try...catch
, switch
, Kopfzeilen einer der for
-Anweisungen, schaffen keinen neuen Gültigkeitsbereich für var
. Variablen, die mit var
innerhalb eines solchen Blocks deklariert wurden, 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 mit var
deklarierte Variable als nicht konfigurierbare Eigenschaft des globalen Objekts hinzugefügt. Dies bedeutet, dass ihr Eigenschaftsbeschreiber nicht geändert werden kann und sie nicht mit delete
gelöscht werden kann. JavaScript verfügt über eine automatische Speicherverwaltung, und es würde keinen Sinn ergeben, den delete
-Operator auf eine globale Variable anzuwenden.
"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 in nativen ECMAScript-Modulen sind Variablen, die auf oberster Ebene deklariert werden, auf das Modul beschränkt und werden nicht als Eigenschaften des globalen Objekts hinzugefügt.
Die Liste, die dem Schlüsselwort var
folgt, wird Bindungsliste genannt und ist durch Kommata getrennt. Diese Kommata sind keine Komma-Operatoren, und die =
-Zeichen sind keine Zuweisungsoperatoren. Die Initialisierungen späterer Variablen können sich auf frühere Variablen in der Liste beziehen und deren initialisierten Wert erhalten.
Hoisting
var
-Deklarationen, egal an welcher Stelle sie in einem Skript auftreten, werden verarbeitet, bevor einer der Skriptinhalte ausgeführt wird. Das Deklarieren einer Variablen irgendwo im Code ist gleichbedeutend mit dem Deklarieren dieser Variablen am Anfang. Dies bedeutet auch, dass eine Variable scheinbar verwendet werden kann, bevor sie deklariert wurde. Dieses Verhalten wird _Hoisting_ genannt, da es so erscheint, als ob die Deklaration der Variablen an die Spitze der Funktion, des statischen Initialisierungsblocks oder der Skriptquelle verschoben wurde, in dem sie steht.
Hinweis: var
-Deklarationen werden nur bis an die Spitze des aktuellen Skripts "gehoisted". Wenn es zwei <script>
-Elemente innerhalb einer einzigen HTML gibt, kann das erste Skript nicht auf Variablen zugreifen, die vom zweiten definiert wurden, bevor das zweite verarbeitet und ausgeführt wurde.
bla = 2;
var bla;
Dies wird implizit wie folgt verstanden:
var bla;
bla = 2;
Aus diesem Grund wird empfohlen, Variablen immer am Anfang ihres Gültigkeitsbereichs (am Anfang des globalen Codes oder oben in Funktionsblöcken) zu deklarieren, damit klar ist, welche Variablen auf die aktuelle Funktion beschränkt sind.
Nur die Deklaration der Variable wird hochgezogen, nicht ihre Initialisierung. Die Initialisierung erfolgt nur, wenn die Zuweisungsanweisung erreicht wird. Bis zu diesem Zeitpunkt bleibt die Variable undefined
(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
}
Wiederholte Deklarationen
Doppelte Deklarationen mit var
lösen keinen Fehler aus, auch nicht im Strict-Modus. Die Variable verliert ihren Wert nicht, es sei denn, die Deklaration enthält eine Initialisierung.
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 vorkommen. In diesem Fall überschreibt die Initialisierung der var
-Deklaration immer den Funktionswert, unabhängig von ihrer relativen Position. Dies liegt daran, dass Funktionsdeklarationen vor der Bewertung jeglicher 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 nicht im gleichen Gültigkeitsbereich wie let
, const
, class
oder import
existieren.
var a = 1;
let a = 2; // SyntaxError: Identifier 'a' has already been declared
Weil var
-Deklarationen nicht auf Blöcke beschränkt sind, gilt dies auch für folgende Fälle:
let a = 1;
{
var a = 1; // SyntaxError: Identifier 'a' has already been declared
}
Es gilt jedoch nicht für den folgenden Fall, bei dem let
in einem untergeordneten Bereich von var
und nicht im gleichen Gültigkeitsbereich liegt:
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 im catch
gebundene Bezeichner haben, aber nur, wenn die catch
-Bindung ein einfacher Bezeichner ist und kein Destructuring-Muster. Dies ist eine veraltete Syntax und sollte nicht verwendet werden. In diesem Fall wird die Deklaration außerhalb des catch
-Blocks angehoben, aber ein innerhalb des catch
-Blocks zugewiesener Wert ist außerhalb nicht sichtbar.
try {
throw 1;
} catch (e) {
var e = 2; // Works
}
console.log(e); // undefined
Beispiele
Deklarieren und Initialisieren von zwei Variablen
var a = 0,
b = 0;
Zuweisung von zwei Variablen mit einer einzelnen Zeichenfolge
var a = "A";
var b = a;
Das 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 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, aber sein Wert ist undefined
. Daher erhält x
den Wert undefined
. Danach wird y
der Wert "A"
zugewiesen.
Initialisieren mehrerer Variablen
Seien Sie vorsichtig mit der Syntax var x = y = 1
– y
wird dabei nicht tatsächlich als Variable deklariert. y = 1
stellt eine nicht qualifizierte Bezeichnerzuweisung dar, die im Nicht-Strict-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!
Das gleiche Beispiel, aber im Strict-Modus:
"use strict";
var x = 0;
function f() {
var x = y = 1; // ReferenceError: y is not defined
}
f();
console.log(x, y);
Implizite globale Variablen und äußerer Funktionsbereich
Variablen, die wie implizite globale Variablen erscheinen, könnten Referenzen auf Variablen im ä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
Deklarationen mit Destructuring
Die linke Seite jedes =
kann auch ein Bindungsmuster sein, was ermöglicht, mehrere Variablen gleichzeitig zu erstellen.
const result = /(a+)(b+)(c+)/.exec("aaabcc");
var [, a, b, c] = result;
console.log(a, b, c); // "aaa" "b" "cc"
Weitere Informationen finden Sie unter Destructuring assignment.
Spezifikationen
Specification |
---|
ECMAScript® 2025 Language Specification # sec-variable-statement |
Browser-Kompatibilität
Report problems with this compatibility data on GitHubdesktop | mobile | server | ||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
var |
Legend
Tip: you can click/tap on a cell for more information.
- Full support
- Full support