Javascript größer, kleiner, gleich

Werte vergleichen

Vergleiche von Werten sind das A und O für Javascript – immer wieder wird geprüft, ob zwei Strings gleich sind, ein bestimmter Wert erreicht wurde oder eine Bedingung true oder false ist. 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).

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

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

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

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

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

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

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

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

== und != sind heimtückisch

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

const a = 2;
const 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:

const myObject = { };

const val = myObject.name;
if (val === null) {
   console.log (name + " nicht gefunden");
}

Die Variable val existiert (ist nicht null), denn sie wurde deklariert, aber sie hat keinen sinnvollen Wert, denn myObject.name ist undefined. Eine Variable mit dem Wert undefined führt erst mal nicht zu einer Fehlermeldung.

Richtig wäre

const myObject = { };
const val = myObject.name;
if (val === undefined) {
   console.log (name + " nicht  gefunden");
}

Das könnte man jetzt einfacher gestalten:

const myObject = {};
const val = myObject.name;

if (val) {
	console.log ("val", val + " gefunden");
} 

myObject.name ist undefined, also wird val zu undefined entwickelt. In einem boolschen Kontext (in der if-Abfrage) ist undefined ein falsy. Die Anweisungen im folgenden Block werden nur ausgeführt, wenn myObjekt.name einen truthy ist.

truthy und falsy – wahr oder falsch

Mathematisch zwischen

Wie herausfinden, ob ein Wert zwischen zwei Werten liegt?

const X = 300;
const Y = 521;
const 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