Bitte warten...

JavaScript: Variablen und Datentypen

Variablen und Konstanten werden mit einem Namen bezeichnet, der aus den Buchstaben az und AZ sowie aus den Ziffern 09 und dem Unterstrich _ bestehen kann. Groß- und Kleinschreibung wird unterschieden. Der Name darf nicht mit einer Zahl beginnen, Schlüsselwörter aus JavaScript sind nicht erlaubt. Umlaute, ß und griechische Buchstaben können ebenfalls enthalten sein.

Im Beispiel wird der Variable abcDEF_123 der Wert Hallo Welt zugewiesen. Die Zuweisung erfolgt mit dem Operator =. Anweisungen werden in JavaScript mit einem Semikolon ; beendet.

Code kopieren
  1. abcDEF_123 = 42;
  2. Äöß = "Hallo, Welt!";
  3. λ = 123;

Datentypen

► JavaScript-Referenz: typeof console.log() console.clear()

Entsprechend dem zugewiesenen Wert erhält jede Variable einen bestimmten Datentyp, der festlegt, welche Operationen mit diesem Wert möglich sind. Der Datentyp einer Variable kann sich im Verlauf des Programms ändern, beispielsweise wenn sie eine Zeichenkette zugewiesen bekommt, während sie zuvor eine Zahl enthielt.

In JavaScript existieren fünf Datentypen, die mit dem Operator typeof ermittelt werden können:

numberZahlen
stringZeichenketten
booleanWahrheitswerte
functionFunktionen
object – Objekte

Ist der Datentyp unbestimmbar, wird undefined zurückgegeben. Nicht deklarierte Variablen sind undefined, daher kann so auch geprüft werden, ob eine Variable deklariert wurde.

Mit der Methode console.log() können Ausgaben in die Web-Konsole geschrieben werden. Die Konsole ist in den Entwicklerwerkzeugen des Browsers zu finden und kann über die Taste F12 angezeigt werden. Es können mehrere Argumente komma-separiert übergeben werden, die dann in einer Zeile geschrieben werden. Mit der Methode console.clear() kann die Konsole wieder geleert werden.

Code kopieren
  1. function a() { return 1000; }
  2. c = null;
  3. var d;
  4. e = 1;
  5. f = -3.5;
  6. g = "Hallo Welt";
  7. h = [e, f, g];
  8. i = true;
  9. j = document;
  10. k = Math;
  11. l = Math.cos;
  12. if (typeof m === 'undefined') console.log("m ist nicht deklariert.");
  13. console.log("a: ", typeof a); // Ausgabe: function
  14. console.log("b: ", typeof b); // Ausgabe: undefined
  15. console.log("c: ", typeof c); // Ausgabe: object
  16. console.log("d: ", typeof d); // Ausgabe: undefined
  17. console.log("e: ", typeof e); // Ausgabe: number
  18. console.log("f: ", typeof f); // Ausgabe: number
  19. console.log("g: ", typeof g); // Ausgabe: string
  20. console.log("h: ", typeof h); // Ausgabe: object
  21. console.log("i: ", typeof i); // Ausgabe: boolean
  22. console.log("j: ", typeof j); // Ausgabe: object
  23. console.log("k: ", typeof k); // Ausgabe: object
  24. console.log("l: ", typeof l); // Ausgabe: function

Deklaration und Initialisierung

► JavaScript-Referenz: var let const

Bei der Deklaration einer Variable wird diese im Programmablauf eingeführt, es muss keine Wertzuweisung erfolgen, daher ist der Datentyp zunächst unbestimmt.

Bei der Initialisierung wird einer Variable ein Anfangswert und damit auch ein Datentyp zugewiesen. Eine Variable kann erst verwendet werden, wenn sie initialisiert ist, ansonsten kommt es zu einer Fehlermeldung in der Konsole und damit zu einem Programmabbruch. Initialisierte Variablen sind automatisch deklariert.

Mit dem Schlüsselwort const werden Konstanten deklariert. Die Werte einer Konstante sind unveränderbar. Ansonsten verhalten sie sich, als wären sie mit let deklariert.

