R größer gleich

Werte vergleichen

Vergleichs-Operatoren werden in Logik-Operationen benutzt, um Gleichheit oder Unterschiede zwischen Variablen oder Werten festzustellen. Gebraucht werden die Vergleiche vor allem in Bedingungen wie while (a < b) und if (x > 0).

Gleich ==

== gibt true zurück, wenn beide Werte gleich sind.

let x = 17;
let y = 17;
if (x == y) // gibt true zurück

Das sieht einfach aus, ist aber nicht immer ohne Heimtücke … besser immer gleich das Trio mit drei Gleichheitszeichen ===

Nicht gleich !=

!= gibt true zurück, wenn die beiden Werte nicht gleich sind.

let x = 17;
let y = 23;
if (x != y) // gibt true zurück

Liest sich: Wenn x nicht gleich y ist …

Drei Gleichheitszeichen, strenges Gleich oder identisch ===

=== Gibt true zurück, wenn die beiden Werte gleich und vom selben Datentyp sind.

let x = 17;
let y = "17";
if (x === y) // gibt false zuück

Liest sich: Wenn x identisch mit y ist, also auch vom selben Datentyp …

Strenges Nicht Gleich !==

!== gibt true zurück, wenn die beiden Werte nicht gleich oder nicht vom selben Datentyp sind.

let x = 17;
let y = 17;
if (x !== y) // gibt false zurück, denn beide Werte gleich und vom selben Datentyp sind.

Liest sich: Wenn x nicht identisch mit y und nicht vom selben Datentyp …

Größer als >

> Gibt true zurück, wenn der Wert auf der linken Seite größer als der Wert auf der rechten Seite ist.

let x = 27;
let y = 23;
if (x > y) // true, denn 27 ist größer als 23

Liest sich: Wenn x größer als y ist …

Kleiner als <

< Gibt true zurück, wenn der Wert auf der linken Seite kleiner als der Wert auf der rechten Seite ist.

let x = 700;
let y = 2000;
if (x < y) // true, denn 700 ist kleiner als 2000

Liest sich: Wenn x kleiner als y ist …

Größer Gleich >=

>= gibt true zurück, wenn der Wert auf der linken Seite größer oder gleich dem Wert auf der rechten Seite ist.

let x = 400;
let y = 400;
if (x >= y) // true, denn 400 ist größer oder gleich 400

Liest sich: Wenn x größer oder gleich y ist …

Kleiner Gleich <=

<= gibt true zurück, wenn der Wert auf der linken Seite kleiner oder gleich dem Wert auf der rechten Seite ist.

let x = 100;
let y = 200;
if (x <= y) // false, denn 200 ist nicht kleiner oder gleich 100

Liest sich: Wenn x kleiner oder gleich y ist …

== und != sind heimtückisch

Das doppelte Gleichheitszeichen == liest sich: Wenn x gleich y ist …. Klingt das nicht einfach?

let a = 2;
let b = "2";
if (a == b) {
	console.log ("Dumm gelaufen")
}

Man spricht von einer lockeren Gleichheit, wenn sich zwei Werte ähneln wie 2 und "2".

Das doppelte Gleichheitszeichen ist die Quelle vieler heimtückischer Fehler in Javascript. Das strenge ist gleich (=== Operator) ist die besser Wahl, denn es schützt vor versteckten Fehlern. Das lockere ist gleich (== Operator) liefert zahlreiche unerwartete Ergebnisse aufgrund von Typ-Missverständnissen. Zum Glück gibt es das dreifache Gleichheitszeichen.

Dasselbe gilt auch für das einfache ungleich !=. Also lieber gleich ein Gleichheitszeichen mehr !==.

Und das ist ein Klassiker unter den Fehlern, und ein gemeiner dazu, denn die zwei Fehler in diesem Snippet heben einander auf:

let myObject = new Object;
let val = myObject [name];
if (val == null) {
   console.log (name + "nicht gefunden");
}

Richtig wäre

let myObject = new Object;
let val = myObject [name];
if (val === undefined) {
   console.log (name + "nicht gefunden");
}

Mathematisch zwischen

Wie herausfinden, ob ein Wert zwischen zwei Werten liegt?

let X = 300;
let Y = 521;
let Z = 800;

if (Y < Z && Y > X) {
    console.log(`Y ist kleiner als Z aber größer als X oder mathematisch
	'X < Y < Z' or 'Z > Y > X'
	`);
}

Weitere Operatoren