Vergleichsoperatoren

Sie kennen Vergleichsoperatoren aus dem Matheunterricht, aber lassen Sie uns Ihr Wissen auffrischen:

Größer-als-Operator (a > b) gibt true zurück, wenn der linke Operand größer als der rechte Operand ist.

Syntax:

a > b

Beispiel für den Größer-als-Operator:

Javascript Greater than operator

console.log(7 > 4); // true

Kleiner-als-Operator (a < b) gibt true zurück, wenn der linke Operand kleiner als der rechte Operand ist.

Syntax:

a < b

Beispiel für den Kleiner-als-Operator:

Javascript less than operator

console.log(4 < 7); // true

Größer-als-oder-gleich-Operator (a >= b) gibt true zurück, wenn der linke Operand größer als oder gleich dem rechten Operanden ist.

Syntax:

a >= b

Beispiel für den Größer-als-oder-gleich-Operator:

jJvascript Greater than or equal operator

console.log(7 >= 4); // true console.log(4 >= 4); // true

Kleiner-als-oder-gleich-Operator (a <= b) gibt true zurück, wenn der linke Operand kleiner als oder gleich dem rechten Operanden ist.

Syntax:

a <= b

Beispiel für den Kleiner-als-oder-gleich-Operator:

Javascript less than or equal operator

console.log(4 <= 7); // true console.log(4 <= 4); // true

Der Gleichheitsoperator (a == b) konvertiert die Operanden, wenn sie nicht vom gleichen Typ sind, und wendet dann eine strenge Vergleich an. Wenn beide Operanden Objekte sind, vergleicht JavaScript interne Verweise, die gleich sind, wenn die Operanden sich auf dasselbe Objekt im Speicher beziehen.

Syntax:

a == b

Beispiel für den Gleichheitsoperator:

Javascript equality operator

console.log(1 == 1); // true console.log("2" == 2); // true console.log(3 == '3'); // true console.log(0 == false); // true console.log(0 == null); // false console.log(0 == undefined); // false console.log(null == undefined); // true

Wenn die Operanden nicht gleich sind, gibt der Ungleichheitsoperator (!=) true zurück. Wenn zwei Operanden nicht vom gleichen Typ sind, versucht JavaScript, die Operanden in einen geeigneten Typ für den Vergleich umzuwandeln.

Wenn beide Operanden Objekte sind, vergleicht JavaScript Verweise, die nicht gleich sind, wenn die Operanden sich auf unterschiedliche Objekte im Speicher beziehen.

Syntax:

a != b

Beispiel für den Ungleichheitsoperator:

Javascript inequality operator

console.log(1 != 2) ; // true console.log(2 != "2"); // false console.log(3 != '3' ); // false console.log(1 != true); // false console.log(0 != false); // false

Boolean ist das Ergebnis

Eine Vergleich gibt wie alle anderen Operatoren einen Wert zurück. Der Wert ist in diesem Fall ein boolean.

true ist “ja”, “korrekt” oder “die Wahrheit”;
false ist “nein”, “falsch” oder “nicht die Wahrheit”.

Comparison operator in javascript

console.log( 3 > 1 ); // true (correct) console.log( 3 == 1 ); // false (wrong) console.log( 3 != 1 ); // true (correct)

Ein Vergleichsergebnis kann einer Variable zugewiesen werden, wie jeder andere Wert:

Comparison operator javascript

let result = 7 > 4; // the result of the comparison console.log ( result ); // true

String-Vergleich

JavaScript verwendet eine “Wörterbuch”- oder “lexikographische” Reihenfolge, um zu sehen, ob ein String größer als ein anderer ist. Mit anderen Worten, Strings werden buchstabenweise verglichen.

Beispiel für den String-Vergleich:

The string comparison in javascript

console.log( 'Z' > 'A' ); // true console.log( 'Want' > 'Walk' ); // true console.log( 'Too' > 'To' ); // true

In den Beispielen gelangt der Vergleich 'Z' > 'A' in einem Schritt zu einem Ergebnis, während die Zeichenketten "Want" und "Walk" buchstabenweise verglichen werden:

W ist gleich W.
a ist gleich a.
n ist größer als l.

Vergleich verschiedener Typen

Für den Vergleich von Werten unterschiedlicher Typen konvertiert JavaScript die Werte in Zahlen.

The comparison of different types in javascript

