Was passiert in JavaScript bei nicht-strenger Vergleich (==)?

Bei nicht strenger Gleichheit (==) in JavaScript wird vor dem Vergleich eine Typumwandlung (Coercion) der Operanden durchgeführt. Wenn die Typen der Operanden unterschiedlich sind, versucht JavaScript, einen oder beide Operanden in einen gemeinsamen Typ umzuwandeln, basierend auf einer Reihe von Regeln.

Hauptregeln der Umwandlung bei ==:

1. Zahl und String: Der String wird in eine Zahl umgewandelt. Wenn die Umwandlung nicht möglich ist (NaN), ist das Ergebnis immer false.

   // "10" wird zu 10. Ergebnis: true
   console.log(10 == "10");
   // "abc" wird zu NaN. Ergebnis: false
   console.log(10 == "abc");
   

2. Boolean und Nicht-Boolean: Boolean wird in eine Zahl umgewandelt (true zu 1, false zu 0). Dann werden die Zahl und der andere Operand verglichen.

   // true wird zu 1. Ergebnis: true
   console.log(true == 1);
   // false wird zu 0. Ergebnis: true
   console.log(false == 0);
   // false wird zu 0, "0" wird zu 0. Ergebnis: true
   console.log(false == "0");
   

3. Null und Undefined: null ist gleich undefined als true, und mit nichts anderem (außer sich selbst) als true.

   // Ergebnis: true
   console.log(null == undefined);
   // Ergebnis: false
   console.log(null == 0);
   // Ergebnis: false
   console.log(undefined == 0);
   

4. Objekt und Primitive: Das Objekt wird in einen Primitive umgewandelt (mithilfe von valueOf oder toString), dann werden die Primitives verglichen.

   // Das Objekt wird zu der Zeichenkette "10" (über toString()) umgewandelt, dann mit der Zahl 10 verglichen
   // "10" wird zu 10. Ergebnis: true
   console.log({ toString: () => "10" } == 10);
   

5. Symbol und anderes: Symbole können nur mit einem anderen Symbol oder einem primitiven Wert verglichen werden, in den das Symbol umgewandelt werden kann (was in Standardfällen meist nicht möglich ist).

   // Ergebnis: false
   console.log(Symbol('a') == 'a');
   

Nicht-strikte Vergleiche können aufgrund der automatischen Typumwandlung zu unerwarteten Ergebnissen führen. Für ein vorhersehbareres Verhalten wird empfohlen, den strikten Vergleich (===) zu verwenden, der keine Typumwandlung durchführt und die Operanden direkt vergleicht.