Datové typy JavaScriptu. Datové typy JavaScriptu Proměnné a datové typy JavaScriptu

Začněme jako obvykle definicí toho, co známe. Co jsou datové typy? Tento koncept platí pro všechny programovací jazyky a JavaScript zde není ojedinělý. Pokud se odkážeme na definici Wikipedie, dozvíme se, že datové typy jsou sada hodnot a operací s těmito hodnotami. Jednoduše řečeno, datový typ je v podstatě typ hodnoty, kterou můžeme uložit do proměnné a pracovat s ní.

V článku Proměnné JavaScriptu jsme porovnali proměnnou s krabicí, do které můžete vložit cokoliv. Ve skutečnosti je to cokoli a existuje hodnota jakéhokoli datového typu. I když neznáte žádný programovací jazyk, intuitivně si myslím, že nyní můžete pojmenovat alespoň dva datové typy, které jsou v JavaScriptu. Přesně tak, je to číslo a řetězec, nebo řetězec a číselný datový typ. Pamatujete si, že jsme do proměnné zapsali jak řetězce, tak čísla? Jediný rozdíl je v tom, že jsme museli řetězec uzavřít do uvozovek.

V JavaScriptu tedy existuje šest datových typů:

JavaScript. Rychlý start

boolean nebo booleovská hodnota

Pojďme se rychle podívat na každý z těchto typů. Začněme datovým typem string. Řetězec je možná jedním z nejčastěji používaných datových typů. S řetězci se setkáváme neustále: přihlášení uživatele je řetězec, název produktu je řetězec, název článku je řetězec atd.

Jak si pamatujete, řetězec musí být uzavřen v jednoduchých nebo dvojitých uvozovkách. Mezi typy uvozovek není žádný rozdíl, v JavaScriptu plní jednoduché i dvojité uvozovky stejnou funkci a neliší se, řekněme, na rozdíl od PHP, kde jsou názvy proměnných zpracovávány v uvozovkách. Příklad řádku:

var jméno = "Jan", příjmení = "Laň";

JavaScript. Rychlý start

Naučte se základy JavaScriptu s praktickou ukázkou tvorby webové aplikace

U řetězců je vše jasné, pojďme dál – číslo nebo číselný datový typ. V JavaScriptu jsou celá čísla a čísla s plovoucí desetinnou čárkou (zlomková čísla) stejného typu, čísla. K ukládání a zápisu čísel nejsou uvozovky potřeba, navíc jsou zbytečné a někdy mohou vést k neočekávaným výsledkům v matematických operacích. Příklad zápisu čísel v JavaScriptu:

var num1 = 2, num2 = 3,4 num3 = -5;

Upozorňujeme, že zlomková část čísla není oddělena čárkou, ale tečkou (desetinnou čárkou). Číslo lze také podepsat: -5 v příkladu.

Řetězec a číslo jsou běžné datové typy v JavaScriptu. Další čtyři typy vám možná ještě nejsou jasné, ale o něco později, až začneme blíže pracovat s kódem, v praxi pochopíte, jak pracovat se zbývajícími datovými typy.

Takže booleovský typ nebo booleovský datový typ. Má pouze dvě možné hodnoty: true a false. Pro zjednodušení je lze porovnat se slovy „ano“ a „ne“ nebo „pravda“ a „nepravda“. Příklad zápisu booleovských hodnot v JavaScriptu:

var ano = pravda, ne = nepravda;

Všimněte si, že true a false rozlišují malá a velká písmena. V PHP například konstanty true a false nerozlišují malá a velká písmena.

Další dvě speciální hodnoty jsou null a nedefinované. Jsou si velmi podobné a v podstatě znamenají totéž – absenci smyslu. undefined bude hodnota proměnné, která je právě deklarována, ale není nastavena na hodnotu, tzn. hodnota není definována. null se často zapisuje do proměnné, aby vynuloval hodnotu proměnné, aby byla takříkajíc neznámá. V následujících článcích se podrobněji podíváme na specifika práce s těmito datovými typy v JavaScriptu.

No a posledním typem je objekt. Pokud bychom porovnávali proměnnou s krabicí, pak lze objekt porovnat se sadou krabic nebo vhodněji například s katalogem krabic v knihovně. Každá krabice je podepsaná a každá obsahuje něco svého. Na objekty se podíváme blíže později, ale nyní se podívejme, jak můžete deklarovat objekt a jak získat přístup k hodnotám, které jsou do něj zapsány.

