V JavaScriptu je jich celkem 6 typy dat:
— číslo číslo,
— provázek,
— logický (booleovský) datový typ boolean,
— nepřítomnost nedefinované hodnoty,
- Prázdnota, nic nula,
— Objekt objektu.

Těchto 6 datových typů se dělí na dva typy, jednoduché datové typy a složené (objektové) datové typy.

Jednoduché (primitivní) datové typy:číslo, řetězec, boolean, nedefinováno, null.
Složené (objektové) datové typy: objekt

Kompozitní datové typy jsou: objekt, funkce, pole (viz na konci článku).

Než se podíváme na jednotlivé typy dat, podívejme se nejprve na operátor typeof. Tento operátor umožňuje zjistit, jaký datový typ má proměnná, dělá se to takto:

Var název proměnné; NameName = hodnota; alert(typeofVariablename);

Typ dat: číslo

Číslo— číslo datového typu. Čísla mohou být buď celá, nebo s pohyblivou řádovou čárkou (zlomky, reálná, reálná čísla).

Var myNumber = 5; var myNumber2 = 5,5;

V JavaScriptu čísla s plovoucí desetinnou čárkou používají tečky, nikoli čárky :)

Alert(typeof myNumber); alert(typeof myNumber2);

V obou případech nám skript poskytne číselnou zprávu.

Typ dat: řetězec

Tětiva— řetězec datového typu. Chcete-li změnit hodnotu proměnné na řetězec, musí být uzavřena v uvozovkách: dvojitý „řetězec“ nebo jednoduchý „řetězec“. Pokud uzavřete číslo do uvozovek, jeho datový typ z čísla se změní na řetězec:

Var myString = "Dobrý den, jsem řetězec JavaScript"; var myString2 = "5";

Pomocí operátoru typeof kontrolujeme datový typ našich proměnných:

Alert(typeof myString); alert(typeof myString2);

V obou případech nám skript poskytne řetězec zprávy .

Typ dat: boolean

Boolean- logický (booleovský) datový typ, může mít pouze jednu ze dvou hodnot: true (true) nebo false (false). Hodnoty true nebo false se obvykle objevují při porovnávání nebo logických operacích.

Var myBoolean = true; var myBoolean2 = false;

Pomocí operátoru typeof kontrolujeme datový typ našich proměnných:

Alert(typeof myBoolean); alert(typeof myBoolean2);

V obou případech nám skript poskytne booleovskou zprávu.

Pokud je booleovský datový typ uzavřen v uvozovkách, jeho datový typ se změní z booleovského na řetězec.

Typ dat: nedefinováno

Nedefinováno— datový typ, který má pouze jednu hodnotu, nedefinovaný . Tento datový typ se objeví, když je proměnná deklarována, ale není inicializována, tzn. když proměnná (vlastnost objektu nebo prvku pole) nemá hodnotu.

// Deklaroval proměnnou, ale nepřiřadil jí hodnotu var myUndefined; // Pomocí operátoru typeof zkontrolujeme datový typ naší proměnné alert(typeof myUndefined);

Funkce upozornění() nám dá zprávu nedefinovanou.

Pokud je proměnné přiřazena hodnota undefined, pak její datový typ bude také nedefinovaný.

Var myUndefined2 = nedefinováno; alert(typeof myUndefined2);

Pokud je nedefinovaná hodnota ohraničena uvozovkami, její datový typ se změní z nedefinovaného na řetězec.

Typ dat: objekt

Objekt— datový typ objektu.

Var myObject; myObject = ( svoistvo: "znachenie", svoistvo2: "znachenie2", );

Pomocí operátoru typeof zkontrolujeme datový typ našeho objektu:

Alert(typeof myObject);

Skript nám poskytne objekt zprávy. Operátor typeof také zobrazí objekt pro pole a funkce (viz níže).

Typ dat: null

Nula je speciální datový typ označující prázdnotu (nic). Null je speciální prázdný objekt. Po klepnutí na tlačítko Storno při používání funkce se například může zobrazit nula výzva().

Var myNull = null; alert(typeof myNull);

Tento skript zobrazí objekt zprávy, níže si přečtěte, proč k tomu dochází.

Pokud je hodnota null uzavřena v uvozovkách, její datový typ se změní z null na řetězec.

Objasnění práce s typem operátora

Zde vám povím o některých úskalích, která existují v operátoru typeof, například když pracujete s null a s funkcemi, produkuje nesprávný datový typ, který často mate začátečníky. Níže jsem vytvořil malou tabulku ukazující, jak to funguje.

