Typová konverze

Jak jsme již zmínili, JavaScript je slabě typovaný, dynamický jazyk. Jinými slovy, nevyžaduje, abyste při deklaraci proměnné specifikovali typ - místo toho se podívá na to, co proměnné přiřadíte, a poté to podle toho v zákulisí zpracuje.

To také znamená, že ve většině případů se o typy nemusíte starat. Stačí deklarovat proměnnou, přiřadit k ní řetězec, a JavaScript ji bude považovat za řetězec. Pokud si to později rozmyslíte, můžete k ní přiřadit číslo a JavaScript ji nyní bude považovat za číslo.

To ale neznamená, že by JavaScriptu na typech nezáleželo, protože interně jsou typy stále velmi důležité a někdy to bude důležité i pro vás. V těchto situacích můžete ručně převádět mezi primitivními typy podle potřeby, abyste zajistili, že určitá proměnná bude zpracována tak, jak byste očekávali.

V tomto článku budeme diskutovat o konverzích typů a o tom, jak je můžete použít k převodu mezi různými typy.

Převod do boolean

JavaScript použije typovou konverzi, jak bylo diskutováno v článku o Truthy a Falsy, k automatickému převodu různých hodnot boolean na pravda (true) nebo nepravda (false), když je to potřeba. Někdy však chcete skutečnou boolean hodnotu a pro to máme funkci Boolean(), která se pokusí daný vstup převést na boolean (true nebo false). Ve své nejzákladnější formě můžete převést číslo, např. 0 nebo 1, na boolean:

alert(Boolean(0) === true); // false
alert(Boolean(1) === true); // true

Ale můžete mu dodat i méně zřejmé hodnoty, jako jsou řetězce. V tomto případě obecně JavaScript převede věci, které by mohly být považovány za "prázdné" nebo nedefinované, na false, zatímco skutečné, neprázdné hodnoty budou převedeny na true. Zde je pár příkladů:

alert(Boolean("") === true); 		// false
alert(Boolean(null) === true); 		// false
alert(Boolean(undefined) === true); // false

alert(Boolean("hello") === true); 	// true
alert(Boolean("000") === true); 	// true

Převod na číslo

Někdy je potřeba zajistit, že pracujete s číselnými hodnotami. Například, pokud přijímáte vstup od uživatele, např. prostřednictvím funkce založené na prohlížeči prompt(), dostanete zpět řetězec, i když bylo zadáno číslo. To povede k neočekávaným výsledkům, pokud se pokusíte s tímto vstupem provádět matematiku, jak ilustruje tento příklad:

let n1 = 40;
// Example input: 2
let n2 = prompt("Please enter a number:");
// Example output: 402
alert(n1 + n2);

Protože metoda prompt vždy vrací řetězec, když přičteme dvě proměnné, JavaScript provede spojení řetězců místo skutečné matematiky. Takže pokud v promptu zadáte "2", výsledkem bude řetězec "402" místo čísla 42. Pokud tedy chceme zajistit, že bude vstup považován za číslo, musíme jej převést a můžeme to udělat pomocí funkce Number():

let n1 = 40;
// Example input: 2
let n2 = Number(prompt("Please enter a number:"));
// Example output: 42
alert(n1 + n2);

Funkce Number() je poměrně flexibilní. Kromě řetězců může přijímat také boolean hodnoty a hodnoty jako undefined a null a dokonce se pokusí vyčistit jakékoli řetězce od nesouvisejících znaků, jako jsou mezery, tabulátory, nové řádky atd. Pokud nemůže vstup převést na číselnou hodnotu, vrátí NaN (Not a Number, Není číslo). Zde jsou některé příklady, jak to funguje:

// 0
alert(Number(null));
// 1
alert(Number(true));
// 42
alert(Number("   042\t\n   "));
// NaN
alert(Number("forty-two"));

Převod na řetězec

Můžou nastat situace, kdy chcete zajistit, že pracujete také s řetězci. To obvykle není problém, protože většina typů může být snadno převedena na řetězce pomocí funkce String().

Výsledek funkce String() je poměrně snadno odhadnutelný, protože to bude jednoduše řetězcová reprezentace čehokoli, co do ní vložíte, včetně hodnot jako null, undefined atd. Zde jsou některé příklady:

// 42
alert(String(42));
// true
alert(String(true));
// null
alert(String(null));

let n1 = String(40);
let n2 = String(2);
// 402
alert(n1 + n2);

Věnujte zvláštní pozornost poslednímu příkladu, kde jasně vidíte, že jsme naše čísla převedli na řetězce tak, že jsou spojovány ("402") místo sčítání (42).

Shrnutí

Protože je JavaScript tak dynamický a flexibilní jazyk, pokud jde o typy, nemusíte se o ně téměř starat. Nicméně v některých situacích potřebujete zajistit, že pracujete se specifickým typem. Naštěstí pro nás je snadné převádět mezi primitivními datovými typy JavaScriptu, jak jsme viděli v tomto článku.