// položka objektu var user = ( jméno: "Jan", příjmení: "Doe", rok: 2016 ); // přístup k vlastnostem objektu alert(user.name); alert(uživatel.příjmení); upozornění(uživatel. rok);

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";

Jazyk 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 JavaScriptu nemají proměnné pevný typ, typ proměnné je určen daty, které ukládá. Například můžete
vystavit 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- čáry; Boolean– booleovský typ; Nedefinováno- neurčitý; Nula- prázdný. Těchto pět datových typů se nazývá základní datové typy, protože na jejich základě jsou stavěny složitější datové typy. Z hlediska ukládání dat jsou zajímavé tři: čísla, řetězce a booleany a nedefinované a prázdné typy jsou v určitých situacích zajímavé.

Čísla

V JavaScriptu zahrnuje číselný datový typ 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 10308 nebo být přesný uvnitř ±2,2250 x 10-308.

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

Chcete-li napsat celé hexadecimální číslo, na začátek se vloží nula a poté písmeno X, pak samotné číslo, které může obsahovat číslice od 0 před 9 a dopisy od A před F.

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

Jazyk JavaScript má také schopnost psát čísla v osmičkovém číselném systému: pro zapsání čísla se umístí na začátek 0 , následují čísla od 0 před 7 .

Speciální čísla

Pokud je výsledek matematické operace mimo rozsah, 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 srovná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ší důležitou speciální hodnotou je NaN- "not a number" (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ý je-li číslo reálné (včetně nekonečna), a Nepravdivé pokud je hodnota proměnné NaN.

Speciální čísla jsou 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.

Po vytvoření má řetězec jednu vlastnost − délka, který vrací délku řetězce a velké množství metod:

charAt(index: Číslo) : Řetězec - vrátí znak na konkrétní pozici;

konkat([řetězec1:Tětiva[, … [, řetězecN: Řetězec]]]]) : Řetězec - spojuje řetězce (podobně jako operátor "+");

indexOf(podřetězec:Tětiva[, startIndex: Číslo]) : Číslo - vrací číslo výskytu 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í se -1 . Vyhledávání se provádí zleva doprava, pro hledá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ů. Jako první parametr je předán oddělovač, na jehož základě se provede rozdělení, 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: Číslo) : Řetězec - vrací 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- tedy není definován.

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

Pole

V JavaScriptu je pole uspořádaná kolekce různých dat. Všechny prvky pole jsou očíslovány, první prvek pole má nulový index. Přístup ke konkrétnímu prvku pole se provádí 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á. Deklarace a přístup k vícerozměrnému poli vypadá takto:

var myArr = [,,];

//vytvoří pole 3x2 a vypíše 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 JavaScriptu lze hodnoty zcela volně (explicitně i implicitně) převádět z jednoho typu na druhý. Pokud například nějaký operátor očekává, že obdrží hodnotu určitého typu, a je mu předána hodnota jiného typu, pak se interpret automaticky pokusí provést převody na požadovaný typ:

Console.log(10 + "auta"); // "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, tj. bez účasti programátora. Explicitní konverze- to je, když programátor sám provádí transformaci. Explicitní konverze je také známá jako 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 konverze není nutná:

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 vedlo ke vzniku následujících zvláštních typů typových přestaveb, 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 s úvodním + nebo - nebo bez znaménka, je vždy převeden 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 + nebo - nebo žádným znaménkem, 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ý, bude převeden na 0 .
• Pokud řetězec obsahuje něco jiného než předchozí možnosti, převede se na NaN .
• U objektů je volána metoda valueOf() 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 - fungují stejně jako funkce Number().

Booleovská konverze

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

• Následující hodnoty se při převodu vyhodnotí jako nepravda: undefined , null , 0 , -0 , NaN , "" .
• Hodnota 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 kromě 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 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():

oNum = nové Číslo(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 jediného řetězce a vloží mezi ně čárky:

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

Účel metody valueOf() není tak jasně definován: má převést 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() nevrací jednoduchou hodnotu, ale odkaz na ni:

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 řetězec není) a vrátí výsledek převodu.
• Pokud objekt nemá metodu toString() nebo pokud tato metoda nevrací jednoduchou hodnotu, pak interpret zkontroluje existenci 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 stejné akce, ale nejprve se pokusí použít 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 pokud tato 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.
• Jinak interpret vyvozuje, že ani toString() ani valueOf() neposkytne 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"

