Typy dat

Hodnota v JavaScriptu je vždy určitého typu. Například řetězec nebo číslo.

V JavaScriptu existuje osm základních datových typů. Zde se jim budeme věnovat obecně a v dalších kapitolách si o každé z nich povíme podrobně.

Do proměnné můžeme vložit jakýkoli typ. Například proměnná může být v jednom okamžiku řetězec a poté uložit číslo:

// no error
let message = "hello";
message = 123456;

Programovací jazyky, které takové věci umožňují, jako je JavaScript, se nazývají „dynamicky typované“, což znamená, že existují datové typy, ale proměnné nejsou vázány na žádný z nich.

Číslo

let n = 123;
n = 12.345;

číslo typ představuje jak celá čísla, tak čísla s plovoucí desetinnou čárkou.

Pro čísla existuje mnoho operací, např. násobení * , divize / , dodatek + , odčítání - , a tak dále.

Kromě běžných čísel existují tzv. „speciální číselné hodnoty“, které také patří k tomuto datovému typu:Infinity , -Infinity a NaN .

• Infinity představuje matematické Nekonečno ∞. Je to speciální hodnota, která je větší než jakékoli číslo.

  Můžeme to získat jako výsledek dělení nulou:

  alert( 1 / 0 ); // Infinity

  Nebo na něj přímo odkazujte:

  alert( Infinity ); // Infinity

• NaN představuje výpočetní chybu. Je to výsledek nesprávné nebo nedefinované matematické operace, například:

  alert( "not a number" / 2 ); // NaN, such division is erroneous

  NaN je lepkavý. Jakákoli další matematická operace na NaN vrátí NaN :

  alert( NaN + 1 ); // NaN
  alert( 3 * NaN ); // NaN
  alert( "not a number" / 2 - 1 ); // NaN

  Pokud tedy existuje NaN někde v matematickém výrazu se to rozšíří na celý výsledek (existuje pouze jedna výjimka:NaN ** 0 je 1 ).

Matematika je v JavaScriptu „bezpečná“. Můžeme dělat cokoli:dělit nulou, považovat nenumerické řetězce za čísla atd.

Skript se nikdy nezastaví s fatální chybou („zemře“). V nejhorším dostaneme NaN jako výsledek.

Speciální číselné hodnoty formálně patří k typu „číslo“. Samozřejmě to nejsou čísla v běžném smyslu tohoto slova.

Více o práci s čísly uvidíme v kapitole Čísla.

BigInt

V JavaScriptu nemůže typ „číslo“ bezpečně reprezentovat celočíselné hodnoty větší než (253-1) (to je 9007199254740991 ), nebo méně než -(253-1) pro negativy.

Abychom byli opravdu přesní, typ „number“ může ukládat větší celá čísla (až 1.7976931348623157 * 10308 ), ale mimo bezpečný rozsah celých čísel ±(253-1) dojde k chybě přesnosti, protože ne všechny číslice se vejdou do pevného 64bitového úložiště. Lze tedy uložit „přibližnou“ hodnotu.

Například tato dvě čísla (přímo nad bezpečným rozsahem) jsou stejná:

console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992

Řekněme, že všechna lichá celá čísla větší než (253-1) nelze vůbec uložit v typu „číslo“.

Pro většinu účelů ±(253-1) rozsah je docela dost, ale někdy potřebujeme celý rozsah opravdu velkých celých čísel, např. pro kryptografii nebo časová razítka s přesností na mikrosekundu.

BigInt type byl nedávno přidán do jazyka, aby reprezentoval celá čísla libovolné délky.

A BigInt hodnota se vytvoří připojením n na konec celého čísla:

// the "n" at the end means it's a BigInt
const bigInt = 1234567890123456789012345678901234567890n;

Jako BigInt čísla jsou potřeba jen zřídka, zde se jimi nezabýváme, ale věnujeme jim samostatnou kapitolu BigInt. Přečtěte si to, když potřebujete tak velká čísla.

