Bool'sche Werte und Datentypen – Programmieren lernen mit JavaScript – Thytos
Nächstes Video startet in 3 Sekunden.
Programmieren lernen mit JavaScript

Bool'sche Werte und Datentypen

In Pro­gramm­code wird oft ent­schie­den, wel­che An­wei­sung aus­ge­führt wird, in­dem Wer­te ver­gli­chen wer­den. Das Er­geb­nis der Ver­glei­che sind Bool'sche Werte.

Um mitzumachen, öffnet die Webkonsole in eurem Browser und folgt den Programmier-Beispielen.

Um Zahlen miteinander zu vergleichen, gibt es Vergleichsoperatoren. Soll bspw. festgestellt werden, ob 24 kleiner oder größer oder gleich 20 ist, kann das auf folgende Weise in die Konsole eingegeben werden.

24 < 20
// => false

Beim Ausführen der Codezeile erscheint das Wort false. Wird statt eines kleiner-als- das größer-als-Zeichen verwendet, erscheint ein anderes Wort.

24 > 20
// => true

Nun erscheint an der Stelle das Wort true. Was bedeuten diese Wörter?

Bool'sche Werte

Bekannterweise arbeiten Computer intern mit Nullen und Einsen. Statt als Nullen und Einsen werden diese atomaren Werte oft auch als Ja und Nein oder als Wahr und Falsch dargestellt.

Ein Vergleich wie 24 < 20 ist, als würde dem Computer eine Frage gestellt werden: »Ist 24 kleiner als 20?« Woraufhin der Computer mit diesen elementaren Werten antwortet: Ja oder wie im konkreten Fall Nein. Lesbar dargestellt wird das mit den Worten true und false, die Englisch sind und wahr und falsch bedeuten.

Datentypen

In der Konsole werden true und false in anderen Farben dargestellt als Zahlen und Strings.

In Chrome sind Zahlen blau, Strings rot und Boolsche Werte violett

Die Farbgebung ist nicht zufällig. Zahlen, Strings und Boolsche Werte sind allesamt Daten, aber Daten unterschiedlicher Art.
Der einfachste und elementarste ist der Boolsche Datentyp, im Englischen Boolean. Boolsche Werte haben nur zwei mögliche Ausprägungen: true oder false. Im Speicher entspricht das einem Bit.
Komplexer sind die Numbers, die Zahlen. Hier entspricht ein Wert einer fast beliebigen Ausprägung entlang einer Zahlengeraden. Intern werden Zahlen übrigens als Binärwert abgespeichert, also als Reihe von Bits.
Noch komplexer sind die Strings, die Zeichenketten. Ein String ist eine beliebig lange Aneinanderreihung beliebiger Zeichen. Im Speicher wird ein Zeichen genau wie eine Zahl als Reihe von Bits repräsentiert. Eine Kette von Zeichen kann deswegen wie eine Kette von Zahlen betrachtet werden.

Zu erkennen ist die steigende Komplexität: Strings sind wie eine Kette von Zahlen und Zahlen sind wie eine Kette von Boolschen Werten.

Neben diesen dreien gibt es noch weitere Datentypen, die in anderen Artikeln dieser Serie vorgestellt werden.

Vergleichsoperatoren

In den Code-Beispielen am Anfang waren die Zahlenvergleiche mit < kleiner als und > größer als zu sehen. Neben diesen zweien gibt es noch weitere sogenannte Vergleichsoperatoren. Deren Bedeutung ist den meisten bestimmt aus der Schulzeit bekannt. Die Schreibweise dagegen ist jedoch in JavaScript teilweise anders.
Soll überprüft werden, ob eine Zahl kleiner oder gleich eine andere Zahl oder größer oder gleich ist, sah das in der Schule folgendermaßen aus:

42 ≤ 42

42 ≥ 42

In JavaScript besteht das kleiner gleich / größer gleich dagegen aus zwei Zeichen: Dem kleiner- und dem gleich-Zeichen bzw. dem größer- und dem gleich-Zeichen.

42 <= 42
42 >= 42

Um zu ermitteln, ob zwei Zahlen gleich sind, unabhängig von kleiner oder größer, werden zwei aufeinanderfolgende Gleichzeichen geschrieben. Es sind zwei Zeichen, weil das einzelne Gleichzeichen bereits eine eigene Bedeutung in JavaScript hat, auf die später in dieser Serie eingegangen wird

42 == 42

Striktes Gleich

Neben dem Vergleich mit zwei Gleichzeichen gibt es außerdem den Vergleich mit drei Gleichzeichen. Wozu gibt es zweimal einen Operator, um zu prüfen, ob Werte gleich sind?
Schaut euch dieses Beispiel an und testet es in eurer Konsole und versucht, selbst den Unterschied zwischen den beiden Operatoren herauszufinden.

42 == 42
// true

42 === 42
// true

42 == "42"
// true

42 === "42"
// false

JavaScript ist eine vereinfachte Programmiersprache und dazu entwickelt, Fehler weitestgehend zu verzeihen. Das geht so weit, dass es erkennt, ob ein String einen Zahlenwert beinhaltet. Gibt bspw. ein Nutzer einen Zahlenwert in ein Eingabefeld ein, ist dieser Wert erst einmal ein String, eine Kette beliebiger Zeichen. Soll mit dem Zahlenwert der Eingabe gerechnet werden, müsste der String streng genommen erst in eine Zahl konvertiert werden, damit sie vom Datentyp Number ist und vom Computer als Zahlenwert wahrgenommen wird.
Das ist ein Umstand, der für Programmieranfänger verwirrend sein kann. Deshalb ist JavaScript so entwickelt, dass es feststellt, ob der Inhalt eines Strings einer Zahl entspricht und ob der Programmierer beabsichtigt, mit diesem Zahlenwert zu arbeiten.
Aus dem Grund gibt das Vergleichen von 42 == "42" true zurück, obwohl die erste 42 eine Zahl und die zweite "42" ein String ist.

Obwohl diese Eigenschaft von JavaScript Programmierern das Leben leichter machen soll, kann sie auch zu Problemen führen. Denn es gibt Fälle, in denen die Grundverschiedenheit der Werte beim Vergleichen berücksichtigt werden soll.
Darum gibt es das strikte Gleich, das aus drei Gleichzeichen besteht. Mit dem wird nicht nur der interpretierte Wert verglichen, sondern auch dessen Datentyp.

Negation

Wenn geschaut werden soll, ob ein Wert nicht gleich einem anderen Wert ist, gibt es dafür das Ungleich. In der Schule wird dafür ein durchgestrichenes Gleichzeichen geschrieben:

42 ≠ 42

In JavaScript wird ein Ausrufezeichen und ein Gleichzeichen geschrieben. Das Ausrufezeichen ist das allgemeine Symbol der Negation, nicht nur in JavaScript, sondern auch in anderen Programmiersprachen.

42 != 42
// false

42 != 43
// true

Genau wie es das strikte Gleich gibt, gibt es auch das strikte Ungleich, bei dem der Datentyp für den Vergleich berücksichtigt wird.

42 != "42"
// false

42 !== "42"
// true

Liste der Vergleichsoperatoren

Zusammenfassend ist hier eine Übersicht der genannten Vergleichsoperatoren:

Operator Bedeutung
< kleiner als
> größer als
<= kleiner gleich
>= größer gleich
== gleich
=== striktes gleich
!= ungleich
!== striktes ungleich