console.log( '3' > 1 ); // true, string '3' becomes a number 3 console.log( '02' == 2 ); // true, string '02' becomes a number 2

Für boolesche Werte wird true zu 1, false zu 0.

Comparison of different types in javascript

console.log( true == 1 ); // true console.log( false == 0 ); // true

Strikte Gleichheit

Eine reguläre Gleichheitsprüfung == hat ein Problem, da sie 0 von false nicht unterscheiden kann:

The regular equality == in javascript

console.log( 0 == false ); // true

Wir begegnen dem gleichen Problem mit einer leeren Zeichenkette:

The regular equality == in javascript

console.log( '' == false ); // true

Vergleich mit null und undefined

Unintuitives Verhalten tritt auf, wenn null oder undefined mit anderen Werten verglichen werden. Bei einer strikten Gleichheitsprüfung ===. Diese Werte sind unterschiedlich, da jeder von ihnen ein anderer Typ ist.

The strict equality === in javascript

console.log( null === undefined ); // false

Für eine nicht strenge Prüfung ==

Diese beiden bilden ein “süßes Paar”, das bedeutet, dass sie einander gleich sind.

The regular equality == in javascript

console.log( null == undefined ); // true

Der Unterschied zwischen == und ===

JavaScript hat zwei optisch ähnliche, aber sehr unterschiedliche Methoden, die Gleichheit zu testen:

== (Doppel-Equals-Operator): der Gleichheits- oder abstrakte Vergleichsoperator

=== (Triple-Equals-Operator): der Identitäts- oder strikte Vergleichsoperator

Hier sind die Unterschiede zwischen == und ===:

Bevor die Vergleich zeigt, konvertiert == die Variablenwerte des gleichen Typs;
=== führt keine Typumwandlung durch und gibt nur dann true zurück, wenn sowohl Werte als auch Typen für die beiden verglichenen Variablen identisch sind.

== and === equality in javascript

var val1 = 13; var val2 = 13; console.log(val1 == val2); // true console.log(val1 === val2); // also true

Für Mathematik und andere Vergleiche < > <= >=

Null/undefined werden in Zahlen umgewandelt, hier wird null zu 0, undefined zu NaN.

Wir präsentieren Ihnen einige lustige Dinge, die passieren, wenn wir diese Regeln anwenden. Und auch, wie man nicht in eine Falle mit ihnen gerät.

Seltsames Ergebnis: null vs 0

Beispiel für den Vergleich von null mit einer Null:

Compare null with a zero in javascript

console.log( null > 0 ); // (1) false console.log( null == 0 ); // (2) false console.log( null >= 0 ); // (3) true

Das ist mathematisch gesehen seltsam. Das letzte Ergebnis besagt, dass "null größer oder gleich null ist", das bedeutet, dass bei einem der oben genannten Vergleiche true sein muss, aber beide sind false.

Der Hauptgrund ist, dass eine Gleichheitsprüfung == und Vergleiche zwischen > < >= <= auf unterschiedliche Weise arbeiten: Vergleiche konvertieren null in eine Zahl und behandeln es als 0. Das ist der Grund, warum (3) null >= 0 true ist und (1) null > 0 false ist.

Andererseits ist die Gleichheitsprüfung == für undefined und null ohne Konvertierungen definiert. Sie sind gleich und sind gleich sonst nichts, deshalb ist (2) null == 0 false.

Ein nicht vergleichbares undefined

Wir können den Wert undefined nicht mit anderen Werten vergleichen:

Compare the value with undefined in javascript

console.log( undefined > 0 ); // false (1) console.log( undefined < 0 ); // false (2) console.log( undefined == 0 ); // false (3)

Die Gründe, warum wir diese Ergebnisse bekommen, sind:

Vergleiche (1) und (2) geben false zurück, da undefined zu NaN konvertiert wird, es handelt sich um einen speziellen numerischen Wert, der für alle Vergleiche false zurückgibt.
Der Gleichheitscheck (3) gibt false zurück, da hier undefined nur gleich null, undefined und keinem anderen Wert ist.

Quizzeit: Testen Sie Ihre Fähigkeiten!

Sind Sie bereit, das Gelernte herauszufordern? Tauchen Sie ein in unsere interaktiven Quizze für ein tieferes Verständnis und eine unterhaltsame Art, Ihr Wissen zu festigen.