JavaScript er et dynamisk språk med over gjennomsnittet finurlige regler for automatisk typekonvertering -- "coercion". Heldigvis er det færre regler enn det kan virke som, men sammen kan de by på mang en overraskelse for enhver. Kan du reglene så vil du ikke bli overrasket over dette kodeeksempelet som noen nylig viste meg:

-1 < null // true
null < 1 // true
0 == null // false (exploding head)

Altså: fordi null er større enn -1, men mindre enn 1, forventet man at den i det minste skulle være lik 0, noe den ikke er. Les videre for å lære hvorfor.

¶A wild coercion appears

Nå som du har peiling på hvilke regler som styrer konvertering kan vi se litt på hvor disse reglene tas i bruk.

¶< og >

Disse to operatorene gir kun mening for tall, og konverter sine argumenter til tall:

3 < "4" //=> 3 < Number("4")
        //=> 3 < 4
        //=> true

null < 1 //=> Number(null) < 1
         //=> 0 < 1
         //=> true

-1 < null //=> -1 < Number(null)
          //=> -1 < 0
          //=> true

Med det eksempelet har vi fått forklart 2/3 av det første kodeeksempelet vårt.

Legg merke til at dette kan bli nokså klovnete med objekter:

var clown = {
  age: 32,

  valueOf() {
    return this.age
  }
};

clown < 33 //=> ToPrimitive(clown) < 33
           //=> 32 < 33
           //=> true

Eller med toString:

var clown = {
  toString() {
    return "56";
  }
};

clown < 57 //=> ToPrimitive(clown) < 57
           //=> Number("56") < 57
           //=> 56 < 57
           //=> true

¶+

+-operatoren i JavaScript er, som så mye annet, litt mer bingo enn i andre språk. Som i andre språk gjør den enten streng-konkatenering eller addisjon, men i motsetning til andre språk så blander den gjerne disse to i ett og samme uttrykk.

Har du en streng eller et objekt på en av sidene får du konkatenering -- ellers får du addisjon. For konkatenering må begge argumentene konverteres til strenger, for addisjon må begge konverteres til tall. Har du flere plusser i samme uttrykk følger du denne regelen én pluss om gangen.

Noen eksempler med tall:

2 + 3 //=> 5

2 + true //=> 2 + Number(true)
         //=> 2 + 1
         //=> 3

true + 4 //=> Number(true) + 4
         //=> 1 + 4
         //=> 5

Fordi du kun får konkatenering når du har et objekt med i dansen, kan du få et uventet resultat dersom du prøver å addere et tall med et objekt som helt fint kan konverteres til et tall:

var then = new Date(2019, 0, 1);

then + 1000 //=> "Tue Jan 01 2019 00:00:00 GMT+0100 (CET)1000"

Hva skjedde? Vel, siden ett argument var et objekt er det streng-konkatering som gjelder, og dermed får vi:

then.toString() + String(1000)
"Tue Jan 01 2019 00:00:00 GMT+0100 (CET)" + "1000"

Dersom du har et lengre uttrykk evaluerer du bare én og en pluss:

2 + 3 + true + []
    //=> 5 + true + []
    //=> 5 + Number(true) + []
    //=> 6 + []
    //=> String(6) + String([])
    //=> "6" + ""

En array har en toString som fungerer som .join(","):

2 + [1, 2, 3] + true
    //=> String(2) + String([1, 2, 3]) + true
    //=> "2" + "1,2,3" + true
    //=> "21,2,3" + String(true)
    //=> "21,2,3true"