Wat gebeurt er in JavaScript bij een niet-strikte vergelijking (==)?

Bij niet-strikte vergelijking (==) in JavaScript wordt een typeconversie (coercion) van de operands uitgevoerd voordat de vergelijking plaatsvindt. Als de types van de operands verschillen, probeert JavaScript een of beide operands naar hetzelfde type te converteren, op basis van een reeks regels.

Belangrijkste regels voor conversie met ==:

1. Getal en string: De string wordt geconverteerd naar een getal. Als de conversie niet lukt (NaN), is het resultaat altijd false.

   // "10" wordt geconverteerd naar 10. Resultaat: true
   console.log(10 == "10");
   // "abc" wordt geconverteerd naar NaN. Resultaat: false
   console.log(10 == "abc");
   

2. Boolean en niet-Boolean: Boolean wordt geconverteerd naar een getal (true naar 1, false naar 0). Vervolgens worden het getal en de andere operand vergeleken.

   // true wordt 1. Resultaat: true
   console.log(true == 1);
   // false wordt 0. Resultaat: true
   console.log(false == 0);
   // false wordt 0, "0" wordt 0. Resultaat: true
   console.log(false == "0");
   

3. Null en Undefined: null is gelijk aan undefined als true, en met niets anders (behalve zichzelf) als true.

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

4. Object en primitief: Het object wordt geconverteerd naar een primitief (met behulp van valueOf of toString), en vervolgens worden de primitieve waarden vergeleken.

   // Het object wordt geconverteerd naar de string "10" (via toString()), en vervolgens vergeleken met het getal 10
   // "10" wordt geconverteerd naar 10. Resultaat: true
   console.log({ toString: () => "10" } == 10);
   

5. Symbool en ander: Symbolen kunnen alleen worden vergeleken met een ander symbool of een primitieve waarde waartoe het symbool kan worden geconverteerd (wat in standaardgevallen onmogelijk is).

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

Niet-strikte vergelijking kan leiden tot onverwachte resultaten door automatische typeconversie. Voor voorspelbaarder gedrag wordt aanbevolen om strikte vergelijking (===) te gebruiken, die geen typeconversie uitvoert en de operands direct vergelijkt.