Proměnné v JavaScriptu jsou deklarovány pomocí klíčového slova var, Například:

Poté můžete nastavit hodnotu proměnné:

x = “Ukázkový řetězec”;

JavaScript vám umožňuje vytvářet proměnné za chodu, aniž byste je deklarovali, například:

y = “Druhý řetězec”;

Tím se vytvoří proměnná y a přidělí se pro ni místo v paměti, ale tato praxe znesnadňuje čtení a ladění skriptu.

V jazyce JavaScript proměnné nemají přesně definovaný typ, typ proměnné je určen daty, které ukládá. Například můžete
manifestovat proměnnou a přiřadit jí číslo a poté přiřadit řetězec.

JavaScript podporuje pět základních datových typů: Číslo– čísla; Tětiva– linky; Boolean– booleovský typ; Nedefinováno– nejistý; Nula- prázdný. Těchto pět datových typů se nazývá základní, protože... na jejich základě se budují složitější datové typy. Z hlediska ukládání dat jsou skutečně zajímavé tři: čísla, řetězce a booleany a v určitých situacích jsou zajímavé typy null a void.

Čísla

V JavaScriptu číselný datový typ zahrnuje celá čísla a reálná čísla. Celá čísla mohou nabývat hodnot z –2 53 před 2 53 , skutečné mohou nabývat velkých hodnot ±1,7976 x 10,308 nebo buď uvnitř přesný ±2,2250 x 10-308.

Čísla mohou být také zapsána v exponenciální formě.

Zaznamenat celek hexadecimální číslo na začátek se umístí nula a poté písmeno X, pak samotné číslo, které může obsahovat čísla od 0 před 9 a dopisy od A před F.

Čísla v hexadecimální soustavaČísla mohou být užitečná při použití bitových operací a také pro ukládání barev - pro Web jsou všechny barvy uloženy v šestnáctkové soustavě.

JavaScript má také schopnost psát čísla v osmičkovém číselném systému: napsat číslo na začátek, put 0 , pak pocházejí čísla z 0 před 7 .

Speciální čísla

Pokud je výsledek matematické operace mimo přijatelné meze, proměnná nabývá hodnoty Nekonečno- nekonečno. Při provádění jakýchkoli operací s takovým číslem bude výsledkem nekonečno. Při porovnávání je kladné nekonečno vždy větší než jakékoli reálné číslo a naopak záporné nekonečno je vždy menší než jakékoli reálné číslo.

Dalším důležitým zvláštním významem je NaN– „není číslo“. Typický příklad operace, která se vrací NaN, je dělení nulou. Chcete-li zjistit, zda je hodnota proměnnou NaN, funkce se používá isNaN(), který se vrací skutečný, pokud je číslo reálné (včetně nekonečna), a Nepravdivé, pokud je hodnota proměnné NaN.

Speciální čísla označují maximální a minimální hodnoty, které může proměnná nabývat. Všechna speciální čísla jsou uvedena v tabulce:

Struny

Řetězec je posloupnost znaků oddělená dvojitými nebo jednoduchými uvozovkami.

Jakmile je řetězec vytvořen, má jednu vlastnost − délka, vrací délku řetězce a velký počet metody:

charAt(index: Číslo) : Řetězec – vrátí znak umístěný na určité pozici;

konkat([řetězec1:Tětiva[, … [, řetězecN: Řetězec]]]]) : Řetězec – zřetězí řetězce (podobně jako operátor „+“);

indexOf(podřetězec:Tětiva[, startIndex: Číslo]) : Číslo – vrací počet výskytů podřetězce v řetězci nepovinným parametrem je číslo znaku, od kterého začíná hledání. Pokud podřetězec není nalezen, vrátí -1 . Vyhledávání se provádí zleva doprava pro vyhledávání zprava doleva se používá metoda lastIndexOf(), který má podobnou syntaxi;

nahradit(rgExp: RegExp, nahraditText: String) : String – nahradí regulární výraz řetězcem;

rozdělit([ oddělovač: (řetězec | RegExp) [, omezit: Číslo]]) : Pole – rozdělí řetězec na pole podřetězců. Prvním parametrem je oddělovač, na jehož základě se oddíl provádí, pokud není oddělovač zadán, vrátí se pole obsahující jeden prvek s původním řetězcem. Druhý parametr určuje maximální počet prvků ve vráceném poli;

substr(Start:Číslo [, délka: Číslo]) : Řetězec – vrátí podřetězec, který začíná na určité pozici a má určitou délku;

podřetězec(Start: Číslo, konec: Number) : String – Vrátí podřetězec, který začíná a končí na pozicích určených parametry.