Právě teď, BigInt je podporováno ve Firefox/Chrome/Edge/Safari, ale ne v IE.

Můžete zkontrolovat MDN Tabulka kompatibility BigInt, abyste věděli, které verze prohlížeče jsou podporovány.

Řetězec

Řetězec v JavaScriptu musí být obklopen uvozovkami.

let str = "Hello";
let str2 = 'Single quotes are ok too';
let phrase = `can embed another ${str}`;

V JavaScriptu existují 3 typy uvozovek.

1. Dvojité uvozovky:"Hello" .
2. Jedné uvozovky:'Hello' .
3. Postup:`Hello` .

Dvojité a jednoduché uvozovky jsou „jednoduché“ uvozovky. V JavaScriptu mezi nimi není prakticky žádný rozdíl.

Backticks jsou uvozovky „rozšířené funkčnosti“. Umožňují nám vkládat proměnné a výrazy do řetězce jejich zabalením do ${…} , například:

let name = "John";

// embed a variable
alert( `Hello, ${name}!` ); // Hello, John!

// embed an expression
alert( `the result is ${1 + 2}` ); // the result is 3

Výraz uvnitř ${…} se vyhodnotí a výsledek se stane součástí řetězce. Můžeme tam vložit cokoliv:proměnnou jako name nebo aritmetický výraz jako 1 + 2 nebo něco složitějšího.

Vezměte prosím na vědomí, že to lze provést pouze pomocí zpětných znamének. Jiné citace tuto funkci vkládání nemají!

alert( "the result is ${1 + 2}" ); // the result is ${1 + 2} (double quotes do nothing)

Strunům se budeme podrobněji věnovat v kapitole Struny.

V některých jazycích existuje speciální typ „znaku“ pro jeden znak. Například v jazyce C a v Javě se nazývá „char“.

V JavaScriptu takový typ neexistuje. Existuje pouze jeden typ:string . Řetězec se může skládat z nula znaků (být prázdný), jednoho znaku nebo mnoha z nich.

Boolean (logický typ)

Booleovský typ má pouze dvě hodnoty:true a false .

Tento typ se běžně používá k ukládání hodnot ano/ne:true znamená „ano, správně“ a false znamená „ne, nesprávně“.

Například:

let nameFieldChecked = true; // yes, name field is checked
let ageFieldChecked = false; // no, age field is not checked

Booleovské hodnoty jsou také výsledkem porovnání:

let isGreater = 4 > 1;

alert( isGreater ); // true (the comparison result is "yes")

Logickým operátorům se budeme hlouběji věnovat v kapitole Logické operátory.

Hodnota „null“

Speciální null hodnota nepatří do žádného z výše popsaných typů.

Tvoří samostatný typ, který obsahuje pouze null hodnota:

let age = null;

V JavaScriptu null není „odkaz na neexistující objekt“ nebo „nulový ukazatel“ jako v některých jiných jazycích.

Je to jen speciální hodnota, která představuje „nic“, „prázdný“ nebo „neznámá hodnota“.

Výše uvedený kód uvádí, že age není známo.

Nedefinovaná hodnota

Speciální hodnota undefined také stojí stranou. Vytváří svůj vlastní typ, stejně jako null .

Význam undefined je „hodnota není přiřazena“.

Pokud je proměnná deklarována, ale není přiřazena, její hodnota je undefined :

let age;

alert(age); // shows "undefined"

Technicky je možné explicitně přiřadit undefined do proměnné:

let age = 100;

// change the value to undefined
age = undefined;

alert(age); // "undefined"

…Ale nedoporučujeme to dělat. Obvykle se používá null přiřadit proměnné „prázdnou“ nebo „neznámou“ hodnotu, zatímco undefined je rezervováno jako výchozí počáteční hodnota pro nepřiřazené věci.

Objekty a symboly

object typ je speciální.

