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;

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 der Variablen durch die Deklaration vergeben werden darf. Für Variablen ist der Gültigkeitsbereich oft die umgebende Funktion, eine Schleife (for oder while) oder Verzweigung (if/else) — diese werden später behandelt. Variablen dürfen nur einmal in ihrem Gültigkeitsbereich deklariert werden. Der Gültigkeitsbereich wird durch umgebende geschweifte Klammern mit einer „öffnenden“ Klammer { am Anfang und einer „schließenden“ Klammer } am Ende festgelegt.

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 = "Schulkasse 8a"; // Fehler!
// SyntaxError bei der Ausführung (zur Laufzeit)
 
// --> 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; 
	
// 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;

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:

console.log(myVariable); // ergibt 24
myVariable = 12;
console.log(myVariable); // ergibt 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);
		
// Variablen können sich ändern - daher ihr Name
luckyNumber = 123; // neue Zuweisung	
luckyNumber = luckyNumber + 7; // neue Zuweisung mit vorigem Wert
	
console.log(luckyNumber);
 
// 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;

Bezeichner und Namen

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 gültiger JavaScript-Ausdruck (expression).

Ausdrücke können einfache Werte der Variablen/Konstanten sein wie z.B. Zahlen (123) oder Text bzw. Strings ("Hello, World!"). Solche Werte, die direkt „hingeschrieben“ werden, werden manchmal „Literale“ genannt (von engl. literal — wörtlich).

Ausdrücke können aber auch durch komplexere Operatoren oder Rückgabewerte von Funktionsaufrufen hervorgehen (siehe später).

let x = 123.4;
let y = (2 + 5) * 12;
let z = "example";
	
// Hier verwenden wir die Methode Math.random()	
// JavaScript enthält viele Hilfsklassen und Methoden,
// mit denen wir viele Aufgaben direkt lösen können	
let number = Math.random();

Ausdrücken begegnen wir auch später im Zusammenhang mit Bedingungen in Fallunterscheidungen und Schleifen wieder.

Einerseits ist ein Ausdruck z.B. etwas „kleines“ oder atomares wie die Zahl 8 und andererseits können mehrere Ausdrücke miteinander kombiniert komplexere Ausdrücke ergeben wie z.B. 8 + 9 oder (Math.random() + 8 - 4) usw. Dies alles wird durch die formale Grammatik einer Programmiersprache festgelegt. In der praktischen Programmierung wird die Grammatik im Prinzip durch die konkrete Erfahrung und Übung erlernt.

Zusammenfassung und Links