Booleovský typ

Booleovské proměnné mohou nabývat jedné ze dvou hodnot: skutečný– pravda; Nepravdivé- lhát. V podmíněném příkazu se často používají booleovské proměnné -li. Příklad:

var doAlert = true;

if (doAlert) ( alert("Ahoj, světe!"); )

Proměnné typu Undefined a Null

Typ Nedefinováno používá se pro neexistující proměnné nebo proměnné, jejichž hodnoty ještě nebyly definovány. V následujícím příkladu proměnná X bude záležet Nedefinováno- to znamená, že není definován.

Typ Nula znamená prázdnou hodnotu. Příklad deklarace prázdné proměnné:

Pole

V JavaScriptu je pole uspořádanou sbírkou různých dat. Všechny prvky pole jsou očíslovány, první prvek pole má nulový index. Ke konkrétnímu prvku pole se přistupuje pomocí hranatých závorek a čísla tohoto prvku. Příklad:

myArr = "Ahoj!";

Deklarace prázdného pole a pole obsahujícího data:

var emptyArr =;

var fillArr = ["Ahoj", "Svět"];

Pole mohou být vícerozměrná. Oznámení a odvolání k vícerozměrné pole vypadá takto:

var myArr = [,,];

//vytvoří pole o velikosti 3x2 a zobrazí obsažený prvek
ve třetím řádku, ve druhém sloupci, rovno 6.

Protože pole je v podstatě objekt, lze jej deklarovat následovně.

V tomto tutoriálu si představíme velmi důležitý pojem – datové typy JavaScriptu. Doporučujeme pečlivě zvážit tento koncept– pokud si to neuvědomujete od samého začátku, budete se často muset potýkat s podivným chováním vámi vytvořeného programu.

Dynamické psaní

Probíhá počítačové programy manipulovat s různými hodnotami, z nichž každá může být zpracována v programovacím jazyce a patří ke specifickému datovému typu.

V Typy JavaScriptu Data lze rozdělit do dvou kategorií: jednoduché (také nazývané primitivní) typy a složené (také nazývané referenční nebo objektové).

JavaScript je slabě typovaný nebo dynamický programovací jazyk, který umožňuje definovat, analyzovat a kompilovat datové typy za běhu během provádění programu. To znamená, že nemusíte předem definovat typ proměnné. Typ bude určen automaticky během provádění programu.
V různých částech programu tedy může stejná proměnná nabývat hodnot různých typů:

Typy dat

Standard ECMAScript® definuje následující datové typy:

• Jednoduchý(nazývají se také primitivní) typy:
  • Boolean – může nabývat dvou možných hodnot, někdy nazývaných true a false;
  • null – hodnota null představuje odkaz, který obvykle záměrně ukazuje na neexistující nebo nesprávný objekt nebo adresu;
  • undefined – označuje předdefinovanou globální proměnnou inicializovanou nedefinovanou hodnotou;
  • číselné (anglické číslo) – číselný typ data v 64bitovém formátu s plovoucí desetinnou čárkou s dvojitou přesností;
  • string (angl. String) – je posloupnost znaků sloužících k reprezentaci textu;
  • symbol (angl. Symbol) je datový typ, jehož instance jsou jedinečné a neměnné. (novinka v ECMAScript 6).
• Objekt(anglicky Object) je kolekce pojmenovaných hodnot, které se obvykle nazývají vlastnosti (vlastnosti) objektu.

Rozdíl mezi primitivními a kompozitními typy

Než se podíváme na jednotlivé typy dat, podívejme se nejprve na operátor typeof. Operátor typeof vrací řetězec popisující datový typ proměnné.
Ukažme si, jak to funguje, na následujícím příkladu:

Ukázkový skript deklaruje proměnné, inicializuje je (přiřazuje hodnoty) a poté vypíše typ každé proměnné.

Rozdíl mezi primitivními a složenými datovými typy nastává, když jsou jejich hodnoty zkopírovány.

Když je proměnné přiřazena hodnota jednoduchého typu, zapíše se do proměnné samotná hodnota (například číslo). Když jsme přiřadit proměnnou jednoduchého typu k té druhé, ona kopíruje hodnotu. V důsledku toho bude mít každá proměnná jeho význam a změny v jedné z proměnných nemá žádný účinek na hodnotě jiné proměnné:

Když proměnná přiřadit hodnotu kompozitu(referenční) typ, pak se proměnná zapíše odkaz vážit si ( odkaz na objekt). Když přiřadíme jednu proměnnou (jejíž hodnota obsahuje odkaz na složenou hodnotu) jiné proměnné, stane se to kopírovat odkaz na složenou hodnotu. Jako výsledek obě proměnné odkazují na stejnou složenou hodnotu a změny hodnoty jedné z proměnných bude mít dopad na jiné proměnné:

