mitmario.dev

Gültigkeitsbereich

JavaScript Im Browser 4 Min Lesezeit 5 BeispieleLektion 6 von 9

Ein Name steht drei Zeilen weiter oben, und trotzdem meldet die Console i is not defined. Dahinter steckt fast immer der Gültigkeitsbereich (englisch scope), also die Frage, wo ein Name gilt.

Der Block ist die Grenze

Was im Block bleibt, bleibt im Block
const draussen = "überall sichtbar";

if (true) {
  const drinnen = "nur im if";
  console.log("Im Block sehe ich:", draussen, "und", drinnen);
}

console.log("Außerhalb sehe ich:", draussen);

// Der Zähler einer Schleife gehört ebenfalls in ihren Block.
for (let i = 1; i <= 3; i++) {
  console.log("i in der Schleife:", i);
}

// Diese Zeile ist der Grund für die Fehlermeldung darunter,
// denn i gibt es hier nicht mehr.
console.log("i nach der Schleife:", i);

Ein Block sind zwei geschweifte Klammern und alles dazwischen. Das kann der Rumpf einer Funktion sein, einer Schleife oder eines if, oder auch nur ein Paar Klammern für sich allein.

Einen Namen, der mit let oder const in einem Block entsteht, gibt es nur in diesem Block. Danach ist der Name weg, als hätte es ihn nie gegeben. Benutzt du ihn trotzdem, bekommst du einen ReferenceError, im Beispiel in der letzten Zeile.

Der Zähler einer Schleife gehört deshalb in die Schleife. Nach der letzten Runde gibt es ihn nicht mehr. Das klingt nach einer Einschränkung und ist eine Erleichterung, denn ein Name, der nur dort existiert, wo er gebraucht wird, kann nirgendwo sonst etwas kaputt machen.

Innen sieht nach außen

Innen sieht nach außen
const mehrwertsteuer = 1.19;

function mitSteuer(nettoInCent) {
  // nettoInCent kennt nur diese Funktion, mehrwertsteuer kommt von außen.
  const bruttoInCent = Math.round(nettoInCent * mehrwertsteuer);
  return bruttoInCent;
}

console.log(mitSteuer(1000));

// Dieselbe Suche noch eine Ebene tiefer.
function aussen() {
  const stufe = "außen";

  function innen() {
    console.log("innen sieht:", stufe);
  }

  innen();
}

aussen();

Die Sichtbarkeit geht nur in eine Richtung. Von innen nach außen sieht eine Funktion alles, was um sie herum steht. Findet JavaScript einen Namen nicht im aktuellen Block, schaut es eine Ebene höher, dann noch eine, bis ganz nach oben. Erst wenn er nirgends steht, gibt es einen ReferenceError.

Von außen nach innen geht es nicht. Was in einer Funktion angelegt wurde, ist außerhalb nicht zu sehen. Sonst könnten zwei Funktionen mit einer Variable namens ergebnis nicht nebeneinander stehen.

Wegen dieser Suche nach oben kannst du Funktionen benutzen, ohne ihnen alles einzeln zu übergeben. Sie ist aber auch der Grund, warum eine Variable ganz oben in der Datei von überall aus erreichbar und veränderbar ist, und deshalb lege ich dort so wenig wie möglich ab.

Der Gültigkeitsbereich als Liste

Der Gültigkeitsbereich ist das abstrakteste Thema dieses Abschnitts. Im Reiter Debug steht er schwarz auf weiß da, denn an jeder Zeile wird gemeldet, welche Namen dort sichtbar sind.

In der Aufzeichnung des Beispiels „Innen sieht nach außen“ stehen in der Zeile const bruttoInCent = Math.round(nettoInCent * mehrwertsteuer) zwei Namen in der Liste, mehrwertsteuer von ganz oben und nettoInCent aus dem Parameter. Eine Zeile weiter kommt bruttoInCent dazu. Sobald die Funktion fertig ist, sind nettoInCent und bruttoInCent wieder weg, und nur mehrwertsteuer steht noch da.

In der inneren Funktion des zweiten Blocks stehen beide, mehrwertsteuer und stufe. Das ist die Suche nach oben als Liste. An keiner Zeile außerhalb steht dagegen ein Name, der drinnen entstanden ist. Auswendig lernen musst du das nicht, ein paarmal ansehen reicht meistens.

Was var anders macht

Was var anders macht
if (true) {
  var mitVar = "kennt keine Blöcke";
  let mitLet = "kennt Blöcke";
  console.log("Im Block:", mitVar, "und", mitLet);
}

// var ist hier draußen weiterhin da. Genau das ist das Problem:
// eine Variable steht plötzlich an Stellen, an denen sie nichts
// zu suchen hat.
console.log("Nach dem Block:", mitVar);

// Noch deutlicher in einer Schleife. Der Zähler überlebt sie.
for (var j = 1; j <= 3; j++) {
  // nichts zu tun
}