Rozhodl jsem se napsat sérii článků s názvem „Obtížné asi jednoduché“. Tento cyklus bude věnován jazyku JavaScript. Proč "obtížné nebo jednoduché"? Protože vše, co řeknu, řeknu s přihlédnutím ke zvláštnostem tlumočníka, počínaje datovými typy. To vše bude provedeno tak, aby později bylo možné hovořit jednoduše o komplexu, například o metodách dědičnosti v JavaScriptu a dalších vzorech.

JavaScript je objektově orientovaný programovací jazyk s prototypovou organizací.
Co znamená „s prototypovou organizací“ si povíme v příštím článku (určitě bude), ale proč je „objektově orientovaná“ a zda je vše v JS objekt, to zjistíme dnes.
JS potřebuje ke splnění svého účelu pouze 9 typů. Programu je navíc k dispozici pouze 6 z nich, zbývající 3 jsou dostupné pouze na implementační úrovni a používá je specifikace. Na první pohled (a to je první mylná představa) je v JS vše objekt. Takže pět ze šesti typů dostupných pro program jsou takzvaná primitiva a nejsou objekty (níže vysvětlím, proč a jak jsou zaměňovány s objekty). Těchto pět primitiv je:

- Řetězec (s='str')
- Číslo (n=10)
- Boolean (b=true)
A jak jim říkám „filosofické typy“:
- null (v = null)
- nedefinováno (u=nedefinováno)

Filosofické v tom null znamená, že proměnné nebylo přiřazeno nic, a nedefinováno znamená, že proměnné byla přiřazena prázdnota. Jaký je v tomto případě rozdíl mezi „nic“ a „prázdnotou“ – přemýšlejte ve svém volném čase. Teď to neuděláme.

Šestý typ dostupný pro program (objekt) je:
-Objekt(nepleťte si to s konstruktorem Object, tady mluvíme pouze o abstraktních typech!) je jediným typem, který reprezentuje objekty v JavaScriptu.
Objekt je datová struktura (jejich celá sada), reprezentovaná jako sada párů klíč-hodnota. Hodnota může být libovolný z datových typů – pak to bude vlastnost objektu, nebo i funkce – pak to bude metoda objektu.

Existuje mnoho způsobů, jak pracovat s primitivy. Počínaje tím, že je lze přiřadit k proměnným pomocí literálů nebo pomocí konstruktorů, a konče tím, že primitiva nelze do proměnných vůbec deklarovat, pracovat s nimi přímo. Primitiva mohou být také v globálních proměnných a v lokálních.

Zde jsou nějaké příklady:

varv1; //nedefinovaná (prázdná) lokální proměnná var v2="2"; //řetězec lokální proměnná literálu var v3 = new String(2); //string lokální proměnná deklarovaná prostřednictvím konstruktoru. Vytvoří nový objekt typu String v4 = String(2); //string globální proměnná volaná přes konstruktor. Create variable window.v4 "2".length; // řetězec se nestane proměnnou, ale lze jej již použít jako Object 34..toString(); //číslo se nestane proměnnou, ale může být již použito jako objekt 12. toString(); //číslo se nestane proměnnou, ale může být již použito jako objekt (22).toString();//číslo se nestane proměnnou, ale může být již použito jako objekt

V posledních 4 příkazech je jasně vidět, jak je primitivum zaměňováno s objektem - vždyť metodu nazýváme přes tečku - stejně jako objekt. Ve skutečnosti se zdá, že tito primitivové jsou předměty.

Mylná představa se ještě umocní, když například kontrolujeme typ proměnné

varv = null; typeofv;

A jako odpověď dostáváme "objekt".

A když napíšeme:
var v = null; v instanceofObject;

Pak bude v hlavě nepořádek, protože výsledek posledního řádku bude „false“. To znamená, že proměnná v je typu object, ale není zděděna z typu Object. Co to sakra?!