Primitivní typy

Všechny datové typy v JavaScriptu, kromě objektů, jsou neměnné nebo neměnné. To znamená, že jejich hodnoty nelze upravit, ale pouze přepsat novou, jinou hodnotou. Řetězce například nelze upravovat znak po znaku – lze je pouze zcela přepsat. Hodnoty těchto typů se nazývají "primitivní".

Nejjednodušší data, se kterými může program pracovat, se nazývají literály. Literály jsou čísla nebo řetězce, které se používají k reprezentaci hodnot v JavaScriptu. Poskytované informace mohou být velmi různorodé, a proto se jejich významy liší různé typy. Nejjednodušší datové typy v JavaScriptu se nazývají základní datové typy: čísla, řetězce a booleany. Všechny jsou klasifikovány jako „primitivní“.

Booleovský (logický) typ „boolean“

Logické neboli booleovské hodnoty (podle jména jejich vynálezce - Boolean) mohou mít pouze jednu ze dvou hodnot: true (true) nebo false (false). Hodnoty true nebo false se obvykle objevují při porovnávání nebo logických operacích.

Následující program vytvoří booleovskou proměnnou a poté otestuje její hodnotu pomocí příkazu if/else:

Jako srovnávací výraz lze použít jakýkoli výraz. Jakýkoli výraz, který vrací 0, null, undefined nebo prázdný řetězec, je interpretován jako false . Výraz, který určuje jakoukoli jinou hodnotu, je interpretován jako true .

Poznámka: Při zápisu booleovských hodnot nejsou uzavřeny v uvozovkách: var myVar = true;
Zároveň deklarováním var myVar = "true" vznikne řetězcová proměnná.

Typ dat čísla

V JavaScriptu není žádný rozdíl mezi celým číslem a číslem s pohyblivou řádovou čárkou – v podstatě JavaScript představuje všechna čísla jako hodnotu s pohyblivou řádovou čárkou.

JavaScript používá k reprezentaci čísel 64bitový formát definovaný standardem IEEE-754. Tento formát je schopen reprezentovat čísla v rozsahu ±1,7976931348623157 × 10308 až ±5 × 10 -324.

Číslo nalezené přímo v kódu programu se nazývá číselný literál. Kromě dekadických celočíselných literálů JavaScript rozpoznává hexadecimální hodnoty.
Hexadecimální čísla mohou obsahovat libovolnou posloupnost čísel od 0 do 9 a písmen od a do f, která musí začínat posloupností znaků "0x".

Var a = 255; var b = 0xFF; // Číslo 255 v hexadecimálním zápisu

JavaScript navíc obsahuje speciální číselné hodnoty:

• NaN (nejedná se o chybu čísla nebo výpočtu). Je výsledkem nesprávné matematické operace s neplatnými daty, jako jsou řetězce nebo nedefinovaná hodnota.
• Nekonečno (kladné nekonečno). Používá se, pokud kladné číslo je příliš velký na to, aby byl reprezentován v JavaScriptu.
• -Nekonečno (záporné nekonečno). Používá se, když je záporné číslo příliš velké na to, aby bylo reprezentováno v JavaScriptu.
• ±0 (kladná a záporná 0). JavaScript rozlišuje kladnou a zápornou nulu.

Datový typ řetězce

Typ řetězce je neměnná, uspořádaná sekvence 16bitových hodnot, z nichž každá představuje Unicode znak(písmena, číslice, interpunkční znaménka, Speciální symboly a mezery). Řádky mohou být prázdné nebo mohou obsahovat jeden nebo více znaků. Řetězce se vytvářejí pomocí dvojitých (") nebo jednoduchých (") uvozovek. Řetězec oddělený dvojicí jednoduchých uvozovek může používat dvojité uvozovky a naopak jednoduché uvozovky lze použít v řetězci uzavřeném dvojicí dvojitých uvozovek:

V JavaScriptu není rozdíl mezi dvojitými a jednoduchými uvozovkami, ale uvozovky na začátku a na konci řetězce by se neměly lišit. Například výraz jako tento by způsobil chybu syntaxe:

var firstName = "Max"; // chyba syntaxe- různé citáty

Poznámka: JavaScript nemá speciální jednoznakový datový typ jako char v C, C++ a Java. Jeden znak je reprezentován řetězcem o jednotkové délce.

Datový typ Null

