Pretvarjanje podatkovnih tipov v JavaScriptu

JavaScript uporablja več podatkovnih tipov in omogoča tudi pretvarjanje med njimi. Pri pretvarjanju podatkovnih tipov je posebej pomembno razlikovati med eksplicitno pretvorbo, ki jo zapiše programer, in implicitno pretvorbo, ki jo JavaScript izvede sam med izvajanjem programa.

Osnovna pravila

• JavaScript pozna več primitivnih tipov in tip object.
• Operator typeof vrne niz, ki opisuje tip vrednosti.
• Pretvorba tipov je lahko eksplicitna ali implicitna.
• Pri novi kodi je priporočljivo uporabljati jasne pretvorbe, kot so String(), Number() in Boolean().
• Pri primerjavah je praviloma varneje uporabljati === in !== namesto == in !=.

Primerjave

Podatkovni tipi

Starejša gradiva pogosto navajajo ožji seznam tipov, sodobna razlaga pa vključuje tudi bigint in symbol. Pri objektih ločimo med splošnim tipom object in posameznimi vrstami objektov, kot so tabele, datumi in funkcije.

Operator typeof

Operator typeof vrne niz, ki označuje tip podane vrednosti. Posebej pomembno je, da typeof null zaradi zgodovinske posebnosti vrne "object", zato za preverjanje null uporabljamo strogo primerjavo z === null.

typeof "Janez";            // "string"
typeof 2.34;              // "number"
typeof NaN;               // "number"
typeof null;              // "object"
typeof true;              // "boolean"
typeof [1, 2, 3, 4];       // "object"
typeof {ime: "Janez"};      // "object"
typeof new Date();         // "object"
typeof function () {};      // "function"
typeof stIme;             // "undefined"

<p id="primer1"></p>
<script>
{
   document.getElementById("primer1").innerHTML =
      typeof "Janez" + "<br>" +
      typeof 2.34 + "<br>" +
      typeof null + "<br>" +
      typeof [1, 2, 3] + "<br>" +
      typeof function () {};
}
</script>

Pretvarjanje v niz

Vrednosti lahko v niz pretvorimo s funkcijo String() ali z metodo toString(). Funkcija String() je pogosto varnejša, ker jo lahko uporabimo tudi pri null in undefined.

Pretvarjanje števil v nize

String(987);           // "987"
String(10 + 20);       // "30"
(123).toString();      // "123"
(10 + 20).toString();  // "30"

Pretvarjanje logičnih vrednosti v nize

String(false);         // "false"
String(true);          // "true"
false.toString();      // "false"
true.toString();       // "true"

Pretvarjanje datumov v nize

Datume v niz pogosto pretvorimo z metodama toString() ali String(), pri sodobni kodi pa je za standardiziran zapis pogosto zanimiva tudi metoda toISOString().

<p id="primer2"></p>
<script>
{
   const d = new Date();
   document.getElementById("primer2").innerHTML =
      String(d) + "<br>" +
      d.toString() + "<br>" +
      d.toISOString();
}
</script>

Pretvarjanje v število

Za pretvorbo v število uporabljamo Number(), pri nizih pa pogosto tudi parseInt() in parseFloat(). Če pred vrednost zapišemo predznak +, JavaScript to vrednost poskusi pretvoriti v število.

Pretvarjanje nizov v števila

Number("1.23");      // 1.23
Number(" ");        // 0
Number("");         // 0
Number("1,23");      // NaN
Number("12 34");     // NaN
Number("st123");     // NaN

parseInt("56.78");    // 56
parseFloat("56.78");  // 56.78

<p id="primer3"></p>
<script>
{
   document.getElementById("primer3").innerHTML =
      Number("1.23") + "<br>" +
      Number(" ") + "<br>" +
      Number("") + "<br>" +
      Number("1,23") + "<br>" +
      parseInt("56.78") + "<br>" +
      parseFloat("56.78");
}
</script>

Pretvarjanje z operatorjem +

const y = "17";   // y je niz
const x = +y;     // x je število 17

<p id="primer4"></p>
<script>
{
   const y = "17";
   const x = +y;
   document.getElementById("primer4").innerHTML =
      y + "<br>" + x + "<br>" + typeof x;
}
</script>

Pretvarjanje logičnih vrednosti in datumov v števila

Number(true);   // 1
Number(false);  // 0

const d = new Date();
Number(d);      // število milisekund
d.getTime();    // isto število milisekund

<p id="primer5"></p>
<script>
{
   const d = new Date();
   document.getElementById("primer5").innerHTML =
      Number(true) + "<br>" +
      Number(false) + "<br>" +
      Number(d) + "<br>" +
      d.getTime();
}
</script>

Pretvarjanje v logično vrednost

V logično vrednost pretvarjamo s funkcijo Boolean(). V logičnem kontekstu so neresnične predvsem vrednosti false, 0, -0, 0n, "", null, undefined in NaN.

<p id="primer6"></p>
<script>
{
   document.getElementById("primer6").innerHTML =
      Boolean(false) + "<br>" +
      Boolean(0) + "<br>" +
      Boolean("") + "<br>" +
      Boolean("0") + "<br>" +
      Boolean("JavaScript");
}
</script>

Samodejna pretvorba podatkovnih tipov

JavaScript pri številnih operatorjih in izrazih samodejno pretvarja tipe. Takšno obnašanje imenujemo implicitna pretvorba oziroma type coercion. Rezultat ni vedno tak, kot bi ga pričakovali na prvi pogled.

3 + null;      // 3
"3" + null;    // "3null"
"3" + 1;       // "31"
"3" - 1;       // 2

<p id="primer7"></p>
<script>
{
   document.getElementById("primer7").innerHTML =
      (3 + null) + "<br>" +
      ("3" + null) + "<br>" +
      ("3" + 1) + "<br>" +
      ("3" - 1);
}
</script>

Tabela pretvorbe podatkovnih tipov

Spodnja tabela povzema nekaj značilnih pretvorb:

Priporočila

• Za pretvorbo tipov uporabljaj jasne in eksplicitne funkcije, kot so String(), Number() in Boolean().
• Pri primerjavah praviloma uporabljaj === in !==.
• Pri delu z uporabniškim vnosom preveri, ali je rezultat pretvorbe v število res veljaven.
• Pri datumih za standardiziran zapis v obliki niza uporabi metodo toISOString().
• Pri razlagi kode vedno posebej opozori, kadar operator + sproži spajanje nizov namesto seštevanja.

Pogoste napake

• Starejši in sodobni podatkovni tipi se predstavljajo kot enak seznam, čeprav sodobni JavaScript vključuje tudi bigint in symbol.
• Operator typeof se uporablja za preverjanje null, čeprav pri tej vrednosti vrne zgodovinsko posebnost "object".
• Implicitna pretvorba tipov se uporablja brez jasnega nadzora, zato izrazi vrnejo drugačen rezultat od pričakovanega.
• Pri primerjavah se uporablja ==, čeprav bi bila zaradi preglednosti in manj dvoumnosti primernejša uporaba ===.
• Rezultat NaN se obravnava kot navadno število, čeprav pomeni, da pretvorba ali računanje ni dalo veljavne številske vrednosti.