Nejprve vysvětlím úlovek pomocí typeof null. Tento operátor vrací typ objektu. Faktem ale je, že operátor typeof vrací řetězcovou hodnotu převzatou z pevně zakódované tabulky, kde je napsáno: „for null, return „object“. Operátor instanceof kontroluje, zda něco patří do zadaného datového typu. Jak to dělá, vám řeknu v příštím článku, ale ujišťuji vás, že v tomto případě to fungovalo správně, null primitivum není v žádném případě zděděno z typu Object - je samo o sobě, primitivum je nejnižší stupeň rozvoj.

Dobře, přišli jsme na typeof a instanceof, ale metody se volají na primitivech – stejně jako na objektech! Co když to není předmět?

Tady je ta věc. Existuje něco jako wrapper funkce (konstruktory) (a vše bude opět jasné v druhém článku). Existují pro všechna primitiva (Number(), Boolean(), String()), stejně jako další. Jejich podstatou je vytvořit z primitiva objekt, který bude mít pomocné metody pro práci s daným typem primitiva.
Proměnnou můžete vytvořit například takto:

Varnum = newNumber(23,456);

V tomto případě dostaneme objekt z primitivního 23.456.
Pro typ čísla má konstruktor Number() pomocnou metodu toPrecision(), která určuje počet platných číslic čísla. Pokud je například číslo 23,456 nastaveno na 4 platné číslice, dostaneme číslo 23,45.
A to je, když se snažíme odkazovat na primitiva jako na objekt:

(23,456). toPrecision(4);

Interpret dočasně zabalí primitivum do objektu voláním new Number(23.456) a poté zavolá metodu toPrecision() na tento objekt, kterou nyní má. Mnoho lidí se tedy mylně domnívá, že vše v JS je objekt.

Existuje také další příklad, který je zavádějící a způsobuje nepochopení toho, co se děje. Zde je kód:

var str = 'str'; str.test = 'test'; //nenastane žádná chyba, program bude pokračovat v práci, ale console.log(str.test); //nedefinováno

Pokud bychom si jako dříve mysleli, že str je objekt, divili bychom se, proč si nepamatoval novou vlastnost test. Nyní ale víme, že když je primitivum označováno jako objekt, je dočasně zabaleno do objektu typu String. Po dokončení operace však tento obal zmizí a s ním i nová vlastnost test. To je ono, žádná magie.

Ve skutečnosti, když se podíváme dopředu, při zabalování primitiva do objektu je postaven celý řetězec dědičnosti (o tom, jak je to organizováno, si povíme později), ale v podstatě se ukazuje jako „matryoshka“:

Objekt(číslo(<примитив>)). Rodičem jakéhokoli objektu v JS, tak či onak, bude Object. Když je v objektu volána vlastnost, hledání prochází celou touto „matrjoškou“, dokud nenajde tuto vlastnost v jednom z objektů nebo nevrátí nedefinovanou, nebo pokud byla prohledána metoda, vyvolá výjimku. Vlastnosti objektu Object jsou tedy dostupné i primitivu. O tom, jak funguje prototypová dědičnost a její jemnosti, si povíme ve druhém článku.

Pro zajímavost nad druhým článkem, který chci vydat, vám řeknu ještě jeden bod související s funkcemi podle konstruktorů – to je převod typů. JS není silně typizovaný jazyk. To znamená, že při deklaraci proměnné nejsme povinni uvádět, o jaký typ se jedná, a navíc lze do této proměnné při provozu programu umístit data libovolného absolutního typu. A také můžeme použít například řetězcové proměnné v matematických operacích nebo naopak čísla v operaci zřetězení. Příklad:

var str = "abc"; str+1; // "abc1"

Zde bude primitivum typu číslo - 1 převedeno na řetězcové primitivum. V objektech je tato funkce dostupná prostřednictvím volání metody toString(), v objektech typu number existuje metoda valueOf(), která vrátí primitivum typu number. Ale trochu jsme řekli, že pouze objekty mohou mít metody. Takže v procesu převodu primitiva z jednoho typu na druhý dochází také k zabalení do objektu? Ujišťuji vás, že není. Tato metoda je volána implicitně, když je funkce konstruktoru volána interpretem bez operátoru new. Co je to za magický operátor nový a co se stane, když se funkce konstruktoru zavolá bez něj, a co je to sakra za funkci konstruktoru, si povíme v příštím článku. Pro tuto chvíli mě vezměte za slovo – převod typu proběhne okamžitě – z primitivního na primitivní.