Typ null obsahuje jedinou speciální hodnotu – null.

Klíčové slovo null nelze použít jako název funkce nebo proměnné. Hodnota null je odkaz na "prázdný" objekt a má speciální účel - obvykle se používá k inicializaci proměnné, které bude později přiřazena hodnota.

Operátor typeof na null vrací řetězec "object", což znamená, že null je speciální "prázdný" objekt.

Nedefinovaný datový typ

Nedefinovaný typ tvoří svůj vlastní typ, který obsahuje jedinou speciální hodnotu - undefined. Toto je hodnota proměnné deklarovaná pomocí operátoru var, ale neinicializovaná:

Hodnota undefined je vrácena při přístupu k proměnné, které nikdy nebyla přiřazena hodnota, neexistující vlastnost objektu nebo prvek pole.

Je třeba poznamenat, že proměnná s nedefinovanou hodnotou se liší od proměnné, která není definována vůbec:

V tomto příkladu metoda alert() zobrazuje hodnotu proměnné stáří, která není definována. Ve druhém případě je do metody alert() předána nedeklarovaná proměnná auta, což vede k chybě.

Následující příklad může být pro začínající programátory poněkud matoucí, protože... Operátor typeof vrací hodnotu undefined pro neinicializovanou i nedeklarovanou proměnnou:

Ve výše uvedeném příkladu je proměnná stáří deklarována, ale nic se do ní nezapisuje, takže její hodnota je pouze nedefinovaná . Proměnná auto není deklarována – ve skutečnosti neexistuje. Typeof však v obou případech vrátí řetězec nedefinovaný. To samozřejmě dává určitý smysl, protože s žádnou z těchto proměnných nelze provádět žádné operace, ačkoliv jsou technicky zcela odlišné.

Poznámka: Doporučuje se vždy inicializovat deklarovanou proměnnou. V tomto případě budete vědět, že operátor typeof vrací nedefinovaný, protože proměnná nebyla deklarována, nikoli proto, že nebyla inicializována.

Hodnota undefined je odvozena z null , takže v ECMA-262 je operátor ekvivalence == považuje za rovné:

Přestože hodnoty null a undefined spolu souvisí, používají se odlišně. Nemělo by být přiřazeno explicitně proměnná hodnota undefined , ale tento požadavek se nevztahuje na null. V případě, že požadovaný objekt není k dispozici, použijte místo něj hodnotu null. To znamená, že null byl zaveden jako ukazatel na prázdný objekt a zdůrazňuje jeho rozdíl od undefined .

K rozlišení mezi hodnotou null a undefined v programu můžete použít operátor identity === :

Datový typ Symbol

Symbol je novým přírůstkem do JavaScriptu od ECMAScript verze 6. Symbol je jedinečná, neměnná, primitivní hodnota, která se používá k vytváření jedinečných identifikátorů.

Chcete-li vytvořit symbol, musíte zavolat funkci Symbol:

var mySymbol = Symbol();

Chcete-li definovat symbol, můžete použít operátor typeof, pokud je hodnotou symbol, bude vrácen řetězec:

Funkce Symbol má volitelný parametr – řetězec, který slouží k popisu symbolu:

Název vlastnosti je řetězec, takže objekty lze považovat za asociované řetězce s hodnotami. Tyto informace společně tvoří páry klíč–hodnota.

V JavaScript objekty lze vytvořit pomocí jedné ze dvou syntaxí:

1. var obj = (); // pomocí objektového literálu 2. var obj = new Object(); // pomocí metody zvané konstruktor

Vytvoření objektu pomocí objektového literálu začíná definováním běžné proměnné. Pravá strana tohoto příkazu zapisuje objektový literál - toto je čárkami oddělený seznam párů uzavřených ve složených závorkách (). "jméno-hodnota", uzavřený ve složených závorkách. Název vlastnosti a hodnota jsou odděleny dvojtečkou:

var cat = ("nohy": 4, "jméno": "Murzik", "barva": "Červená" )

Druhým způsobem vytváření objektů je použití konstruktoru Object(). V tomto případě se nejprve použije nový výraz Object() a poté se definují a inicializují vlastnosti výsledného objektu:

Když přiřadíme jednu proměnnou (jejíž hodnota obsahuje odkaz na složenou hodnotu) k jiné proměnné, odkaz na složenou hodnotu se zkopíruje. Výsledkem je, že obě proměnné odkazují na stejnou složenou hodnotu a změny v hodnotě jedné proměnné ovlivní druhou proměnnou.

Jakýkoli výraz, který vrací 0, null, undefined nebo prázdný řetězec, je interpretován jako false .

