Variablen und Konstanten

Variablen

Variablen helfen, in Programmen relevante „Werte“ wie z. B. bestimmte Zahlen oder „Zwischenergebnisse“ (z. B. von Berechnungen) mit Namen bzw. Bezeichnern auszustatten, sodass diese leicht wiederverwendet werden können.

Variablen werden mit dem Schlüsselwort let gefolgt von einem Name/Bezeichner deklariert:

// Deklaration von Variablen (noch ohne Wert/„Inhalt")
let myVariable;
let variable2;

Eine Variable, die ohne Wert deklariert wurde, hat automatisch den speziellen Wert undefined:

let myVariable;
console.log(myVariable);
 
undefined

Werden mehrere Variablen direkt nacheinander deklariert, so lassen sich diese auf einer Zeile mit , getrennt auflisten:

// Dies entspricht der vorigen Deklaration (s.o.)
let myVariable, variable2;

Mit einer Zuweisung erhält die Variable einen Wert. Nachfolgende Zuweisungen ändern den aktuellen Wert in der Variablen.

// myVariable ist der Name/Bezeichner der Variablen
// die Variable mit dem Namen myVariable wurde zuvor deklariert (s.o.)
// es folgt eine erste Zuweisung
myVariable = 1; // Wert der Variablen ist 1
	
// hier steht vielleicht eine ganz andere Berechnung...
	
// der Variablen wird ein neuer Wert zugewiesen
myVariable = 24; // Wert der Variablen ist nun 24
 
// Zuweisung der Variablen variable2
variable2 = "Hi!"; // Variablenwert ist der Text/String "Hi!"

Variablen haben einen Namen/Bezeichner, der nur einmal im Gültigkeitsbereich deklariert werden darf. Was genau der Gültigkeitsbereich ist, werden wir später bei Funktionen und Schleifen genauer sehen.

Reservierte Schlüsselwörter sind das „Vokabular“ einer Programmiersprache, die nicht für Bezeichner verwendet werden dürfen (z. B. let, function, class, usw.).

let class = "Schulklasse 8a"; // FEHLER!
// SyntaxError: wird durch Parsing erkannt und 
// verhindert die Ausführung des Programms
 
// --> Uncaught SyntaxError: unexpected token: keyword 'class'

Mehr zu möglichen Bezeichnern folgt weiter unten.

Die beiden Anweisungen zur Deklaration und der ersten Zuweisung eines Wertes an die Variablen lassen sich in eine Anweisung zusammenfassen. Dann sprechen wir von einer Initialisierung:

// Initialisierung: Deklaration und erste Zuweisung kombiniert
let myVariable = 1; 
Cannot redeclare block-scoped variable 'myVariable'.
	
// hier steht vielleicht eine ganz andere Berechnung...
	
// neuer Wert wird zugewiesen
myVariable = 24;
	
// FEHLER! 
// Variable darf nur einmal im 
// Gültigkeitsbereich deklariert werden!
let myVariable = 25;
Cannot redeclare block-scoped variable 'myVariable'.

Mehrere Initialisierungen können ähnlich wie Deklarationen durch Komma getrennt zusammengefasst werden:

let myVariable = 24, variable2 = "Hi!";

Mit der Methode console.log() können wir uns den Inhalt bzw. aktuellen Wert einer Variablen ausgeben lassen:

let myVariable = 24;
console.log('Wert von myVariable:', myVariable);
 
Wert von myVariable: 24
 
myVariable = 12;
console.log('Wert von myVariable:', myVariable);
 
Wert von myVariable: 12

Die Werte von Variablen sind sozusagen „zwischengespeichert“ und deshalb werden sie meistens mehrmals verwendet. Zum Beispiel kann der aktuelle Variablenwert auch in einer erneuten Zuweisung an dieselbe Variable genutzt werden.

let luckyNumber = 108; // Initialisierung
 
console.log(luckyNumber);
 
108		
 
// Variablen können sich ändern - daher ihr Name
luckyNumber = 123; // neue Zuweisung	
luckyNumber = luckyNumber + 7; // neue Zuweisung mit vorigem Wert
	