Zatím je samozřejmě více otázek než odpovědí, nicméně věřte, že po přečtení druhého článku bude vše mnohem jasnější. Tady mě v podstatě zaujalo a nastolil řadu otázek – takříkajíc rozvířil mysl. Ale přesto se lze z tohoto článku něco naučit:
1. Navzdory zažitému názoru „vše v JS je objekt“ tomu tak není, zjistili jsme, že ze 6 datových typů, které má programátor k dispozici, je až 5 primitiv a pouze jeden reprezentuje typ objektů.
2. O objektech jsme se dozvěděli, že jde o takovou datovou strukturu, která obsahuje páry klíč-hodnota. Když hodnota může být libovolný z datových typů (a to bude vlastnost objektu) nebo funkce (a to bude metoda objektu).
3. Ale primitiva nejsou předměty. Sice s nimi můžete pracovat jako s objektem (a to způsobuje mylnou představu, že primitiv je objekt), ale ...
4. Proměnné lze deklarovat jak jednoduché (doslova) (var a = 'str'), tak prostřednictvím funkce konstruktoru (wrapper) (var a = new String('str')). V druhém případě již nezískáme primitiv, ale objekt vytvořený funkcí wrapper String(). (co je nového magický operátor a co je funkce konstruktoru, se dozvíme dále).
5. Naučili jsme se, že vytvořením obalu nad primitivem (new String('str')) s ním můžete pracovat jako s objektem. Právě tento obal vytváří interpret kolem primitiva, když s ním zkoušíme pracovat jako s objektem, ale po dokončení operace je zničen (primitiv si proto nikdy nebude schopen zapamatovat vlastnost, kterou mu přiřadíme a.test = 'test' - vlastnost test zmizí s obalem ).
6. Zjistili jsme, že objekty mají metodu toString(), která vrací řetězcovou reprezentaci objektu (pro typ number valueOf() vrátí číselnou hodnotu).
7. Pochopili, že při provádění zřetězení nebo matematických operací mohou primitiva předefinovat svůj typ na požadovaný. K tomu používají wrapperové funkce svých typů, ale bez nového operátoru (str = String(str)). (jaký je rozdíl a jak to funguje, si povíme dále)
8. A nakonec jsme se dozvěděli, že typeof přebírá hodnoty z pevně zakódované tabulky (odtud pochází další mylná představa založená na typeof null //object).

JavaScript nebo JS(krátce) nelehký 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, jsou zde pole JavaScriptu, objekty, zpětná volání a všechno to, co často napadá mozek.

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ě jsou při ověřování triky a o tom bude tento příspěvek. Začněme hned.

Kontrola typu proměnné

Například musíte zkontrolovat, zda je proměnná objekt, pole, řetězec nebo číslo. Můžete k tomu použít typeof, ale ne vždy vám to řekne pravdu a v příkladu níže vám ukážu proč.

Tento příklad jsem napsal, abych ilustroval, 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 objektu s číslem řetězce

Ž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 musí být plovoucí místo čísla. Chcete-li to vyřešit, 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 všechny hodnoty na čísla s plovoucí desetinnou čárkou. Nejprve zkontrolujte, zda se proměnná rovná nčíslo (Number(n) === n) a pokud ano, pak se provede ještě jedna kontrola pro dělení se zbytkem a pokud existuje zbytek, vrátí se boolean ( skutečný nebo Nepravdivé) výsledek (n % 1 !== 0).

Ve výše uvedeném příkladu se vrátí skutečný, Nepravdivé A Nepravdivé. První význam je plovák typ, druhý není - toto je 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

Hned v prvním příkladu je pole vykresleno jako objekt, což není moc dobré, protože někdy je potřeba použít tento typ a nic jiného.

Existuje několik způsobů, jak otestovat proměnnou pro typ pole.

První možnost (dobrá možnost). Zkontrolujte, zda data patří do pole pomocí instanceof().

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

Druhá možnost (dobrá varianta). 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í objektu vytvoří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 jako funkce pohodlí:

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

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

Doslov

Deska se ukázala být docela velká, než byla původně zamýšlena. Ale jsem s ním spokojený, protože je dostatečně stručný a jasný na to, aby popsal potíže s ověřováním proměnných v JavaScriptu a jak je obejít.

Pokud máte nějaké dotazy, napište je pod tento příspěvek. Rád pomohu.