Code kopieren
  1. var a, b, c; // mehrere Variablen deklarieren
  2. var d = 1, e = 2; f = 3; // mehrere Variablen deklarieren und initialisieren
  3. console.log(a, b, c, d, e, f);
  4. g = h = i = 4; // mehreren Variablen den gleichen Wert zuweisen
  5. console.log(g, h, i);
  6. const x = 123;
  7. x++; // führt zu einem Fehler, da Konstanten unveränderbar sind

In JavaScript gibt es nun drei verschiedene Geltungsbereiche von Variablen, je nachdem, ob sie mit var, let oder implizit durch Wertzuweisung deklariert wurden.

Code kopieren
  1. function myFunction() { // Subkontext 2
  2. var b = 22;
  3. let c = 33;
  4. console.log(a); // 1, da global (überall) verfügbar und unverändert
  5. console.log(b); // 22, da neu deklariert mit var
  6. console.log(c); // 33, da neu deklariert mit let
  7. if (1 < 2) { // Subkontext 3
  8. a = 111;
  9. var b = 222;
  10. let c = 333;
  11. console.log(a); // 111, da geändert
  12. console.log(b); // 222, da neu deklariert mit var
  13. console.log(c); // 333, da neu deklariert mit let
  14. }
  15. console.log(a); // 111, da zuletzt in Subkontext 3 geändert und global (überall) verfügbar
  16. console.log(b); // 222, da in Subkontext 3 mit var neu deklariert und offenbar in Subkontext 2 verfügbar
  17. console.log(c); // 33, da in Subkontext 3 mit let neu deklariert und daher ohne Auswirkung auf Subkontext 2
  18. }
  19. // Kontext 1
  20. a = 1;
  21. var b = 2;
  22. let c = 3;
  23. myFunction();
  24. console.log(a); // 111, da zuletzt in Subkontext 3 geändert und global (überall) verfügbar
  25. console.log(b); // 2, da zuletzt in Subkontext 3 mit var neu deklariert aber ohne Auswirkung auf Kontext 1
  26. console.log(c); // 3, da in Subkontexten 2 und 3 mit let neu deklariert und daher ohne Auswirkung auf Kontext 1

Grundsätzlich kann man sagen, dass Variablen, die implizit durch Wertzuweisung deklariert wurden, global verfügbar sind, also überall im Programm gelten.

Variablen, die mit let deklariert wurden, gelten nur in dem Kontext-Block (von geschweiften Klammern {} umschlossen), in dem die Deklaration stattgefunden hat und in untergeordneten Blöcken. Also beispielsweise in Funktionen oder in Blöcken, die von Bedingungen abhängen. Außerhalb dieser Blöcke sind diese Variablen nicht verfügbar, sie können aus diesen Blöcken also nicht „ausbrechen“.

Variablen, die mit var deklariert wurden, sind zwar offenbar auch außerhalb von Blöcken verfügbar, die von Bedingungen abhängen, aber nicht außerhalb von Funktionen, wenn sie innerhalb deklariert wurden.

Unabhängig von der Art der Deklaration sind Variablen immer in untergeordneten Blöcken verfügbar, sie können also automatisch in diese Blöcke „eindringen“.

Ob man von diesen unterschiedlichen Arten der Deklaration mit den entsprechenden Konsequenzen Gebrauch macht, muss man im Einzelfall selbst entscheiden. Dabei ist es wichtig, nicht den Überblick zu verlieren, welche Variablen auf welche Weise deklariert wurden, da dann eben auch die Geltungsbereiche unterschiedlich sein können.

Ich persönlich finde das eher verwirrend und habe mich dazu entschieden, auf var und let ganz zu verzichten. Dafür muss ich dann im Auge behalten, welche Variablennamen ich bereits verwendet habe.

Möchte man verhindern, dass Variablen global verfügbar sind, muss man sie in einem Codeblock (in geschweiften Klammern) mit let deklarieren:

Code kopieren
  1. summe = function() {
  2. /* Diese Funktion führt zu einer Fehlermeldung,
  3. weil die Variablen a, b und c nicht global sind. */
  4. return a + b + c;
  5. };
  6. { // Beginn des Codeblocks
  7. let a = 10;
  8. let b = 5;
  9. let c = 200;
  10. out = summe();
  11. console.log("Summe: ", out); // Summe: 215;
  12. } // Ende des Codeblocks