Lokale Blockkonstanten in JavaScript 

Eine in einem Block deklarierte Konstante ist ein lokale Blockkonstante  (oder kurz „lokale Konstante “ oder „Blockkonstante “).

Eine Blockkonstante

{ const a = 2; }

Für lokale Blockkonstanten gilt alles zuvor über Konstanten Gesagte, abgesehen von den im folgenden genannten Unterschieden.

Kommandos

Eine Konstantendeklaration ist keine Anweisung, sondern ein Kommando  (ECMAScript 2016, 13.2 “StatementListItem ”).

Ein Kommando  ist eine Anweisung oder eine Deklaration.

Eine Sequenz  ist eine Folge von Kommandos (Eine Sequenz mit 0 Kommandos ist die Nullsequenz, eine Sequenz mit einem Kommando ist einfach ein einzelnes Kommando.).

Wir hatten den Begriff „Sequenz“ bisher für eine Folge von Anweisungen verwendet, und erweitern ihn nun um Deklarationen, indem wir ihn nun als eine Folge von Kommandos  verstehen.

Ein Skript ist eine Sequenz, aber eine Sequenz muß umgekehrt kein vollständiges Skript sein, sondern kann auch ein Teil eines umfangreicheren Skripts sein.

Der Inhalt eines Blocks oder eines Skripts ist eine Sequenz.

(“Script ” wird definiert in ECMAScript 2016 15.1.)

Globale Konstanten

Die zuvor von uns außerhalb eines Block deklarierten Konstanten nennen wird jetzt zur besseren Unterscheidung von den Blockkonstanten auch globale Konstanten.

Die globalen Konstanten existiert in einer „lexikalischen Umgebung“ und nicht im globalen Objekt. Daher kann eine globale Konstante, wie »x«, nicht mit »this.x« erreicht werden, sondern höchstens mit »x« alleine.