console.log("j nach der Schleife:", j);

var ist die alte Art, eine Variable anzulegen, und sie kennt nur Funktionen als Grenze, keine Blöcke. Eine Variable, die mit var in einem if oder einer Schleife entsteht, ist danach immer noch da. Sie ist sogar schon davor da, dann mit dem Wert undefined. Beides führt zu Fehlern, die schwer zu finden sind, denn an der Stelle, an der es knallt, sieht der Code völlig richtig aus.

In diesem Kurs kommt var deshalb nicht vor. In älterem Code begegnet es dir noch, und jetzt weißt du, worauf du dann achten musst. Geschrieben wird es nie. const für alles, was sich nicht ändert, let für den Rest.

Vor der eigenen Zeile

Vor der eigenen Zeile
// Eine Funktionsdeklaration ist schon vor ihrer eigenen Zeile da.
console.log("Aufruf von oben:", frueh());

function frueh() {
  return "geht";
}

// Bei const und let ist das anders. Der Name existiert zwar schon,
// benutzbar ist er aber erst ab seiner Zeile.
const spaet = "steht erst hier";
console.log("Nach der Zeile:", spaet);

// Diese Zeile steht bewusst am Ende, denn sie bricht ab: der Zugriff
// liegt vor der Zeile mit const.
console.log(nochNichtDa);
const nochNichtDa = "zu spät";

Eine Funktionsdeklaration lässt sich aufrufen, bevor sie in der Datei steht. JavaScript liest die Datei vorher einmal durch und legt alle Funktionsdeklarationen an, bevor die erste Zeile läuft. Das nennt man Hoisting.

Bei const und let ist es anders. Der Name existiert zwar von Anfang an, benutzbar ist er aber erst ab seiner Zeile. Dazwischen liegt die temporale Totzone (englisch temporal dead zone), und ein Zugriff darin ist ein ReferenceError. Chrome schreibt dazu Cannot access 'nochNichtDa' before initialization, Firefox can't access lexical declaration 'nochNichtDa' before initialization. Auf Deutsch heißt das etwa „kein Zugriff vor der Zeile mit const“.

Ich schreibe Namen einfach vor ihre Verwendung, dann spielt keine dieser Regeln eine Rolle.

Die Closure

Die innere Funktion behält, was sie umgibt
function baueKasse() {
  let summe = 0;

  return function (betragInCent) {
    summe = summe + betragInCent;
    return summe;
  };
}

const ersteKasse = baueKasse();
console.log(ersteKasse(250), ersteKasse(120), ersteKasse(300));

// Eine zweite Kasse hat ihre eigene Summe und fängt bei 0 an.
const zweiteKasse = baueKasse();
console.log("Die zweite kassiert:", zweiteKasse(500));
console.log("Die erste kassiert weiter:", ersteKasse(80));

// An summe kommt von außen niemand heran. Es gibt keinen Namen
// dafür, außer innerhalb der zurückgegebenen Funktion.
console.log("Von außen sichtbar:", typeof summe);

Eine innere Funktion sieht, was sie umgibt. Und zwar auch dann noch, wenn die äußere Funktion längst fertig ist. Sie nimmt ihre Umgebung sozusagen mit, und damit wird aus dem Gültigkeitsbereich ein Werkzeug.

Im Beispiel legt baueKasse bei jedem Aufruf eine frische summe an und gibt eine Funktion zurück, die darauf zugreift. Jede gebaute Kasse hat damit ihre eigene Summe. Von außen kommt niemand heran, weil es keinen Namen dafür gibt.

Das nennt man eine Closure. Sie ist der übliche Weg, wenn sich etwas über mehrere Aufrufe hinweg etwas merken soll, ohne dass es allen gehört.

In der Console stehen nur die Ergebnisse, in der Aufzeichnung siehst du mehr. Die Zeile summe = summe + betragInCent läuft fünfmal, für zwei verschiedene Kassen. Beim vierten Mal steht dort summe=0, beim fünften summe=670. Zwei Speicher hinter einer Codezeile, und keiner hat einen Namen, unter dem man ihn von außen erreichen könnte. Deshalb steht in der letzten Zeile des Beispiels undefined.

In der Aufgabe zählen zwei Zähler auf demselben Stand weiter, und jeder soll seinen eigenen bekommen.

Zum Mitnehmen

Ein Name aus let oder const lebt nur in seinem Block, und gesucht wird immer von innen nach außen. Eine Closure ist eine innere Funktion, die ihre Umgebung mitnimmt und auch nach dem Ende der äußeren noch darauf zugreift.

Jetzt du

Basis Konto, kostenlos

Zu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.

Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.

Was in dieser Lektion steckt

  • Artikel mit 5 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe im Editor, direkt im Browser geprüft

    Öffnet sich mit dem Basis Konto.