Start · Sprachen · JavaScript · Referenz · Blockanweisung

Blockanweisung

Anweisung

Eine Blockanweisung gruppiert null oder mehr Anweisungen in einem einzigen syntaktischen Block, der durch geschweifte Klammern <code>{ }</code> begrenzt wird.

seit JavaScript ES1 Kategorie: syntax

Signatur

{ statement }

Beschreibung

Die Blockanweisung (auch zusammengesetzte Anweisung genannt) fasst beliebig viele JavaScript-Anweisungen in einem Paar geschweifter Klammern { } zusammen. Überall dort, wo die Sprachspezifikation eine einzelne Anweisung erwartet — etwa nach if, else, for, while oder try — kann stattdessen ein Block stehen, der mehrere Anweisungen enthält.

Seit ES2015 (ES6) definieren Blöcke zusammen mit let und const einen eigenen Block-Scope. Variablen, die mit let oder const innerhalb eines Blocks deklariert werden, existieren ausschließlich innerhalb dieses Blocks und sind von außen nicht erreichbar. var-Deklarationen hingegen ignorieren Block-Grenzen und werden auf den nächsten Funktions- oder globalen Scope angehoben (Hoisting).

Ein Block kann auch als eigenständige Anweisung — ohne begleitenden Kontrollfluss — genutzt werden, um logisch zusammengehörige Schritte zu kapseln und lokale let/const-Bindungen zu isolieren. Obwohl dies selten nötig ist, kann es in längeren Funktionen die Lesbarkeit und Wartbarkeit verbessern.

  • Ein leerer Block { } ist syntaktisch gültig und wird häufig als Platzhalter verwendet.
  • Blöcke sind keine Ausdrücke — sie haben keinen Rückgabewert und können nicht direkt einer Variablen zugewiesen werden.
  • Labels können einem Block vorangestellt werden (label: { }), um mit break label aus dem Block heraus zu springen.

Beispiele

Blockanweisung mit if/else

const temperatur = 18;

if (temperatur < 20) {
  // Beginn des Blocks
  const hinweis = 'Jacke mitnehmen';
  console.log(`Kalt! ${hinweis}`);
  // Ende des Blocks
} else {
  console.log('Schönes Wetter!');
}
Kalt! Jacke mitnehmen

Eigenständiger Block zur Scope-Isolation

let ergebnis = 0;

// Erster isolierter Block
{
  const faktor = 5;
  ergebnis += faktor * 2;
}

// Zweiter isolierter Block — faktor ist hier unbekannt
{
  const faktor = 10; // eigene Bindung, kein Konflikt
  ergebnis += faktor * 3;
}

console.log(ergebnis); // 5*2 + 10*3
40

Block mit Label und break

outer: {
  console.log('Vor dem break');
  break outer; // springt ans Ende des Blocks
  console.log('Diese Zeile wird nie erreicht');
}
console.log('Nach dem Block');
Vor dem break Nach dem Block

var vs. let im Block-Scope

{
  var altesStyle = 'sichtbar außerhalb'; // var ignoriert Block-Scope
  let modernesStyle = 'nur im Block';
}

console.log(altesStyle);       // funktioniert
try {
  console.log(modernesStyle); // ReferenceError
} catch (e) {
  console.log(e.message);
}
sichtbar außerhalb modernesStyle is not defined

// Wichtig · Fallstricke

Kein eigener Scope für var: Im Gegensatz zu let und const erzeugt ein Block für var-Deklarationen keinen eigenen Scope. var wird stets in den umgebenden Funktions- oder globalen Scope gehoben. Um unbeabsichtigte Namenskollisionen zu vermeiden, sollte var in modernem Code durch let oder const ersetzt werden.

Kein Semikolon nach dem schließenden }: Eine Blockanweisung endet mit } und benötigt kein abschließendes Semikolon — im Gegensatz zu Ausdrucksanweisungen. Ein irrtümlich gesetztes Semikolon ist zwar nicht syntaktisch falsch (es wird als leere Anweisung interpretiert), kann aber bei Anfängern zu Verwirrung führen.

Strict Mode: Funktionsdeklarationen innerhalb von Blöcken verhalten sich im Strict Mode ('use strict') konsistenter: Sie sind block-scoped. Im Sloppy Mode ist dieses Verhalten implementierungsabhängig und sollte vermieden werden.