console.log(luckyNumber);
 
130

// Fehler zur Laufzeit, wenn nicht bekannte Variablen 
// verwendet werden	
console.log(thisVariableDoesNotExist); // ReferenceError

Konstanten

Konstanten sind vereinfacht gesagt „Variablen, die sich nicht ändern können“ — es darf also später keine neue Zuweisung erfolgen. Dadurch können wir „feste“ oder „unveränderliche“ Werte mit einem Namen/Bezeichner erhalten.

Konstanten werden mit dem Schlüsselwort const deklariert.

Konstanten müssen direkt bei der Deklaration mit einem Wert initialisiert werden, der danach im weiteren Verlauf des Programms unveränderlich (konstant) ist.

const answer = 42;
const unknownName = "John Doe";
 
// Fehler: Konstanten können nicht geändert werden!
answer = 23; // --> würde Fehler ergeben
 
// Fehler: Konstanten ohne Wert deklarieren
const notAllowed;

const list = [1, 2, 3];
list.push(4);      // funktioniert! list ist nun [1, 2, 3, 4]
list[0] = 99;      // funktioniert! list ist nun [99, 2, 3, 4]
 
list = [5, 6, 7];  // Fehler! Neue Zuweisung nicht erlaubt

Bezeichner und Namen

Bisher haben wir Variablen und Konstanten mit Namen wie myVariable oder answer versehen. Aber welche Namen sind in JavaScript eigentlich erlaubt?

Neben Variablen erstellen wir in JavaScript u.a. auch eigene Funktionen und Klassen, denen wir passende Namen geben.

Solche Namen werden auch Bezeichner genannt. Sie enthalten keine Leerzeichen.

Bezeichner können aus folgenden Elementen bestehen (d.h. mit diesen können wir passende Namen zusammensetzen):

• a,b,c, …,x,y,z,A,B,C, …,X,Y,Z (alle Buchstaben des Alphabets)
• 0,1,2,3, …,9 (Ziffern von 0 bis 9)
• _ (Unterstrich)
• $ (Dollarzeichen)

Bezeichner dürfen nicht mit einer Ziffer beginnen.

Zwischen Groß- und Kleinschreibung wird unterschieden (JavaScript ist also case sensitive). Also sind die Bezeichner Hallo und hallo verschieden und können für zwei unterschiedliche Variablen verwendet werden.

Schlüsselwörter dürfen nicht als Bezeichner verwendet werden.

Beispiele gültiger Bezeichner:

• Mein_Name
• _ein_Bezeichner
• Name_$123

Beispiele nicht zulässiger Bezeichner:

• 1Name
• Gibt's-nicht
• class

Variablennamen werden in JavaScript in der Regel in sogenannter CamelCase-Form formuliert, d.h. die Bezeichner beginnen mit einem kleinen Buchstaben und Teilbezeichnungen im Namen beginnen mit einem Großbuchstaben:

// Variablennamen in Camel Case
let theAnswer = 42;
let firstName = "Alice";
let anotherLongVariableName = "something";

Schlüsselwörter

In Programmiersprachen haben bestimmte „Vokabeln“ eine vordefinierte Bedeutung und dürfen nicht als Bezeichner verwendet werden. Deshalb nennt man diese (reservierte) Schlüsselwörter.

In JavaScript sind dies u.a. die folgenden:

break case catch class continue default do
else export extends for function if new
return static super switch this try while
…

Wir lernen deren Bedeutung zum Teil später kennen.

Ausdrücke

Auf der „rechten Seite” einer Zuweisung steht ein Ausdruck (expression). Das kann ein einfacher Wert sein (z. B. 42 oder "Hallo"), eine Berechnung (z. B. 10 + 5) oder ein Funktionsaufruf (z. B. Math.random()).

let a = 42;              // Wert
let b = 10 + 5;          // Berechnung
let c = Math.random();   // Funktionsaufruf

Mehr zu Ausdrücken erfahren wir bei Operatoren.

Zusammenfassung und Links