Vergleich in

Über Vergleich

Zahlen vergleichen

In JavaScript kannst du Zahlen mit den folgenden Vergleichs- und Gleichheitsoperatoren vergleichen.

Das Ergebnis des Vergleichs ist immer ein boolescher Wert, also entweder true oder false.

1 < 3;
// => true

2 !== 2;
// => false

1 === 1.0;
// => true
// All numbers are floating-points, so this is different syntax
// for the exact same value.

Strings vergleichen

In JavaScript kannst du die oben genannten Vergleichsoperatoren auch verwenden, um Strings zu vergleichen. In diesem Fall wird eine lexikografische Reihenfolge angewendet. Eine Liste der genauen Reihenfolge aller Zeichen findest du hier.

'Apple' > 'Pear';
// => false

'a' < 'above';
// => true

'a' === 'A';
// => false

Du musst vorsichtig sein, wenn du zwei Variablen vergleichst, die numerische Werte zu enthalten scheinen, aber vom Typ String sind. Aufgrund der lexikografischen Reihenfolge ist das Ergebnis nicht dasselbe wie beim Vergleich von Werten des Typs Number.

10 < 2;
// => false

'10' < '2';
// => true (because "1" comes before "2")

Eine andere Möglichkeit, Strings zu vergleichen, ist die Methode localeCompare. Damit kannst du verschiedene Optionen festlegen, um die Art und Weise anzupassen, wie Strings verglichen werden.

Strikte Gleichheit

Vielleicht fragst du dich, warum in JavaScript drei Gleichheitszeichen für die Prüfung auf Gleichheit stehen. === steht für die Prüfung auf strikte Gleichheit. Das bedeutet, dass keine Typumwandlung durchgeführt wird und Werte unterschiedlichen Typs immer ungleich sind.

'3' === 3;
// => false
// The value on the left has type string, the value on the right
// has type number.

1 === 1n;
// => false
// The value on the left has type number, the value on the right
// has type bigint.

In JavaScript ist die Verwendung von === und !== die empfohlene Art, auf Gleichheit zu prüfen.

Implizite Typumwandlung vermeiden

Es gibt auch == und !=, die für die Prüfung auf lose Gleichheit stehen. Du solltest das vermeiden, weil dabei eine implizite Typumwandlung durchgeführt wird, bevor der Vergleich stattfindet. Die Ergebnisse sind in diesen Fällen schwer vorherzusagen und manchmal nicht das, was du erwartest. Mehr dazu kannst du hier lesen.

0 == false;
// => true

Theoretisch kannst du auch Werte unterschiedlichen Typs vergleichen (z. B. "1" < 2). Dann werden die Werte implizit umgewandelt, um zu bestimmen, ob das Ergebnis wahr oder falsch ist. Genau wie die Prüfung auf lose Gleichheit ist auch das aus dem oben genannten Grund nicht empfehlenswert.

Was solltest du stattdessen tun? Du kannst eine explizite Typumwandlung anwenden. Damit kannst du sicherstellen, dass die Werte den richtigen Typ haben, bevor du den Vergleich durchführst. Dann ist dein Code leichter zu verstehen und weniger fehleranfällig.