Řetězce se vytvářejí pomocí dvojitých (") nebo jednoduchých (") uvozovek. Řetězec oddělený dvojicí jednoduchých uvozovek může používat dvojité uvozovky a naopak jednoduché uvozovky lze použít v řetězci uzavřeném dvojicí uvozovek.

Hodnota null je odkaz na "prázdný" objekt a má speciální účel - obvykle se používá k inicializaci proměnné, které bude později přiřazena hodnota.

Hodnota (undefined) je proměnná deklarovaná pomocí operátoru var, ale neinicializovaná.

V JavaScriptu lze objekty vytvářet jedním ze dvou způsobů:

• pomocí objektového literálu
• pomocí metody zvané konstruktor

Objekt obsahuje neuspořádanou kolekci vlastností, z nichž každá obsahuje název a hodnotu. K objektu můžete kdykoli přidat nové pojmenované hodnoty nebo odstranit stávající.

V JavaScriptu lze hodnoty zcela volně (explicitně i implicitně) převádět z jednoho typu na druhý. Například pokud nějaký operátor očekává, že obdrží hodnotu určitý typ a je mu předána hodnota jiného typu, interpret se automaticky pokusí provést převody na požadovaný typ:

Console.log(10 + "stroje"); // "10 aut". Číslo je implicitně převedeno na řetězec console.log("7" * "4"); // 28. Oba řetězce jsou implicitně převedeny na čísla

Implicitní konverze- to je, když tlumočník automaticky provádí konverzi typu, to znamená bez účasti programátora. Explicitní konverze- tehdy převod provádí sám programátor. Explicitní konverze se také nazývá typové odlévání:

Console.log("7" * "4"); // 28. Implicitní konverze console.log(Number("7") * Number("4")); // 28. Explicitní konverze

Níže uvedená tabulka popisuje, jak JavaScript převádí hodnoty z jednoho typu na jiný. Prázdné buňky odpovídají situacím, kdy není nutná konverze:

Význam	Převést na:
	Tětiva	Číslo	Boolean	Objekt
nedefinováno nula	"nedefinováno" "nula"	NaN 0	Nepravdivé Nepravdivé	typ chybyChyba typ chybyChyba
skutečný Nepravdivé	"skutečný" "Nepravdivé"	1 0		nový booleovský (pravda) nový booleovský (nepravda)
"" (prázdný řádek) "1.2" "jeden" "-10" "+10" "011" "0xff"		0 1.2 NaN -10 10 11 255	Nepravdivé skutečný skutečný skutečný skutečný skutečný skutečný	nový řetězec("") nový řetězec ("1.2") nový řetězec ("jeden") nový řetězec ("-10") nový řetězec("+10") nový řetězec("011") nový řetězec("0xff")
0 -0 NaN Nekonečno -Nekonečno 3	"0" "0" "NaN" "Nekonečno" "-Nekonečno" "3"		Nepravdivé Nepravdivé Nepravdivé skutečný skutečný skutečný	nové číslo(0) nové číslo (-0) nové číslo (NaN) nové číslo (nekonečno) nové číslo (-nekonečno) nové číslo (3)
() (jakýkoli předmět) (prázdné pole) (1 číselný prvek) arr (jakékoli jiné pole) function()() (libovolná funkce)	viz Konverze objektů "" "9" viz Konverze objektů viz Konverze objektů	viz Konverze objektů 0 9 NaN NaN	skutečný skutečný skutečný skutečný skutečný

Pro explicitní převod na jednoduché typy se používají následující funkce: Boolean(), Number(), String(). Pro implicitní převod používá interpret stejné funkce, jaké se používají pro explicitní převod.

Pro explicitní převod můžete místo funkcí použít operátory. Pokud je například jeden z operandů operátoru + řetězec, pak se druhý operand také převede na řetězec. Unární operátor + převede svůj operand na číslo. Unární operátor! převede operand na booleovskou hodnotu a invertuje ji. To vše se stalo důvodem pro vznik následujících unikátních metod typové konverze, které lze nalézt v praxi:

X + "" // Stejné jako String(x) +x // Stejné jako Číslo(x). Můžete také vidět x - 0 !!x // Stejné jako Boolean(x)

Převést na čísla

Funkce Number() převádí hodnoty podle následujících pravidel:

• Booleovské hodnoty true a false jsou převedeny na 1, respektive 0.
• Čísla jsou vrácena beze změny.
• Hodnota null se převede na 0 .
• Nedefinovaná hodnota se převede na NaN.

Pro řetězce platí zvláštní pravidla:

