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 enthalten sein, Firefox und Chrome unterstützen das, ich weiß aber nicht, ob das offiziell so ist und auf allen Plattformen funktioniert.

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 auswählen
1
2
3
      abcDEF_123 = 42;
      Äöß = "Hallo, Welt!";
      λ = 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 auswählen
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
      function a() { return 1000; }
      c = null;
      var d;
      e = 1;
      f = -3.5;
      g = "Hallo Welt";
      h = [e, f, g];
      i = true;
      j = document;
      k = Math;
      l = Math.cos;

      if (typeof m === 'undefined') console.log("m ist nicht deklariert.");
      
      console.log("a: ", typeof a);  // Ausgabe: function
      console.log("b: ", typeof b);  // Ausgabe: undefined
      console.log("c: ", typeof c);  // Ausgabe: object
      console.log("d: ", typeof d);  // Ausgabe: undefined
      console.log("e: ", typeof e);  // Ausgabe: number
      console.log("f: ", typeof f);  // Ausgabe: number
      console.log("g: ", typeof g);  // Ausgabe: string
      console.log("h: ", typeof h);  // Ausgabe: object
      console.log("i: ", typeof i);  // Ausgabe: boolean
      console.log("j: ", typeof j);  // Ausgabe: object
      console.log("k: ", typeof k);  // Ausgabe: object
      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 auswählen
1
2
3
4
5
6
7
8
9
      var a, b, c;  // mehrere Variablen deklarieren
      var d = 1, e = 2; f = 3;  // mehrere Variablen deklarieren und initialisieren
      console.log(a, b, c, d, e, f);

      g = h = i = 4;  // mehreren Variablen den gleichen Wert zuweisen
      console.log(g, h, i);

      const x = 123;
      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 auswählen
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
      function myFunction() {  // Subkontext 2
        var b = 22;
        let c = 33;
        console.log(a);  // 1, da global (überall) verfügbar und unverändert
        console.log(b);  // 22, da neu deklariert mit var
        console.log(c);  // 33, da neu deklariert mit let
        if (1 < 2) {  // Subkontext 3
          a     = 111;
          var b = 222;
          let c = 333;
          console.log(a);  // 111, da geändert
          console.log(b);  // 222, da neu deklariert mit var
          console.log(c);  // 333, da neu deklariert mit let
        }
        console.log(a);  // 111, da zuletzt in Subkontext 3 geändert und global (überall) verfügbar
        console.log(b);  // 222, da in Subkontext 3 mit var neu deklariert und offenbar in Subkontext 2 verfügbar
        console.log(c);  // 33, da in Subkontext 3 mit let neu deklariert und daher ohne Auswirkung auf Subkontext 2
      }
      // Kontext 1
      a     = 1;
      var b = 2;
      let c = 3;
      
      myFunction();
      
      console.log(a);  // 111, da zuletzt in Subkontext 3 geändert und global (überall) verfügbar
      console.log(b);  // 2, da zuletzt in Subkontext 3 mit var neu deklariert aber ohne Auswirkung auf Kontext 1
      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 auswählen
1
2
3
4
5
6
7
8
9
10
11
12
13
14
      summe = function() {
        /* Diese Funktion führt zu einer Fehlermeldung,
        weil die Variablen a, b und c nicht global sind. */
        return a + b + c;
      };
      
      {  // Beginn des Codeblocks
        let a = 10;
        let b = 5;
        let c = 200;
        
        out = summe();
        console.log("Summe: ", out);  // Summe: 215;
      }  // Ende des Codeblocks