(Die Fachbezeichnung für die „globale lexikalische Umgebung“ lautet “global environment's declarative environment record ”.)

Der Gültigkeitsbereich

Eine Blockkonstante kann nur innerhalb des Blocks verwendet werden, der ihre Deklaration direkt enthält.

Eine Blockkonstante

{ { const a = 2; } /* hier kann a nicht mehr verwendet werden */ }

Zwei Konstanten in einander nicht überlappenden Gültigkeitsbereichen können denselben Namen haben.

Zwei Blockkonstanten

{ { const a = 2; console.log( a ); }
  { const a = 7; console.log( a ); }}

Ausgabe

2
7

Sprechende Namen (mnemonische Namen)

Da keine Kollisionen mit globalen Einträgen zu befürchten sind, können wir jetzt für die Konstanten auch längere, sprechende (verständliche) Namen verwenden.

ℛ  Stilregel Für eine lokale Konstante sind Namen zu bevorzugen, welche die Bedeutung jener Konstanten auf verständliche Weise erklären. Dabei sollten sie nicht zu lang sein.

Es gilt als schlechter Stil, einen unverständlichen Namen zu wählen, selbst wenn dieser durch einen Kommentar erklärt wird.

Schlechter Stil

{ const m = 19; /* Mehrwertsteuersatz */ }

Es gilt als guter Stil, einen verständlichen Namen zu wählen.

Guter Stil

{ const Mehrwertsteuersatz = 19; }

Die Existenzdauer

Wenn ein Block ausgewertet wird und eine seiner Konstantendeklaration ausgewertet wurde, so beginnt damit die Existenzdauer einer Inkarnation der deklarierten Konstanten für diese Auswertung jenes Blocks. Die Existenzdauer endet mit dem Ende jenes Blocks.

Der Begriff der Existenzdauer ähnelt dem des Gültigkeitsbereiches, jedoch ist der Gültigkeitsbereich ein Teil des Quelltextes während die Existenzdauer ein Teil der Auswertungszeit ist. (Zudem kann es sein, daß mehrere Inkarnationen derselben Konstanten gleichzeitig existieren, wenn derselbe Block bei einer Rekursion mehrfach betreten wird, ohne beendet worden zu sein. Ein Beispiel hierfür findet sich in einem Sternchen-Abschnitt am Ende dieser Lektion.

Der verbotene Bereich

Wenn eine Konstante in einem Block deklariert wird, so darf sie in diesem Block vor der Stelle ihrer Deklaration nicht  verwendet werden.

Konsolenprotokoll

{ console.log( c ); const c = 2; } 
ReferenceError: can't access lexical declaration `c' before initialization

Verdeckung

Eine Konstantendeklaration gilt immer für den gesamten sie direkt enthaltenden Block, selbst für die Teile des Blocks, die ihr vorangehen.

Eine globale Konstante ist in einem Block normalerweise sichtbar (das heißt, sie kann darin verwendet werden). Wird aber im Block eine gleichnamige lokale Konstante angelegt so verdeckt sie die globale Konstante in diesem Block.

Ein Skript

"use strict";
const c = 2;
{ /* die globale Konstante c ist sichtbar */
  console.log( c ); /* Ausgabe: 2 */ } 
{ /* hier ist console.log( c ) verboten */
  const c = 3; /* die globale Konstante c ist verdeckt */
  console.log( c ); /* Ausgabe: 3 */ } 

Konstanten und Parameter

Im äußersten Block einer Funktion darf keine Konstante deklariert werden, deren Namen dem Namen eines Parameters jener Funktion gleicht.

Konsolenprotokoll

f = x=>{ const x = 2; } 

TypeError: redeclaration of formal parameter x

f = x=>{ { const x = 2; } } 

function f()

Verschachtelte Blöcke

Unter einem „Bereich“ verstehen wir hier einen Block oder den globalen Bereich, der die Skriptteile umfaßt, die in gar keinem Block enthalten sind.

Wenn ein Name in einem Bereich verwendet wird, so bezieht dieser sich auf die erste Deklaration, die man erreicht, indem man von diesem Bereich aus in weiter außen liegende Blöcke geht und dort nach einer Deklaration jenes Namens sucht. Findet man keine Deklaration auf diese Weise, so bezieht sich der Name auf eine globale Eigenschaft.

Ein Skript

"use strict";
{ const c = 2; 
  console.log( c ); /* Ausgabe: 2 */ } 

Ein Skript (1)

"use strict";
{ const c = 2; 
  { console.log( c ); /* Ausgabe: 2 */ }} 

Ein Skript (2)

"use strict";
{ const c = 2; 
  { const c = 3; 
    console.log( c ); /* Ausgabe: 3 */ } 
  console.log( c ); /* Ausgabe: 2 */ } 

Vorteile lokaler Konstanten

In einem großen Skript kann es bei Verwendung globaler Konstanten unklar sein, welche Konstanten schon definiert wurden und ob ein bestimmter Name schon verwendet wurde. Werden statt dessen lokale Konstanten mit möglichst kleinem Gültigkeitsbereich verwendet, so wird die Situation übersichtlicher.

ℛ  Stilregel Der Gültigkeitsbereich eines Bezeichners sollte immer so klein wie möglich sein, insbesondere sind lokale Konstanten gegenüber globalen Konstanten zu bevorzugen.

Mehrere Inkarnationen einer Blockkonstanten *

In dem folgenden Skript existieren vier Inkarnationen der Blockkonstanten »c« gleichzeitig und enthalten jeweils unterschiedliche Werte.

Wenn »f0« sich selbst aufruft, bleibt die Inkarnation der Konstanten »c« in der aufrufenden Funktion erhalten, während in der aufgerufenen Funktion eine neue Inkarnation derselbe Konstanten angelegt wird, die wieder einen eigenen Wert haben kann.

Skript

"use strict";
const f0 = ( x )=> 
{ "use strict"; 
  console.group( "f0" );
  const c = x; 
  console.log( "c = " + c ); 
  eval( "f" + Math.floor( x/3 )+ "( x + 1 )" ); 
  console.log( "c = " + c ); 
  console.groupEnd(); };
const f1 = ( x )=> console.trace();
f0( 0 );

Ausgabe

f0
c = 0
  f0
  c = 1
    f0
    c = 2
      f0
      c = 3
        console.trace():
        f1()
        f0()
        f0()
        f0()
        f0()
      c = 3
    c = 2
  c = 1
c = 0

Die Konstante »c« wurde oben nur verwendet, weil die Inkarnation einer Blockkonstanten gezeigt werden sollte. Ansonsten könnte man dasselbe auch ohne eine Konstanten programmieren.

Skript

"use strict";
const f0 = ( x )=> 
{ console.group( "f0" );
  console.log( "x = " + x ); 
  eval( "f" + Math.floor( x/3 )+ "( x + 1 )" ); 
  console.log( "x = " + x ); 
  console.groupEnd(); };
const f1 = ( x )=> console.trace();
f0( 0 );

Deklarationen in »eval«

Der Wert der eval-Auswertung einer Sequenz ist der Wert des letzten ausgewerteten Ausdrucks einer Auswertungsanweisung. Deklarationen und leere Blöcke werden dabei nicht berücksichtigt.

Konsole

eval( "2; const b = 3;" )

2

Falls auf diese Weise kein Wert erhalten werden kann, so ergibt »eval« »undefined«.

Konsole

eval( "const b = 3;" )

undefined

Deklarationen in »eval« haben ihren eigenen Gültigkeitsbereich, ähnlich wie ein einem Block.

Konsole

eval( "const b = 3; console.log( b );" )

3

Konsole

eval( "const g = 3;" ); console.log( g );

ReferenceError: g is not defined