• Pokud řetězec obsahuje pouze číslice se znaménkem + nebo - na začátku nebo bez znaménka, vždy se převede na celé desítkové číslo. Úvodní nuly jsou ignorovány, například „0011“ se převede na 11.
• Pokud je řetězec číslem s plovoucí desetinnou čárkou s úvodním znaménkem + nebo - nebo bez znaménka, převede se na odpovídající číslo s plovoucí desetinnou čárkou (počáteční nuly jsou také ignorovány).
• Pokud je řetězec hexadecimální číslo, převede se na odpovídající dekadické celé číslo.
• Pokud je řetězec prázdný, převede se na 0.
• Pokud řetězec obsahuje něco jiného než předchozí možnosti, převede se na NaN.
• Metoda valueOf() je volána na objektech a hodnota, kterou vrací, je automaticky převedena podle předchozích pravidel. Pokud tento převod vyústí v NaN, zavolá se metoda toString() a použijí se pravidla pro převod řetězců na čísla.

Unární operátory + a - se řídí stejnými pravidly jako funkce Number().

Převod na booleovské hodnoty

Funkce Boolean() převede hodnotu na její booleovský ekvivalent:

• Následující hodnoty jsou převedeny na false: undefined , null , 0 , -0 , NaN , "" .
• False je vrácena beze změny.
• Všechny ostatní hodnoty jsou převedeny na true .

Převést na řetězce

Funkce String() převádí hodnoty podle následujících pravidel:

• Pro všechny hodnoty jiné než null a undefined se automaticky zavolá metoda toString() a vrátí se řetězcová reprezentace hodnoty.
• Pro hodnotu null je vrácen řetězec "null".
• Pro hodnotu undefined je vrácen řetězec "undefined".

Převod jednoduchých typů na objekty

Pro převod jednoduchých hodnot na objekty se používají konstruktory Boolean() , Number() , String():

Var oNum = new Number(3); var oStr = new String("1.2"); var oBool = new Boolean(true); alert(typeof oNum); // "objekt" alert(typeof oStr); // "objekt" alert(typeof oBool); // "objekt"

Převod objektů na jednoduché hodnoty

Všechny objekty dědí dvě metody převodu: toString() a valueOf() .

Metoda toString() vrací řetězcovou reprezentaci objektu. Ve výchozím nastavení nevrací nic zajímavého:

Alert((x: 1).toString()); // ""

Některé typy mají specializovanější verze metody toString(). Například metoda toString() v poli převede všechny jeho prvky na řetězce a poté je zřetězí do jednoho řetězce a vloží mezi ně čárky:

Alert(.toString()); // "1,2,3"

Účel metody valueOf() je méně jasně definován: předpokládá se, že převede objekt na jednoduchou hodnotu, která jej reprezentuje, pokud taková hodnota existuje. Objekty jsou ze své podstaty složené hodnoty a většinu objektů nelze reprezentovat jako jedna jednoduchá hodnota, takže ve výchozím nastavení metoda valueOf() vrací odkaz na ni, nikoli jednoduchou hodnotu:

Alert(typeof (x:2).valueOf()); // "objekt"

Při převodu objektu na řetězec provede interpret JavaScriptu následující:

• Pokud má objekt metodu toString(), interpret ji zavolá. Pokud vrátí jednoduchou hodnotu, interpret převede hodnotu na řetězec (pokud to není řetězec) a vrátí výsledek převodu.
• Pokud objekt nemá metodu toString() nebo metoda nevrací jednoduchou hodnotu, pak interpret zkontroluje přítomnost metody valueOf(). Pokud je tato metoda definována, interpret ji zavolá. Pokud vrátí jednoduchou hodnotu, překladač tuto hodnotu převede na řetězec (pokud to není řetězec) a vrátí výsledek převodu.

Při převodu objektu na číslo provede interpret totéž, ale nejprve vyzkouší metodu valueOf():

• Pokud má objekt metodu valueOf(), která vrací jednoduchou hodnotu, interpret převede (v případě potřeby) tuto hodnotu na číslo a vrátí výsledek.
• Pokud objekt nemá metodu valueOf() nebo metoda nevrací jednoduchou hodnotu, pak interpret zkontroluje přítomnost metody toString(). Pokud má objekt metodu toString(), která vrací jednoduchou hodnotu, interpret provede převod a vrátí výslednou hodnotu.
• V opačném případě dojde k závěru, že ani toString() ani valueOf() nemohou získat jednoduchou hodnotu a vyvolá TypeError .

Metody toString() a valueOf() jsou pro čtení/zápis, takže je můžete přepsat a explicitně určit, co bude vráceno při převodu:

