let

Zusammenfassung

Das Schlüsselwort let deklariert eine Variable im Gültigkeitsbereich des lokalen Blocks. Optional wird die Variable mit einem Wert initialisiert.

Syntax

let var1 [= wert1] [, var2 [= wert2]] [, ..., varN [= wertN]];

Parameter

var1, var2, …, varN

Variablenname. Jeder legale Bezeichner ist erlaubt.

wert1, wert2, …, wertN

Initialwert der Variablen. Jeder legale Ausdruck ist erlaubt.

Beschreibung

let ermöglicht es Variablen zu deklarieren, deren Gültigkeitsbereich auf den Block, den Befehl oder den Ausdruck beschränkt ist, in dem sie deklariert sind. Der Unterschied zum var-Schlüsselwort ist, dass der Gültigkeitsbereich auf Blöcke und nicht auf Funktionen beschränkt ist.

Blocksichtbarkeitsbereich mit let

Das let-Schlüsselwort wird genutzt, um eine Variable in einem Block zu definieren.

if (x > y) {
  let gamma = 12.7 + y;
  i = gamma * x;
}

Man kann let einsetzten, um Pseudonamensräumen einen neuen Namen zu geben. (Siehe Security best practices in extensions.)

let Cc = Components.classes, Ci = Components.interfaces;

let macht den Programmcode manchmal leserlicher, wenn innere Funktionen eingesetzt werden.

var list = document.getElementById("list");

for (var i = 1; i <= 5; i++) {
  var item = document.createElement("LI");
  item.appendChild(document.createTextNode("Item " + i));

  let j = i;
  item.onclick = function (ev) {
    console.log("Item " + j + " is clicked.");
  };
  list.appendChild(item);
}

Dieses Beispiel funktioniert wie intendiert, weil alle fünf Instanzen der anonymen inneren Funktionen auf verschiedene Instanzen der Variable j zugreifen. Wenn stattdessen var verwendet wird oder in der inneren Funktion statt j zu deklarieren i benutzt wird, funktioniert dies nicht.

Regeln für Gültigkeitsbereiche

Variablen, die mit let deklariert werden, haben als Gültigkeitsbereich den Block in dem sie definiert wurden und alle weiteren Unterblöcke in denen sie nicht neu definiert werden. In dieser Hinsicht funktioniert let ähnlich wie var. Der Unterschied besteht darin, dass der Gültigkeitbereich bei var-deklarierten Variablen die umschließende Funktion ist:

function varTest() {
  var x = 31;
  if (true) {
    var x = 71;  // gleiche Variable!
    console.log(x);  // 71
  }
  console.log(x);  // 71
}

function letTest() {
  let x = 31;
  if (true) {
    let x = 71;  // andere variable
    console.log(x);  // 71
  }
  console.log(x);  // 31
}

Auf der ersten Ebene des Programmes oder von Funktionen funktioniert let exakt wie var. Zum Beispiel:

var x = 'global';
let y = 'global';
console.log(this.x); //global
console.log(this.y); //global

Zeitweilig tote Zonen und Fehler mit let

Eine wiederholte Deklaration einer Variablen im gleichen Blockgültigkeitsbereich führt zu einem TypeError.

if (x) {
  let foo;
  let foo; // TypeError
}

Funktionen besitzten diese Einschränkung nicht!

function do_something() {
  let foo;
  let foo; // Funktioniert fehlerfrei.
}

In ECMAScript 6, werden Deklarationen mit let nicht an den Anfang des Blocks verschoben (hoist). Wird eine Variable vor der Deklaration in einem Block referenziert, führt dies zu einem ReferenceError, weil sich die Variable bei Eintritt in den Block bis zur Verarbeitung der Deklaration in einer "zeitweilig toten Zone" (temporal dead zone) befindet.

function do_something() {
  console.log(foo); // ReferenceError
  let foo = 2;
}

Ein switch-Block besteht nur aus einem Block, so dass Fehler wie im folgenden Beispiel auftreten können.

switch (x) {
  case 0:
    let foo;
    break;
    
  case 1:
    let foo; // TypeError
    break;
}

Gültigkeitsbereich für let-Variablen in for-Schleifen

Mit let können Schleifenvariablen auf den Gültigkeitsbereich von for-Schleifen beschränkt werden. Der Unterschied zum Einsatz einer var-Variablen ist, dass diese nicht für die ganze Funktion sichtbar wird, in der die Schleife auftritt.

var i=0;
for ( let i=i ; i < 10 ; i++ ) {
  console.log(i);
}

Sichtbarkeitsregeln

for (let expr1; expr2; expr3) statement

Hier befinden sich expr2, expr3 und statement in einem impliziten Block, der die Variable expr1 enthält. Diese Variable wurde mit let deklariert und ist deswegen nur in diesem Block sichtbar. Das darüberstehende Beispiel demonstriert dies.

Beispiele

let vs var

Beim Einsatz von let in einem Block wird der Sichtbarkeitsbereich der Variablen auf den Block beschränkt. Beachte den Unterschied zu var-Variablen, deren Gültigkeitsbereich die Funktion ist, in der sie deklariert wurden.

var a = 5;
var b = 10;

if (a === 5) {
  let a = 4; // Gültigkeitsbereich im if-Block
  var b = 1; // Gültigkeitsbereich in der Funktion

  console.log(a);  // 4
  console.log(b);  // 1
} 

console.log(a); // 5
console.log(b); // 1

let in Schleifen

Man kann das let-Schlüsselwort nutzen, um Variablem für den lokalen Block der Schleife zu definieren. Dabei entsteht keine globale Variable wie bei dem einsatz von var-Deklarationen.

for (let i = 0; i<10; i++) {
  console.log(i); // 0, 1, 2, 3, 4 ... 9
}

console.log(i); // i ist nicht definiert.

Nicht standardisierte let-Erweiterungen

let block

The let block provides a way to associate values with variables within the scope of a block, without affecting the values of like-named variables outside the block.

Syntax

let (var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN]]) statement;

Description

The let block provides local scoping for variables. It works by binding zero or more variables in the lexical scope of a single block of code; otherwise, it is exactly the same as a block statement. Note in particular that the scope of a variable declared inside a let block using var is still the same as if it had been declared outside the let block; such variables still have function scoping. When using the let block syntax, the parentheses following let are required. Failure to include them will result in a syntax error.

Example

var x = 5;
var y = 0;

let (x = x+10, y = 12) {
  console.log(x+y); // 27
}

console.log(x + y); // 5

The rules for the code block are the same as for any other code block in JavaScript. It may have its own local variables established using the let declarations.

Scoping rules

The scope of variables defined using let is the let block itself, as well as any inner blocks contained inside it, unless those blocks define variables by the same names.

let expressions

The let expression lets you establish variables scoped only to a single expression.

Syntax

let (var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN]]) expression;

Example

You can use let to establish variables that are scoped only to a single expression:

var a = 5;
let(a = 6) console.log(a); // 6
console.log(a); // 5

Scoping rules

Given a let expression:

let (decls) expr

There is an implicit block created around expr.

Specifications

Browser compatibility

Firefox-specific notes

• [1]: Only available to code blocks in HTML wrapped in a <script type="application/javascript;version=1.7"> block (or higher version). XUL script tags have access to these features without needing this special block. See Bug 932517 and Bug 932513.
• ES6 compliance for let in SpIderMonkey is tracked in Bug 950547 and non-standard extensions are going to be removed in the future Bug 1023609.

See also

• var
• const