Všechny ostatní typy se nazývají „primitivní“, protože jejich hodnoty mohou obsahovat pouze jednu věc (ať už je to řetězec nebo číslo nebo cokoli jiného). Naproti tomu objekty se používají k ukládání kolekcí dat a složitějších entit.

Jelikož jsou předměty tak důležité, zaslouží si zvláštní zacházení. Budeme se jimi zabývat později v kapitole Objekty, až se dozvíme více o primitivech.

symbol typ se používá k vytvoření jedinečných identifikátorů objektů. Musíme to zde zmínit pro úplnost, ale také odložit detaily, dokud nebudeme znát objekty.

Operátor typeof

typeof operátor vrací typ argumentu. Je to užitečné, když chceme hodnoty různých typů zpracovávat odlišně nebo jen chceme provést rychlou kontrolu.

Volání na číslo typeof x vrátí řetězec s názvem typu:

typeof undefined // "undefined"

typeof 0 // "number"

typeof 10n // "bigint"

typeof true // "boolean"

typeof "foo" // "string"

typeof Symbol("id") // "symbol"

typeof Math // "object" (1)

typeof null // "object" (2)

typeof alert // "function" (3)

Poslední tři řádky mohou vyžadovat další vysvětlení:

1. Math je vestavěný objekt, který poskytuje matematické operace. Naučíme se to v kapitole Čísla. Zde slouží pouze jako příklad objektu.
2. Výsledek typeof null je "object" . Toto je oficiálně uznaná chyba v typeof , pocházející z velmi raných dob JavaScriptu a uchovávané kvůli kompatibilitě. Určitě, null není objekt. Je to zvláštní hodnota s vlastním samostatným typem. Chování typeof je zde špatně.
3. Výsledek typeof alert je "function" , protože alert je funkce. Funkcemi se budeme zabývat v dalších kapitolách, kde také uvidíme, že v JavaScriptu neexistuje žádný speciální typ „funkce“. Funkce patří k typu objektu. Ale typeof zachází s nimi jinak a vrací "function" . To také pochází z počátků JavaScriptu. Technicky takové chování není správné, ale v praxi může být pohodlné.

Můžete se také setkat s jinou syntaxí:typeof(x) . Je to stejné jako typeof x .

Aby bylo jasno:typeof je operátor, ne funkce. Zde uvedené závorky nejsou součástí typeof . Je to druh závorek používaných pro matematické seskupování.

Obvykle takové závorky obsahují matematický výraz, například (2 + 2) , ale zde obsahují pouze jeden argument (x) . Syntakticky umožňují vyhnout se mezerám mezi typeof operátor a jeho argument a některým lidem se to líbí.

Někteří lidé preferují typeof(x) , ačkoli typeof x syntaxe je mnohem běžnější.

Shrnutí

V JavaScriptu existuje 8 základních datových typů.

• Sedm primitivních datových typů:
  • number pro čísla jakéhokoli druhu:celé číslo nebo s plovoucí desetinnou čárkou jsou celá čísla omezena ±(253-1) .
  • bigint pro celá čísla libovolné délky.
  • string pro struny. Řetězec může mít nula nebo více znaků, neexistuje žádný samostatný jednoznakový typ.
  • boolean pro true /false .
  • null pro neznámé hodnoty – samostatný typ, který má jednu hodnotu null .
  • undefined pro nepřiřazené hodnoty – samostatný typ, který má jednu hodnotu undefined .
  • symbol pro jedinečné identifikátory.
• A jeden neprimitivní datový typ:
  • object pro složitější datové struktury.

typeof operátor nám umožňuje vidět, který typ je uložen v proměnné.

• Obvykle se používá jako typeof x , ale typeof(x) je také možné.
• Vrátí řetězec s názvem typu, například "string" .
• Pro null vrátí "object" – toto je chyba v jazyce, ve skutečnosti to není objekt.

V dalších kapitolách se zaměříme na primitivní hodnoty a jakmile se s nimi seznámíme, přejdeme k objektům.