Var obj = (); obj.toString = function() ( return "object"; ); alert("Toto je " + obj); // "Toto je objekt"

JavaScript nebo JS(zkráceně) není jednoduchý jazyk a začínající vývojáři se o něm hned tak nedozví. Nejprve se naučí základy a vše se jim zdá barevné a krásné. Když půjdeme trochu hlouběji, objeví se pole JavaScriptu, objekty, zpětná volání a všechno podobné, což vám často vyrazí dech.

V JavaScriptu je důležité správně zkontrolovat typ proměnné. Řekněme, že chcete vědět, zda je proměnná pole nebo objekt? Jak to správně zkontrolovat? V tomto konkrétním případě existují triky při ověřování a tento příspěvek bude o nich. Začněme hned.

Kontrola typu proměnné

Potřebujete například zkontrolovat, zda je proměnná objekt, pole, řetězec nebo číslo. Můžete k tomu použít typeof, ale ne vždy bude říkat pravdu a v příkladu níže ukážu proč.

Napsal jsem tento příklad, abych jasně ukázal, proč typeof není vždy tou správnou volbou.

Var _comparison = ( string: "string", int: 99, float: 13.555, object: (ahoj: "ahoj"), pole: new Array(1, 2, 3) ); // Vrátí pole s klíči objektu var _objKeys = Object.keys(_comparison); for(var i = 0; i<= _objKeys.length - 1; i++) { // выведем в консоль тип каждой переменной console.log(typeof _comparson[_objKeys[i]]); }

Výsledek spuštění kódu:

Objekt řetězec číslo číslo objektu

Že jo? - Samozřejmě že ne. Problémy jsou dva. Každý z nich bude podrobně popsán a navrženo řešení.

První problém: plovoucí číslo, výstup jako číslo

Comparison.float není číslo a číslo by mělo být plovoucí desetinnou čárkou (číslo s plovoucí desetinnou čárkou), můžete vytvořit funkci se zaškrtnutím jako v kódu níže.

Var_floatNumber = 9,22; var _notFloatNumber = 9; console.log(isFloat(_floatNumber)); console.log(isFloat(_notFloatNumber)); console.log(isFloat("")); function isFloat(n)( return Number(n) === n && n % 1 !== 0; )

Funkce isFloat() kontroluje, zda jsou všechny hodnoty s pohyblivou řádovou čárkou. Nejprve se zkontroluje, zda je proměnná rovna nčíslo (Number(n) === n) a pokud ano, tak se provede další kontrola na dělení se zbytkem a pokud je tam zbytek, tak boolean ( skutečný nebo Nepravdivé) výsledek (n % 1 !== 0).

Ve výše uvedeném příkladu se vrací skutečný, Nepravdivé A Nepravdivé. První význam je plovák typ, druhý není - je to běžné číslo a poslední je jen prázdný řetězec, který neodpovídá pravidlům.

Druhý problém: pole bylo definováno jako objekt

V úplně prvním příkladu bylo pole zobrazeno jako objekt a to není moc dobré, protože někdy potřebujete použít přesně tento typ a nic jiného.

Existuje několik způsobů, jak zkontrolovat, zda je proměnná typu pole.

První možnost (dobrá možnost). Zda data patří do pole kontrolujeme pomocí instanceof().

Var data = new Array("ahoj", "svět"); var isArr = instance dat pole;

Druhá možnost (dobrá možnost). Metoda Array.isArray() vrací booleovskou hodnotu, která bude záviset na tom, zda je proměnná pole nebo ne ().

Var data = new Array("ahoj", "svět"); var isArr = Array.isArray(data);

Třetí možnost (nejlepší, ale dlouhá). Pro pohodlí můžete z této metody udělat funkci. Pomocí Object děláme . Pokud se výsledek Object.prototype.toString.call(data) nerovná, pak proměnná není pole ().

Var data = new Array("ahoj", "svět"); var isArr = Object.prototype.toString.call(data) == ""; console.log(isArr);

Poslední výsledek v podobě komfortní funkce:

Funkce isArray(data) ( return Object.prototype.toString.call(data) == "" )

Nyní můžete zavolat funkce isArray() a nastavit pole nebo něco jiného jako argument a vidět výsledek.

Doslov

Nahrávka se ukázala být docela velká, než bylo původně zamýšleno. Ale těší mě, protože celkem stručně a jasně popisuje potíže při kontrole proměnných v JavaScriptu a jak je obejít.

Pokud máte ještě nějaké dotazy, napište je níže pod tento záznam. Rád pomohu.