Premenná je pomenované pamäťové miesto, do ktorého môžete ukladať nejaké informácie a zároveň ich z neho získavať.

Deklarovanie (vytváranie) premenných sa vykonáva pomocou kľúčového slova var.

// správa - názov premennej var message;

Keď vytvoríte premennú, môžete jej okamžite priradiť hodnotu.

Priradenie hodnoty premennej sa vykonáva pomocou operátora „=“.

// napríklad vytvorte premennú e-mailovú adresu a priraďte jej reťazec " [e-mail chránený]"var email = " [e-mail chránený]"; // nastavenie premennej emailu na novú hodnotu email = " [e-mail chránený]";

Ak chcete získať hodnotu premennej, jednoducho na ňu odkazujte podľa názvu.

// napríklad vypíšte hodnotu premennej email do konzoly prehliadača: console.log(email);

Ak chcete deklarovať viac ako jednu premennú pomocou jedného kľúčového slova var, musíte použiť čiarku.

Var cena = 78,55, množstvo = 10, správa;

JavaScript je dynamicky alebo slabo napísaný jazyk. To znamená, že keď je premenná deklarovaná, nemusí špecifikovať typ údajov, ktorý môže akceptovať. Preto môžete do premennej najskôr umiestniť hodnotu jedného typu údajov a potom inú.

Var výstup = "úspech"; // premenná má dátový typ string output = 28; // rovnaká premenná, ale už dátového typu „číslo“ output = true; // rovnaká premenná, ale už ukladá boolovskú hodnotu

Hodnotu premennej je možné meniť neobmedzený počet krát.

// je vytvorená premenná veku var age; // premennému veku je priradená hodnota 67 vek = 67; // premenný vek je nastavený na "Vek odchodu do dôchodku" vek = "Vek odchodu do dôchodku"; // variabilný vek je nastavený na 55 vek = 55;

Osvedčenou praxou pri vývoji klientskych aplikácií je použitie len jedného dátového typu v danej premennej, t.j. Do premennej nezapisujte hodnoty rôznych typov údajov. Aby ste pochopili, aký typ údajov by sa mal v premennej očakávať, pri vytváraní premennej sa odporúča okamžite ju inicializovať konkrétnou hodnotou.

Názov premennej sa môže skladať z písmen, číslic a symbolov $ a _. V tomto prípade prvý znak premennej nesmie byť číslo. Okrem toho nemôžete použiť vyhradené slová ako názvy premenných.

// vytvorenie dvoch premenných, prvá premenná sa volá phone, druhá je správa; var telefón, správa;

Na veľkosti písmen v názve premennej záleží. To znamená, že napríklad premenná telefón a telefón sú dve rôzne premenné.

Ak sa nepoužíva striktný režim, môžete vytvoriť premennú s počiatočnou hodnotou bez kľúčového slova var.

Cena = 250,00; // vytvoril premennú a inicializoval ju číslom 250.00 percent = "20%"; // vytvoril premennú a inicializoval ju reťazcom „20%“

Vytváranie premenných týmto spôsobom sa však neodporúča.

Typy údajov

V JavaScripte možno dátové typy rozdeliť na primitívne a objektové.

Premenné obsahujúce primitívne dátové typy ukladajú svoju hodnotu explicitne.

V JavaScripte existuje 5 primitívnych dátových typov:

• číslo;
• reťazec;
• booleovský typ (boolean);
• nulový;
• nedefinované.

Ak je jednej premennej priradená hodnota inej, ktorá obsahuje primitívny dátový typ, dostane vlastnú kópiu tejto hodnoty.

Var x = 77, y = x; x = 55; y; // 77

Premenné obsahujúce objekt v skutočnosti neukladajú samotný objekt, ale odkaz naň.

Ak je jednej premennej priradená hodnota inej, ktorá obsahuje objekt (odkaz naň), potom dostane aj prepojenie naň. V dôsledku tejto operácie budú tieto dve premenné obsahovať odkaz na rovnaký objekt.

// príklad 1 (s typom údajov "objekt") var coord1 = (x: 77, y: 100), coord2 = coord1; coord1.x = 55; // nastavíme vlastnosť x objektu na novú hodnotu coord2.x; // 55, pretože coord1 a coord2 obsahujú odkaz na rovnaký objekt // príklad 2 (s typom údajov poľa) var coord1 = , coord2 = coord1; coord1 = 55; // nastavíme prvok s indexom 0 na novú hodnotu coord2; // 55, pretože coord1 a coord2 obsahujú odkaz na rovnaký objekt // príklad 3 (s typom údajov "dátum") var date1 = new Date(2018,00,01), date2 = date1; date2 = date2.setDate(date2.getDate()+7); // zvýšenie dátumu o 7 dní dátum1; // 01.07.2018, pretože dátum1 a dátum2 obsahujú odkaz na rovnaký objekt

číslo

Číselný typ údajov v JavaScripte je všeobecný. Používa sa na reprezentáciu celých čísel aj zlomkov.

Var int = 5; // integer var float = 5,98; // zlomkové číslo

Formát na reprezentáciu čísel v JavaScripte je v súlade s normou IEEE 754-2008.

Celé čísla v JavaScripte je možné špecifikovať nielen v desiatková sústavačíselnej sústave, ale aj v osmičkovej (0) alebo hexadecimálnej číselnej sústave (0x) s použitím predpôn uvedených v zátvorkách:

Var int = 010; // 8 int = 055; // 45 int = 0xFF; //255 int = 0xB8; // 184

Je možné písať čísla v exponenciálnom tvare:

Var num = 2e3; // exponencialny zapis cisla 2*10^3 (2000) num = 2e-3; // exponencialny zapis cisla 2*10^-3 (0,002) num = 3,2e3; // 3200 num = 1,5e-2; // 0,015

Číselný dátový typ obsahuje okrem čísel aj špeciálne číselné hodnoty:

• Infinity (pozitívne nekonečno);
• -Nekonečno (záporné nekonečno);
• NaN (nie je číslo).

Špeciálna hodnota Infinity znamená veľmi veľké kladné číslo, t.j. číslo, ktoré nie je možné zobraziť v JavaScripte, pretože je príliš veľké.

Špeciálne významy -Nekonečno znamená naopak veľmi veľké záporné číslo, t.j. číslo, ktoré nemôže byť reprezentované JavaScriptom, pretože je tiež príliš veľké.

Príklad výrazov, ktoré vrátia špeciálne číselné hodnoty ako výsledok ich výpočtu:

5/0; // Nekonečno -5/0; // -Infinity Math.pow(10,399); // Nekonečno (10 na mocninu 399) Math.pow(10,399); // -Nekonečno (-10 na mocninu 399)

Hodnota NaN sa vráti ako výsledok vykonania matematických operácií, ktoré JavaScript nedokáže vypočítať.

5 - "Ahoj"; // NaN (odčítajte riadok od čísla 5) 1000 / "20px"; // NaN (číslo delené reťazcom) true * "1rem"; // NaN (logická hodnota true vynásobená reťazcom)

Čo je veľmi zaujímavé, je, že hodnota NaN v JavaScripte sa nerovná ničomu vrátane seba samého.

NaN == NaN; // falošné NaN === NaN; //false

Booleovský dátový typ

Boolean je primitívny dátový typ, ktorý má iba dve hodnoty: true a false.

Var a = pravda; var b = nepravda;

Reťazec

String je dátový typ, ktorý sa používa v JavaScripte na reprezentáciu textu.

Reťazec JavaScript môže pozostávať z 0 alebo viac postavy.

JavaScript vždy používa Unicode ako formát reťazca.

Vytvorenie reťazca (reťazcový literál) sa vykonáva uzavretím textu do jedného resp dvojité úvodzovky.

"JavaScript"; "ECMAScript";

V JavaScripte nie je rozdiel medzi jednoduchými a dvojitými úvodzovkami.

Ale v niektorých prípadoch má zmysel používať jednoduché úvodzovky namiesto dvojitých úvodzoviek a naopak.

Napríklad, keď reťazec obsahuje dvojité úvodzovky, je vhodnejšie ho uzavrieť do jednoduchých úvodzoviek. Odstráni sa tým potreba dávať v ňom dvojité úvodzovky.

""ECMAScript""; // bez escapovania (pomocou jednoduchých úvodzoviek) "\"ECMAScript\""; // s únikom

Reťazec v JavaScripte môže obsahovať špeciálne znaky. Napríklad \n (riadkový posuv), \t (tabulátor), \r (návrat vozíka) atď.

"Toto je veta.\nA toto je tiež veta, ale bude začínať od nového riadku.";

Pomocou reťazcov môžete vykonávať operáciu sčítania (zjednotenia) alebo, inými slovami, zreťazenia. Používa sa na to operátor „+“. Zmyslom tejto operácie je pripojiť druhý riadok na koniec prvého.

"Milujem" + "JavaScript"; // Milujem JavaScript

Hodnota je "nedefinovaná"

undefined je špeciálny primitívny dátový typ, ktorý má jednu hodnotu rovnajúcu sa undefined .

Tento typ údajov má deklarovanú premennú, ktorej ešte nebola priradená hodnota.

Var num; //nedefinované

Hodnota undefined sa vráti aj pri prístupe k neexistujúcej vlastnosti objektu.

Var obj = (); // prázdny objekt obj.prop; //nedefinované

"nulová" hodnota

null je špeciálny primitívny dátový typ, ktorý má jednu hodnotu rovnajúcu sa null .

null je len špeciálna hodnota, ktorá má význam „nič“ alebo „neznáma hodnota“, t.j. jasne to nic neznamena.

Objekt

Objekt je dátová štruktúra pozostávajúca z párov názov-hodnota.

Vytvorenie objektu pomocou objektového doslovného zápisu sa vykonáva takto:

( názov_1: hodnota_1, názov_2: hodnota_2, názov_3: hodnota_3, ... )

Ako vidíte, názov je oddelený od hodnoty dvojbodkou a páry sú od seba oddelené čiarkou.

Navyše, ak je hodnota páru funkcia, potom sa nazýva metóda tohto objektu. Všetky ostatné páry, t.j. páry, v ktorých sa funkcia nepoužíva ako hodnota, sa nazývajú vlastnosti objektu.

Inými slovami, objekt je dátová štruktúra pozostávajúca z vlastností a metód.

Var osoba = ( meno: "Vitaly", vek: 27, getAge: function () ( return "Vek: " + tento.vek; ) )

Prístup k vlastnostiam objektu sa vykonáva pomocou bodky alebo pomocou zápisu zátvoriek.

// zobrazenie hodnoty vlastnosti age v konzole prehliadača // 1. metóda (cez bodku) console.log(person.age); // Metóda 2 (pomocou zátvoriek) console.log(person["vek"]); // volanie metódy getAge; hodnota, ktorú vráti, bude odoslaná do konzoly console.log(person.getAge());

typ operátora

Operátor typeof sa používa na získanie informácií o dátovom type výrazu ako reťazec.

Syntax operátora typeof (možnosť bez zátvoriek):

Typ výrazu

Typ syntaxe operátora (pomocou zátvoriek):

Typeof (výraz)

Meno premennej, vek = 37, e-mail = " [e-mail chránený]", isLicense = true, interest: null, lastExperience: ( obdobie: "jún 2011 - jún 2018", miesto: "ISACA, Moskva", pozícia: "Web designer" ), getExperience: function() ( return lastExperience.period + " ("+ posledná skúsenosť.pozícia + " - " + posledná skúsenosť.miesto + ")"; ); typ mena; // "nedefinovaný" typ veku; // "číslo" typ jeLicencia; // "boolovský" typ záujmu; / / "object" (1) typeof lastExperience; // "object" typeof getExperience; // "function" (2) /* (1) je chyba, ktorá je v jazyku prítomná od jeho prvej implementácie; opravené, aby sa zachovala kompatibilita a treba to brať do úvahy pri písaní skriptov; null je primitívny dátový typ, nie je to objekt */ /* (2) - je veľmi výhodné, že operátor typeof oddeľuje funkcie oddelene; ale funkcia v JavaScipt je tiež objekt; to možno ľahko overiť vykonaním nasledujúcej konštrukcie: */ typeof getExperience.__proto__.__proto__ // "objekt" (prototyp funkcie je objekt)

Konštanty

S vydaním ECMAScript 6 bolo možné vytvárať konštanty. To sa vykonáva pomocou kľúčového slova const.

Const COLOR_RED = "#ff0000";

Konštanta je premenná, ktorej hodnota je chránená pred zmenou. Tie. Pri pokuse o zmenu hodnoty sa zobrazí chyba.

Const COLOR_RED = "#ff0000"; COLOR_RED = "#f44336"; // Uncaught TypeError: Priradenie ku konštantnej premennej.

Ak napríklad konštanta obsahuje objekt, potom ho nemožno zmeniť, alebo skôr odkaz naň. Ale vlastnosti tohto objektu sa dajú zmeniť.

Const COLORS = ( červená: "#ff0000", zelená: "#00ff00", modrá: "#00ff00" ) COLORS = ["#ff0000","#00ff00","#00ff00"]; // Uncaught TypeError: Priradenie ku konštantnej premennej. COLORS.green = "#4caf50";

Dátové typy pomáhajú vytvárať klasifikáciu údajov v programovacích jazykoch. Napríklad číslo a reťazec znakov sú rôzne typy údajov, s ktorými bude JavaScript zaobchádzať odlišne.

Je to dôležité, pretože každý typ údajov môže nadobúdať špecifické hodnoty a vykonávať špecifické akcie. Aby ste mohli vykonávať operácie s premennými v JavaScripte, je dôležité pochopiť dátový typ každej danej premennej.

Tento tutoriál vám predstaví typy údajov JavaScript.

Poznámka: Informácie v tejto príručke nie sú vyčerpávajúce, ale poskytnú vám prehľad základných možností JavaScriptu.

Dynamické písanie

JavaScript je dynamický jazyk. To znamená, že kontrola typu údajov sa vykonáva v čase spustenia, nie v čase kompilácie.

V dynamických jazykoch možno na ukladanie použiť premenné s rovnakým názvom odlišné typyúdajov.

Napríklad premenná t, definovaná kľúčovým slovom var, môže uchovávať rôzne typy údajov; môže byť tiež inicializovaný, ale ponechaný nedefinovaný:

var t = 16; // t je číslo
var t = "Tereza"; // t je reťazec
var t = pravda; // t je boolovská hodnota
var t; // t nie je definované

Všetky premenné t obsahujú rôzne typy údajov JavaScript. V JavaScripte nemusíte pred použitím premennej explicitne špecifikovať typ údajov.

čísla

JavaScript má jeden číselný typ údajov, ktorý nerozlišuje medzi celými číslami a číslami s pohyblivou rádovou čiarkou. Preto je možné čísla v JavaScripte písať s desatinnými miestami alebo bez nich:

var num1 = 93;
var num2 = 93,00;

Vo vyššie uvedenom príklade obidve premenné obsahujú čísla, či už je v nich čiarka alebo nie.

Vedecká notácia v JavaScripte vám umožňuje skracovať veľmi veľké alebo malé čísla:

var num3 = 987e8; // 98700000000
var num4 = 987e-8; // 0,00000987

V JavaScripte sa čísla považujú za presné na 15 číslic. To znamená, že po dosiahnutí 16. číslice budú čísla zaokrúhlené:

var num5 = 999999999999999; // zostane ako 999999999999999
var num6 = 9999999999999999; // zaokrúhlené nahor na 10000000000000000

Čísla v JavaScripte majú tiež tri symbolické významy:

Nekonečno - číselná hodnota, čo je kladné číslo blížiace sa k nekonečnu.

Nekonečno je číselná hodnota, ktorá predstavuje záporné číslo blížiace sa k nekonečnu.

NaN – Not-a-Number, špeciálny stav čísla s pohyblivou rádovou čiarkou.

Infinity a -Infinity sú vrátené pri počítaní čísla nad maximálny možný počet dostupný v JavaScripte. Objavujú sa aj pri počítaní nedefinovaných hodnôt, ako je delenie nulou:

var num7 = 5/0; //Nekonečno
var num8 = -5 / 0; // -Nekonečno

Technicky sa Infinity vráti, ak je číslo väčšie ako 1,797693134862315E+308, čo je horný limit v JavaScripte.

Podobne sa zobrazí -Nekonečno, keď číslo prekročí spodnú hranicu, -1,797693134862316E+308.

Nekonečné číslo možno použiť aj v slučkách:

zatiaľ čo (číslo 9 != nekonečno) (
// Kód sa tu vykoná cez num9 = Infinity
}

Pre nedefinované čísla sa vytlačí NaN. Ak sa pokúsite vykonať matematickú operáciu s číslom a nečíselnou hodnotou, dostanete NaN. Napríklad:

var x = 20 / "Žralok"; // x bude NaN

Keďže 20 nemožno deliť reťazcom Shark, hodnota x bude NaN.

Ak však možno reťazec vyhodnotiť ako číselnú hodnotu, JavaScript vyhodnotí matematický výraz:

var y = 20 / "5"; // y bude 4

Keďže JavaScript môže považovať 5 za číselnú hodnotu, 5 bude fungovať s operátorom matematického delenia.

Ak je jedna premenná vo výraze nastavená na NaN, výsledkom bude NaN, aj keď druhý operand je číslo.

var a = NaN;
var b = 37;
var c = a + b; // c bude NaN

Takže v JavaScripte existuje iba jeden číselný typ údajov. V JavaScripte nie je potrebné oddeľovať čísla na celé čísla a čísla s pohyblivou rádovou čiarkou, pretože JavaScript je dynamický jazyk.

Struny

Reťazec je postupnosť jedného alebo viacerých znakov (písmená, čísla a iné symboly). Reťazce predstavujú textové údaje.

V JavaScripte sú reťazce v jednoduchých aj dvojitých úvodzovkách. Ak chcete vytvoriť reťazec, musíte sekvenciu znakov uzavrieť do úvodzoviek:

var singleQuotes = "Toto je reťazec v jednoduchých úvodzovkách.";
var doubleQuotes = "Toto je reťazec v dvojitých úvodzovkách.";

Môžete použiť jednoduché alebo dvojité úvodzovky, ale v rámci toho istého kódu musíte konzistentne používať jeden typ úvodzoviek.

Program "Ahoj, svet!" ukazuje, ako sa reťazce používajú v počítačovom programovaní. V podstate v v tomto príklade reťazec je postupnosť znakov, ktoré tvoria frázu „Ahoj, svet!“ v upozornení ().

funkcia helloFunction() (
alert("Ahoj, Svet!");
}

Klikni na mňa

Spustením kódu a kliknutím na tlačidlo Click me sa zobrazí vyskakovacie okno s textom:

Podobne ako iné dátové typy, aj reťazce môžu byť uložené v premenných.

var hw = "Ahoj, Svet!";

Potom môžete zobraziť reťazec volaním premennej:

...

var hw = "Ahoj, Svet!";
funkcia helloFunction() (
alert(hw);
}

...
Dobrý deň, Svet!

Reťazce umožňujú odovzdanie informácií používateľovi a späť do programu.

Booleovský dátový typ

Dátový typ Boolean (alebo Boolean) pozostáva z dvoch hodnôt – true a false.

Tento typ sa používa na reprezentáciu pravdivostných hodnôt spojených s logikou a algoritmami v informatike.

Poznámka: Tento typ údajov je pomenovaný po matematikovi Georgovi Booleovi.

Mnohé operácie v matematike prinášajú výsledky, ktoré možno vyhodnotiť ako pravdivé alebo nepravdivé:

Viac ako:

• 500 > 100 pravda
• 1 > 5 nepravda

Menej ako:

• 200 < 400 true
• 4 < 2 false

• 5 = 5 pravda
• 500 = 400 nepravda

Podobne ako iné typy, aj dátový typ Boolean možno uložiť do premenných.

var myBool = 5 > 8; // nepravda

Keďže 5 nie je väčšie ako 8, myBool bude mať hodnotu false.

Pri kódovaní v JavaScripte sa zoznámite s tým, ako fungujú boolovské údaje a ako môžu rôzne funkcie a operácie na vyhodnocovanie pravdy zmeniť tok programu.

Polia

Pole môže obsahovať viacero hodnôt v rámci jednej premennej. To znamená, že môžete uložiť zoznam hodnôt do poľa a iterovať ich.

Každá hodnota v poli sa nazýva prvok. K prvkom poľa môžete pristupovať pomocou indexu.

Polia sú definované hranatými zátvorkami.

Pole reťazcov vyzerá takto:

var ryba = ["žralok", "sépia", "klaun", "úhor"];

Zavolaním premennej ryby získate výsledok:

["žralok", "sépia", "klaun", "úhor"]

Polia sú veľmi flexibilným typom údajov, pretože sú meniteľné: môžete pridávať, odstraňovať a meniť hodnoty prvkov.

Objekty

Objekt v JavaScripte pozostáva z párov kľúč:hodnota.

Syntax objektu pozostáva z párov kľúč:hodnota. Objekt je oddelený zloženými zátvorkami na oboch stranách (()).

Páry v objekte sú oddelené medzerami:

var sammy = (meno:"Wally", priezvisko:"Žralok", farba:"modrá", poloha:"oceán");

Objekt môže byť napísaný aj na viacerých riadkoch (to platí najmä pre veľké objekty).

var wally = (
krstné meno: "Wally",
priezvisko: "Žralok",
farba: "modrá",
miesto: "Oceán"
};

Práca s viacerými typmi údajov

Každý program, ktorý vytvoríte, bude pravdepodobne obsahovať viacero typov údajov, ale operácie sa zvyčajne vykonávajú na jednom type údajov. matematika sa aplikuje na čísla a krájanie sa aplikuje na reťazce.

Použitím operátorov, ktoré pracujú so všetkými typmi údajov (napríklad operátor + môže pridávať čísla alebo vykonávať zreťazenie reťazcov), môžete získať neočakávané výsledky.

Ak vytvoríte premennú na zreťazenie, JavaScript bude interpretovať každý prvok ako reťazec.

var o = "Oceán" + 5 + 3;

Volaním premennej o získate nasledujúci výsledok:

Ak však reťazec obsahuje najskôr čísla a potom reťazec, operátor + vykoná sčítanie a potom zreťazenie:

var p = 5 + 3 + "Oceán";
8Oceán

Pretože výsledky sú nepredvídateľné, je pohodlnejšie vykonávať operácie a metódy v jednom dátovom type. JavaScript však nevracia chyby pri miešaní typov údajov, ako to robia niektoré iné programovacie jazyky.

Záver

Teraz ste oboznámení s typmi údajov JavaScript. Každý z tu uvedených typov je dôležitý pri písaní programov JavaScript.

Tagy: Premenná je identifikátor, ktorému bola priradená hodnota. K premennej je možné pristupovať v programe, teda pracovať s hodnotou, ktorá je jej priradená.

Samotná premenná JavaScript neobsahuje informácie o type hodnôt, ktoré v nej budú uložené. To znamená, že zapísaním napríklad reťazca do premennej do nej neskôr môžete zapísať číslo. Takáto operácia nespôsobí chybu v programe. To je dôvod, prečo sa JavaScript niekedy nazýva „netypizovaný“ jazyk.

Pred použitím premennej je potrebné ju deklarovať pomocou kľúčového slova var alebo let. Ak hovoríme o konštante, používa sa kľúčové slovo const. Môžete deklarovať premennú a priradiť jej hodnotu bez použitia týchto kľúčových slov, ale neodporúča sa to.

▍Kľúčové slovo var Pred štandardom ES2015 bolo použitie kľúčového slova var jediná cesta deklarácie premenných.

Var a = 0
Ak v tomto konštrukte vynecháte var, hodnota bude priradená nedeklarovanej premennej. Výsledok tejto operácie závisí od režimu, v ktorom sa program vykonáva.

Ak je teda povolený takzvaný prísny režim, spôsobí to chybu. Ak nie je povolený prísny režim, premenná bude implicitne deklarovaná a priradená ku globálnemu objektu. Konkrétne to znamená, že premenná implicitne deklarovaná vo funkcii týmto spôsobom zostane dostupná aj po dokončení funkcie. Typicky sa očakáva, že premenné deklarované vo funkciách „neprekračujú“ svoj rozsah. Vyzerá to takto:

Funkcia notVar() ( bNotVar = 1 //radšej to nerobte) notVar() console.log(bNotVar)
1 sa objaví v konzole, takéto správanie od programu zvyčajne nikto neočakáva, výraz bNotVar = 1 nevyzerá ako pokus o deklaráciu a inicializáciu premennej, ale ako pokus o prístup k premennej umiestnenej v rozsahu mimo funkciu (toto je celkom normálne). Výsledkom je, že implicitné deklarácie premenných sú pre tých, ktorí čítajú kód, mätúce a môžu viesť k neočakávanému správaniu programu. Neskôr si povieme o funkciách aj rozsahoch, ale zatiaľ sa snažte vždy používať špecializované kľúčové slová, keď je významom výrazu deklarovať premennú. Ak je v tomto príklade telo funkcie prepísané ako var bNotVar = 1, potom pokus o spustenie vyššie uvedeného fragmentu kódu bude mať za následok chybové hlásenie (môžete ho vidieť v konzole prehliadača).

Môže to vyzerať napríklad takto: Uncaught ReferenceError: bNotVar nie je definovaný . Jeho význam sa scvrkáva na skutočnosť, že program nemôže pracovať s neexistujúcou premennou. Je oveľa lepšie vidieť takéto chybové hlásenie pri prvom spustení programu, ako písať nezrozumiteľný kód, ktorý sa môže správať neočakávane.

Ak pri deklarovaní premennej nie je inicializovaná alebo nie je priradená žiadna hodnota, automaticky sa jej priradí hodnota nedefinovaná.

Premenná a //typ a === "nedefinované"
Premenné deklarované pomocou kľúčového slova var je možné deklarovať znova mnohokrát, čím sa im priradia nové hodnoty (to však môže byť mätúce pre osobu, ktorá číta kód).

Var a = 1 var a = 2
V jednom výraze môžete deklarovať viacero premenných:

Var a = 1, b = 2
Rozsah premennej je oblasť programu, v ktorej je táto premenná prístupná (viditeľná).

Premenná inicializovaná kľúčovým slovom var mimo funkcie je priradená ku globálnemu objektu. Má globálny rozsah a je prístupný odkiaľkoľvek v programe. Ak je premenná deklarovaná pomocou kľúčového slova var vnútri funkcie, potom je viditeľná iba v rámci tejto funkcie, pretože je pre ňu lokálnou premennou.

Ak funkcia používajúca var deklaruje premennú, ktorej názov je rovnaký ako premenná v globálnom rozsahu, „prepíše“ globálnu premennú. To znamená, že pri prístupe k takejto premennej vnútri funkcie sa použije jej lokálna verzia.

Je dôležité pochopiť, že bloky (oblasti kódu uzavreté v zložených zátvorkách) nevytvárajú nové rozsahy. Nová oblasť viditeľnosť sa vytvorí pri volaní funkcie. Kľúčové slovo var má skôr to, čo sa nazýva funkčný rozsah než rozsah bloku.

Ak je premenná deklarovaná v kóde funkcie, je viditeľná pre celý kód funkcie. Aj keď je premenná deklarovaná pomocou var na konci kódu funkcie, možno k nej pristupovať na začiatku kódu, pretože JavaScript má mechanizmus variabilného zdvíhania. Tento mechanizmus „zdvíha“ deklarácie premenných, ale nie ich inicializačné operácie. To môže byť zdrojom zmätku, preto si zvyknite deklarovať premenné na začiatku vašej funkcie.

▍Kľúčové slovo let Kľúčové slovo let bolo zavedené v ES2015 a zjednodušene ho možno nazvať „blokovou“ verziou var . Premenné deklarované s kľúčovým slovom let sa vzťahujú na blok, príkaz alebo výraz, v ktorom sú deklarované, a na vnorené bloky.

Ak sa vám samotné slovo „nech“ nezdá veľmi jasné, môžete si predstaviť, že namiesto toho použijete slovo „nech“. Potom výraz let color = „červená“ možno preložiť do angličtiny takto: „nech je farba červená“ a do ruštiny takto: „nech je farba červená“.

Použitím kľúčového slova let sa môžete vyhnúť nejednoznačnostiam, ktoré prichádzajú s kľúčovým slovom var (napríklad nebudete môcť tú istú premennú deklarovať dvakrát pomocou let ). Použitie let mimo funkcie, povedzme pri inicializácii slučiek, nevytvára globálne premenné.

Napríklad tento kód vygeneruje chybu:

Pre (nech i = 0; i< 5; i++) { console.log(i) } console.log(i)
Ak je pri inicializácii cyklu počítadlo i deklarované pomocou kľúčového slova var, potom bude i dostupné mimo cyklu, keď dokončí svoju prácu.

V súčasnosti, keď sa vyvíjajú programy JS založené na moderných štandardoch, je celkom možné úplne opustiť var a používať iba kľúčové slová let a const.

▍Kľúčové slovo const Hodnoty premenných deklarované pomocou kľúčových slov var alebo let možno prepísať. Ak sa namiesto týchto kľúčových slov použije const, potom konštante deklarovanej a inicializovanej s jej pomocou nemožno priradiť novú hodnotu.

Const a = "test"
V tomto príklade nemožno konštante a priradiť novú hodnotu. Treba však poznamenať, že ak a nie je primitívna hodnota ako číslo, ale objekt, použitie kľúčového slova const nechráni tento objekt pred zmenami.

Keď hovoria, že objekt je uložený v premennej, v skutočnosti tým myslia, že premenná ukladá odkaz na objekt. Tento odkaz nie je možné zmeniť, ale je možné zmeniť samotný objekt, na ktorý odkaz vedie.

Kľúčové slovo const nerobí objekty nemennými. Jednoducho chráni odkazy na ne zapísané v zodpovedajúcich konštantách pred zmenami. Takto to vyzerá:

Const obj = () console.log(obj.a) obj.a = 1 //funguje console.log(obj.a) //obj = 5 //spôsobí chybu
Pri inicializácii sa do konštanty obj zapíše nový prázdny objekt. Pokus o prístup k jeho vlastnosti a, ktorá neexistuje, nespôsobí chybu. Konzola bude nedefinovaná. Potom k objektu pridáme novú vlastnosť a pokúsime sa k nemu znova pristúpiť. Tentoraz je hodnota tejto vlastnosti v konzole 1. Ak odkomentujete posledný riadok príkladu, pokus o vykonanie tohto kódu bude mať za následok chybu.

Kľúčové slovo const je veľmi podobné kľúčovému slovu let , konkrétne má blokový rozsah.

V moderných podmienkach je celkom prijateľné použiť kľúčové slovo const na deklarovanie všetkých entít, ktorých hodnoty sa neplánujú meniť, pričom sa uchyľujú iba v špeciálnych prípadoch. prečo? Ide o to, že najlepšie je snažiť sa používať čo najjednoduchšie dostupné konštrukcie, aby sa nekomplikoval program a vyhlo sa chybám.

Dátové typy JavaScriptu sa niekedy nazývajú „netypizovaný“ jazyk, ale nie je to tak. Je pravda, že do premenných môžete zapisovať hodnoty rôznych typov, ale v JavaScripte stále existujú typy údajov. Hovoríme najmä o primitívnych a objektových dátových typoch.

Na určenie typu údajov hodnoty môžete použiť operátor typeof. Vracia reťazec označujúci typ operandu.

▍Primitívne typy údajov Tu je zoznam primitívnych typov údajov JavaScript:

• číslo
• reťazec
• boolean (boolovská hodnota)
• null (špeciálna hodnota null)
• undefined (špeciálna hodnota undefined)
• symbol (symbol, používaný v špeciálnych prípadoch, zavedený v ES6)

Tu sú názvy typov údajov uvedené tak, ako ich vracia operátor typeof.

Povedzme si niečo o najčastejšie používaných dátových typoch z tohto zoznamu.

Typ čísla Hodnoty typu číslo v JavaScripte sú reprezentované ako 64-bitové čísla s pohyblivou rádovou čiarkou s dvojitou presnosťou.

V kóde sú číselné literály reprezentované ako celé čísla a zlomky v desiatkovej sústave čísel. Na písanie čísel môžete použiť iné metódy. Ak je napríklad na začiatku číselného literálu predpona 0x, vníma sa ako číslo zapísané v šestnástkovej sústave. Čísla sa dajú písať aj v exponenciálnom zápise (v takýchto číslach nájdeme písmeno e).

Tu sú príklady zápisu celých čísel:

10 5354576767321 0xCC // hexadecimálne číslo
Tu sú zlomky.

3,14 ,1234 5,2e4 //5,2 * 10^4
Číselné literály (toto správanie je typické aj pre niektoré iné primitívne typy), keď sa k nim pokúsite pristupovať ako k objektom, sa automaticky počas trvania operácie prevedú na zodpovedajúce objekty, ktoré sa nazývajú „objektové obaly“. V tomto prípade hovoríme o obale objektu Number.

Tu je napríklad to, ako vyzerá pokus o prístup k premennej a, ktorá obsahuje číselný literál, ako objekt v konzole Google Chrome.

Tip na obal objektu čísla

Ak napríklad použijete metódu toString() objektu typu Number, vráti reťazcovú reprezentáciu čísla. Zodpovedajúci príkaz vyzerá takto, ktorý je možné vykonať v konzole prehliadača (a v bežnom kóde) takto:

A.toString()
Všimnite si dvojité zátvorky za názvom metódy. Ak ich nedodáte, systém nevygeneruje chybu, ale namiesto očakávaného výstupu uvidíte v konzole niečo, čo sa reťazcovej reprezentácii čísla 5 vôbec nepodobá.

Globálny objekt Number sa dá použiť ako konštruktor, pomocou ktorého vytvára nové čísla (v tejto podobe sa však takmer nepoužíva), dá sa použiť aj ako nezávislá entita, bez vytvárania svojich inštancií (teda určitých čísel). zastúpené s jeho pomocou). Napríklad jeho vlastnosť Number.MAX_VALUE obsahuje maximálnu číselnú hodnotu reprezentovanú v JavaScripte.

Typový reťazec Hodnoty typu string sú sekvencie znakov. Takéto hodnoty sú špecifikované ako reťazcové literály uzavreté v jednoduchých alebo dvojitých úvodzovkách.

"Reťazec" "Ďalší reťazec"
Hodnoty reťazca je možné rozdeliť na viacero častí pomocou znaku spätnej lomky.

"A\reťazec"
Riadok môže obsahovať takzvané únikové sekvencie, ktoré sa interpretujú pri výstupe riadku do konzoly. Napríklad sekvencia \n znamená znak nového riadku. Znak spätnej lomky možno použiť aj na pridanie úvodzoviek do reťazcov uzavretých v rovnakých úvodzovkách. Escapovanie znaku citácie pomocou \ spôsobí, že systém ho nebude považovať za špeciálny znak.

"Som vývojár"
Reťazce je možné spájať pomocou operátora +.

"A" + "reťazec"

Šablónové literály V ES2015 sa objavili takzvané šablónové literály alebo reťazce šablón. Sú to reťazce uzavreté v zadných úvodzovkách (`) a majú niektoré zaujímavé vlastnosti.

"reťazec".
Môžete napríklad nahradiť určité hodnoty, ktoré sú výsledkom vyhodnotenia výrazov JavaScript, do literálov šablóny.

`reťazec s $(niečo)` `reťazec s $(niečo+niečoElse)` `reťazec s $(obj.niečo())`
Použitie spätných úvodzoviek uľahčuje písanie reťazcových literálov do viacerých riadkov:

`reťazec s $(niečo)`

JavaScript boolovského typu má pár vyhradených slov používaných pri práci s boolovskými hodnotami: true a false. Porovnávacie operátory, ako napríklad == , === ,< , >, vráti true alebo false .

Booleovské výrazy sa používajú v príkazoch ako if a while na pomoc pri riadení toku programu.

Treba poznamenať, že tam, kde sa očakáva hodnota true alebo false, môžete použiť iné hodnoty, ktoré jazyk automaticky vyhodnotí ako true (truth) alebo false (false).

Konkrétne ide o nepravdivé hodnoty:

0 -0 NaN undefined null "" //prázdny reťazec
Zvyšné hodnoty sú pravdivé.

JavaScript typu null má špeciálnu hodnotu null , ktorá označuje absenciu hodnoty. Podobné hodnoty sa používajú aj v iných jazykoch Typ undefined Hodnota undefined zapísaná do určitej premennej znamená, že táto premenná nie je inicializovaná a nemá pre ňu žiadnu hodnotu.

Táto hodnota sa automaticky vracia z funkcií, ktorých výsledky nie sú explicitne vrátené pomocou kľúčového slova return. Ak funkcia preberá parameter, ktorý nie je špecifikovaný pri jej volaní, je tiež nastavený na undefined .

Ak chcete skontrolovať hodnotu pre undefined , môžete použiť nasledujúcu konštrukciu.

Typ premennej === "nedefinované"

▍Objekty Všetky neprimitívne hodnoty sú typu objektu. Hovoríme o funkciách, poliach, o tom, čo nazývame „objekty“ a mnohých ďalších entitách. Všetky tieto dátové typy vychádzajú z typu objektu a hoci sa od seba v mnohom líšia, majú aj veľa spoločného Výrazy Výrazy sú časti kódu, ktoré je možné spracovať a získať určitú hodnotu na základe vykonaných výpočtov. . V JavaScripte existuje niekoľko kategórií výrazov Aritmetické výrazy Táto kategória zahŕňa výrazy, ktoré sa vyhodnocujú ako čísla.

1/2 i++ i -= 2 i * 2

Reťazcové výrazy Výsledkom vyhodnotenia takýchto výrazov sú reťazce.

"A" + "reťazec" "A" += "reťazec"

Primárne výrazy Do tejto kategórie patria literály, konštanty a odkazy na identifikátory.

2 0,02 "niečo" pravda nepravda tento //kontext vykonania, odkaz na aktuálny objekt nedefinovaný i //kde i je premenná alebo konštanta
Patria sem aj niektoré kľúčové slová a konštrukcie JavaScriptu.

Funkcia triedy funkcie* //generátor výnosu //príkaz na pozastavenie/obnovenie výnosu generátora* //delegovanie na iný iterátor alebo generátor asynchrónna funkcia* //asynchrónny funkčný výraz čaká //organizácia čakania na vykonanie asynchrónnej funkcie /vzor /i // regulárny výraz() //zoskupenie

Inicializačné výrazy pre polia a objekty //array literal () //object literal (a: 1, b: 2) (a: (b: 1)) Logické výrazy Logické výrazy používajú logické operátory, výsledkom ich výpočtu sú logické hodnoty.

A && b a || b!a

Výrazy prístupu k vlastnostiam Tieto výrazy vám umožňujú pristupovať k vlastnostiam a metódam objektov.

Object.property //volanie vlastnosti (alebo metódy) objektu object object["property"]

Výrazy vytvorenia objektu new object() new a(1) new MyRectangle("name", 2, (a: 4)) Výrazy deklarácie funkcie function() () function(a, b) ( return a * b ) (a, b) => a * b a => a * 2 () => ( return 2 ) Volanie výrazov Takéto výrazy sa používajú na volanie funkcií alebo metód objektov.

A.x(2) window.resize()

Práca s objektmi S objektmi sme sa už stretli vyššie, hovorili sme o objektových literáloch, volali ich metódy a pristupovali k ich vlastnostiam. Tu si povieme o objektoch podrobnejšie, najmä sa pozrieme na mechanizmus prototypovej dedičnosti a použitie kľúčového slova class.▍Prototypická dedičnosť JavaScript vyniká medzi modernými programovacími jazykmi tým, že podporuje prototypickú dedičnosť . Väčšina objektovo orientovaných jazykov používa model dedičnosti založený na triedach.

Každý objekt JavaScript má špeciálnu vlastnosť (__proto__), ktorá ukazuje na iný objekt, ktorý je jeho prototypom. Objekt zdedí vlastnosti a metódy prototypu.

Povedzme, že máme objekt vytvorený pomocou objektového literálu.

Const car = ()
Alebo sme vytvorili objekt pomocou konštruktora Object.

Const car = nový objekt ()
V každom z týchto prípadov bude prototypom objektu auta Object.prototype .

Ak vytvoríte pole, ktoré je zároveň objektom, jeho prototypom bude objekt Array.prototype.

Const list = //alebo tak const list = new Array()
Môžete to skontrolovať nasledovne.

Auto.__proto__ == Object.prototype //pravé auto.__proto__ == nový objekt().__proto__ //skutočný zoznam.__proto__ == Object.prototype //nepravdivý zoznam.__proto__ == Array.prototype //skutočný zoznam.__proto__ == new Array().__proto__ //true
Tu sme použili vlastnosť __proto__, nemusí byť k dispozícii vývojárovi, ale zvyčajne je prístupná. Treba poznamenať, že viac spoľahlivým spôsobom získanie prototypu objektu je použitie globálnej metódy getPrototypeOf(). Objekt.

Object.getPrototypeOf(new Object())
Všetky vlastnosti a metódy prototypu sú dostupné objektu, ktorý má tento prototyp. Tu je napríklad to, ako vyzerá ich zoznam pre pole.

Tip na pole

Základným prototypom pre všetky objekty je Object.prototype.

Array.prototype.__proto__ == Object.prototype
Object.prototype nemá prototyp.

To, čo sme videli vyššie, je príklad prototypovej reťaze.

Keď sa pokúsite získať prístup k vlastnosti alebo metóde objektu, ak samotný objekt takúto vlastnosť alebo metódu nemá, ich vyhľadávanie sa vykoná v jeho prototype, potom v prototype prototypu atď., kým sa nenájde požadovaná vlastnosť. alebo kým reťaz prototypov neskončí.

Okrem vytvárania objektov pomocou operátora new a pomocou objektových alebo poliových literálov môžete vytvoriť inštanciu objektu pomocou metódy Object.create(). Prvý argument odovzdaný tejto metóde je objekt, ktorý bude prototypom objektu, ktorý vytvorí.

Const car = Object.create(Object.prototype)
Pomocou metódy isPrototypeOf() môžete skontrolovať, či je objekt súčasťou prototypového reťazca iného objektu.

Konštantný zoznam = Array.prototype.isPrototypeOf(zoznam)

Funkcie konštruktora Vyššie sme vytvorili nové objekty pomocou funkcií konštruktora, ktoré sú už v jazyku k dispozícii (pri ich volaní sa používa kľúčové slovo new). Takéto funkcie si môžete vytvoriť sami. Pozrime sa na príklad.

Funkcia Osoba(meno) ( this.name = meno ) Person.prototype.hello = function() ( console.log(this.name) ) let person = new Person("Flavio") person.hello() console.log( Person.prototype.isPrototypeOf(person))
Tu vytvoríme funkciu konštruktora. Pri volaní sa vytvorí nový objekt, čo je označené klávesom slovo toto v tele konštruktéra. Tomuto objektu pridáme vlastnosť name a zapíšeme doň, čo bolo odovzdané konštruktorovi. Tento objekt sa automaticky vráti z konštruktora. Pomocou funkcie konštruktor môžete vytvoriť mnoho objektov, ktorých vlastnosti názvu budú obsahovať to, čo bolo odovzdané konštruktorovi pri ich vytváraní.

Po vytvorení konštruktora pridáme do jeho prototypu funkciu, ktorá vypíše do konzoly hodnotu vlastnosti name objektu vytvoreného pomocou tejto funkcie. Všetky objekty vytvorené pomocou tohto konštruktora budú mať rovnaký prototyp, a preto budú používať rovnakú funkciu hello(). Dá sa to jednoducho skontrolovať vytvorením ďalšieho objektu typu Osoba a porovnaním jeho funkcie hello() s funkciou objektu už existujúceho v príklade (v tomto prípade sa názov funkcie zapíše bez zátvoriek).

▍Triedy V štandarde ES6 zaviedol JavaScript koncept „triedy“.

Predtým mohol JavaScript používať iba prototypový mechanizmus dedičnosti opísaný vyššie. Tento mechanizmus vyzeral nezvyčajne pre programátorov, ktorí prišli k JS z iných jazykov. Preto sa v jazyku objavili triedy, ktoré sú v podstate „syntaktickým cukrom“ pre prototypový mechanizmus dedičnosti. Teda vytvorené predmety tradičným spôsobom a objekty vytvorené pomocou tried majú prototypy.

Deklarácia triedy Takto vyzerá deklarácia triedy.

Osoba triedy ( constructor(name) ( this.name = name ) hello() ( return "Ahoj, ja som " + this.name + "." ) )
Trieda má identifikátor, ktorý možno použiť na vytvorenie nových objektov pomocou novej konštrukcie ClassIdentifier().

Keď sa vytvorí nový objekt, zavolá sa metóda konštruktora a odovzdajú sa jej parametre.

Môžete deklarovať metódy v triede. V našom prípade hello() je metóda, ktorú môžu volať všetky objekty vytvorené na základe triedy. Takto vyzerá vytvorenie nového objektu pomocou triedy Osoba.

Const flavio = nová osoba("Flavio") flavio.hello()

Triedy dedičnosti na základe tried môžu rozšíriť ďalšie triedy. Objekty vytvorené z takýchto tried zdedia metódy pôvodnej triedy aj metódy špecifikované v rozšírenej triede.

Ak má trieda, ktorá rozširuje inú triedu (podtriedu tejto triedy), metódu, ktorej názov je rovnaký ako názov rodičovskej triedy, táto metóda má prednosť pred pôvodnou.

Class Programmer rozširuje osobu ( hello() ( return super.hello() + "Som programátor." ) ) const flavio = new Programmer("Flavio") flavio.hello()
Volanie metódy hello() vo vyššie uvedenom príklade vráti reťazec Hello, I am Flavio. Som programátor.

Triedy nezabezpečujú prítomnosť premenných (vlastností), vlastnosti objektov vytvorených pomocou tried musia byť nakonfigurované v konštruktore.

V rámci triedy máte prístup k rodičovskej triede pomocou kľúčového slova super.

Statické metódy Metódy opísané v triede možno volať prístupom k objektom vytvoreným z triedy, ale nie prístupom k triede samotnej. Statické metódy možno volať priamym prístupom k triede Súkromné ​​metódy JavaScript nemá zabudovaný mechanizmus, ktorý umožňuje deklarovať súkromné ​​metódy. Toto obmedzenie sa dá prekonať napríklad použitím uzáverov Getre a settery Metódy v triede môžete definovať tak, že im predpíšete kľúčové slová get alebo set. To vám umožňuje vytvárať takzvané getters a setters – funkcie, ktoré slúžia na riadenie prístupu k vlastnostiam objektov vytvorených na základe triedy. Getter sa volá, keď sa pokúšate prečítať hodnotu pseudovlastnosti, a nastavovač sa volá, keď sa do nej pokúšate zapísať novú hodnotu.

Trieda Osoba ( konstruktor(meno) ( this.userName = meno ) set name (hodnota) ( ​​this.userName = hodnota ) get name() ( return this.userName ) )

Zhrnutie V tomto materiáli sme hovorili o premenných, dátových typoch, výrazoch a práci s objektmi v JavaScripte. Témou nášho ďalšieho materiálu budú funkcie.

Vážení čitatelia! Ak už dlho píšete v JS, povedzte nám prosím, ako sa vám páči vzhľad kľúčového slova class v jazyku.

V tomto návode si predstavíme veľmi dôležitý koncept – dátové typy JavaScript. Odporúčame, aby ste si na tento pojem dávali veľký pozor – ak mu nerozumiete od samého začiatku, často sa budete musieť potýkať s podivným správaním vami vytvoreného programu.

Dynamické písanie

Prebieha počítačové programy manipulovať s rôznymi hodnotami, z ktorých každá môže byť spracovaná v programovacom jazyku a patrí k určitému typu údajov.

V JavaScripte možno dátové typy rozdeliť do dvoch kategórií: jednoduché (tiež nazývané primitívne) typy a zložené (tiež nazývané referenčné alebo objektové).

JavaScript je slabo typizovaný alebo dynamický programovací jazyk, ktorý umožňuje definovať, analyzovať a kompilovať dátové typy za behu počas vykonávania programu. To znamená, že nemusíte vopred definovať typ premennej. Typ sa určí automaticky počas vykonávania programu.
V rôznych častiach programu teda tá istá premenná môže nadobúdať hodnoty rôznych typov:

Typy údajov

Štandard ECMAScript® definuje nasledujúce typy údajov:

• Jednoduché (nazývané aj primitívne) typy:
  • Boolean – môže nadobúdať dve možné hodnoty, niekedy nazývané true a false;
  • null – hodnota null predstavuje odkaz, ktorý zvyčajne zámerne poukazuje na neexistujúci alebo nesprávny objekt alebo adresu;
  • undefined – označuje preddefinovanú globálnu premennú inicializovanú nedefinovanou hodnotou;
  • numeric (English Number) – číselný typ údajov vo formáte 64-bitového čísla s pohyblivou rádovou čiarkou s dvojitou presnosťou;
  • string (anglicky String) – je sekvencia znakov používaná na reprezentáciu textu;
  • symbol (angl. Symbol) je dátový typ, ktorého inštancie sú jedinečné a nemenné. (nové v ECMAScript 6).
• Objekt je súbor pomenovaných hodnôt, ktoré sa zvyčajne nazývajú vlastnosti objektu.

Rozdiel medzi primitívnymi a zloženými typmi

Predtým, ako sa pozrieme na jednotlivé typy údajov, oboznámme sa najprv s operátorom typeof. Operátor typeof vracia reťazec popisujúci typ údajov premennej.
Ukážme si, ako to funguje, na nasledujúcom príklade:

Vzorový skript deklaruje premenné, inicializuje ich (priraďuje hodnoty) a potom vypíše typ každej premennej.

Rozdiel medzi primitívnymi a zloženými typmi údajov nastáva, keď sa ich hodnoty skopírujú.

Keď je premennej priradená hodnota jednoduchého typu, do premennej sa zapíše samotná hodnota (napríklad číslo). Keď premennú jednoduchého typu priradíme inej, skopíruje hodnotu. Výsledkom je, že každá premenná bude mať svoju vlastnú hodnotu a zmeny v jednej z premenných žiadnym spôsobom neovplyvnia hodnotu druhej premennej:

Keď premennej priradíme hodnotu zloženého (referenčného) typu, do premennej sa zapíše odkaz na hodnotu (odkaz na objekt). Keď priradíme jednu premennú (ktorej hodnota obsahuje odkaz na zloženú hodnotu) k inej premennej, odkaz na zloženú hodnotu sa skopíruje. Výsledkom je, že obe premenné odkazujú na rovnakú zloženú hodnotu a zmeny v hodnote jednej premennej ovplyvnia druhú premennú:

Primitívne typy

Všetky dátové typy v JavaScripte, okrem objektov, sú nemenné alebo nemenné. To znamená, že ich hodnoty nemožno upravovať, ale iba prepisovať novou, inou hodnotou. Reťazce sa napríklad nedajú upravovať znak po znaku – možno ich iba úplne prepísať. Hodnoty takýchto typov sa nazývajú "primitívne".

Najjednoduchšie údaje, s ktorými môže program pracovať, sa nazývajú literály. Literály sú čísla alebo reťazce, ktoré sa používajú na reprezentáciu hodnôt v JavaScripte. Poskytované informácie môžu byť veľmi rôznorodé, a preto sa ich významy líšia rôzne druhy. Najjednoduchšie dátové typy v JavaScripte sa nazývajú základné dátové typy: čísla, reťazce a booleany. Všetky sú klasifikované ako "primitívne".

Booleovský (logický) typ „boolean“

Logické alebo boolovské hodnoty (podľa mena ich vynálezcu - Boolean) môžu mať iba jednu z dvoch hodnôt: true (true) alebo false (false). Hodnoty sú pravdivé alebo nepravda sa zvyčajne objavuje pri porovnávaní alebo logických operáciách.

Nasledujúci program vytvorí boolovskú premennú a potom otestuje jej hodnotu pomocou príkazu if/else:

Ako porovnávací výraz možno použiť akýkoľvek výraz. Akýkoľvek výraz, ktorý vráti 0, null, undefined alebo prázdny reťazec, sa interpretuje ako false . Výraz, ktorý určuje akúkoľvek inú hodnotu, sa interpretuje ako true .

Poznámka: Pri písaní boolovských hodnôt nie sú uzavreté v úvodzovkách: var myVar = true;
Zároveň deklarovaním var myVar = "true" sa vytvorí reťazcová premenná.

Typ údajov čísla

V JavaScripte neexistuje rozdiel medzi celým číslom a číslom s pohyblivou rádovou čiarkou – JavaScript v podstate predstavuje všetky čísla ako hodnotu s pohyblivou rádovou čiarkou.

JavaScript používa na reprezentáciu čísel 64-bitový formát definovaný štandardom IEEE-754. Tento formát je schopný reprezentovať čísla v rozsahu ±1,7976931348623157 × 10308 až ±5 × 10 -324.

Číslo nachádzajúce sa priamo v kóde programu sa nazýva číselný literál. Okrem desiatkových celočíselných literálov JavaScript rozpoznáva aj hexadecimálne hodnoty.
Hexadecimálne čísla môžu obsahovať ľubovoľnú postupnosť čísel od 0 do 9 a písmen od a po f, ktoré musia začínať sekvenciou znakov „0x“.

Var a = 255; var b = 0xFF; // Číslo 255 v hexadecimálnom zápise

JavaScript navyše obsahuje špeciálne číselné hodnoty:

• NaN (nie je to chyba čísla alebo výpočtu). Je výsledkom nesprávnej matematickej operácie s neplatnými údajmi, ako sú reťazce alebo nedefinovaná hodnota.
• Nekonečno (pozitívne nekonečno). Používa sa, keď je kladné číslo príliš veľké na to, aby bolo reprezentované v JavaScripte.
• -Nekonečno (záporné nekonečno). Používa sa, keď je záporné číslo príliš veľké na to, aby bolo reprezentované v JavaScripte.
• ±0 (kladná a záporná 0). JavaScript rozlišuje medzi kladnou a zápornou nulou.

Typ údajov reťazca

Typ reťazca je nemenná, usporiadaná sekvencia 16-bitových hodnôt, z ktorých každá predstavuje znak Unicode (písmená, čísla, interpunkcia, špeciálne znaky a medzery). Riadky môžu byť prázdne alebo môžu pozostávať z jedného alebo viacerých znakov. Reťazce sa vytvárajú pomocou dvojitých (") alebo jednoduchých (") úvodzoviek. Reťazec oddelený dvojicou jednoduchých úvodzoviek môže používať dvojité úvodzovky a naopak, jednoduché úvodzovky možno použiť v rámci reťazca uzavretého dvojicou úvodzoviek:

V JavaScripte nie je rozdiel medzi dvojitými a jednoduchými úvodzovkami, ale úvodzovky na začiatku a na konci reťazca by sa nemali líšiť. Napríklad takýto výraz by spôsobil chybu syntaxe:

var firstName = "Max"; //chyba syntaxe - rôzne úvodzovky

Poznámka: JavaScript nemá špeciálny jednoznakový dátový typ ako char v C, C++ a Java. Jeden znak je reprezentovaný reťazcom jednotkovej dĺžky.

Typ údajov null Typ null obsahuje jedinú špeciálnu hodnotu – null.

Kľúčové slovo null nemožno použiť ako názov funkcie alebo premennej. Hodnota null je odkaz na „prázdny“ objekt a má špeciálny účel – zvyčajne sa používa na inicializáciu premennej, ktorej bude neskôr priradená hodnota.

Operátor typeof pre hodnotu null vracia reťazec "object", čo znamená, že hodnota null je špeciálny "prázdny" objekt.

Nedefinovaný typ údajov

Nedefinovaný typ tvorí svoj vlastný typ, ktorý obsahuje jedinú špeciálnu hodnotu - undefined. Toto je hodnota premennej deklarovanej pomocou operátora var, ale neinicializovaná:

Hodnota undefined sa vráti pri prístupe k premennej, ktorej nikdy nebola priradená hodnota, neexistujúca vlastnosť objektu alebo prvok poľa.

Treba poznamenať, že premenná s nedefinovanou hodnotou sa líši od premennej, ktorá nie je definovaná vôbec:

V tomto príklade metóda alert() zobrazuje hodnotu premennej veku, ktorá nie je definovaná. V druhom prípade sa do metódy alert() odovzdá nedeklarovaná premenná auta, čo vedie k chybe.

Nasledujúci príklad môže byť pre začínajúcich programátorov trochu mätúci, pretože... Operátor typeof vráti hodnotu nedefinovaný pre neinicializovanú aj nedeklarovanú premennú:

Vo vyššie uvedenom príklade je premenná vek deklarovaná, ale nič sa do nej nezapisuje, takže jej hodnota je len nedefinovaná . Premenná auta nie je deklarovaná – v skutočnosti neexistuje. Typeof však v oboch prípadoch vráti reťazec nedefinovaný. To samozrejme dáva zmysel, pretože so žiadnou z týchto premenných nie je možné vykonávať žiadne operácie, hoci technicky sú úplne odlišné.

Poznámka: Odporúča sa vždy inicializovať deklarovanú premennú. V tomto prípade budete vedieť, že operátor typeof vracia nedefinovaný, pretože premenná nebola deklarovaná, nie preto, že nebola inicializovaná.

Hodnota undefined je odvodená od null , takže v ECMA-262 ich operátor ekvivalencie == považuje za rovnaké:

Hoci hodnoty null a undefined spolu súvisia, používajú sa odlišne. Premennej by ste nemali explicitne priradiť hodnotu undefined, ale to neplatí pre hodnotu null. V prípade, že požadovaný objekt nie je k dispozícii, použite namiesto neho hodnotu null. To naznačuje, že null bol zavedený ako ukazovateľ na prázdny objekt a zdôrazňuje jeho rozdiel od nedefinovaného .

Na rozlíšenie medzi hodnotou null a undefined v programe môžete použiť operátor identity === :

Typ údajov Symbol

Symbol je novým prírastkom do JavaScriptu od verzie ECMAScript 6. Symbol je jedinečná, nemenná, primitívna hodnota, ktorá sa používa na vytváranie jedinečných identifikátorov.

Ak chcete vytvoriť symbol, musíte zavolať funkciu Symbol:

var mySymbol = Symbol();

Na definovanie symbolu môžete použiť operátor typeof; ak je hodnotou symbol, vráti sa reťazec:

Funkcia Symbol má voliteľný parameter – reťazec, ktorý slúži na popis symbolu:

Názov vlastnosti je reťazec, takže objekty možno považovať za priraďujúce reťazce k hodnotám. Tieto informácie spolu tvoria páry kľúč – hodnota.

IN JavaScript objekty možno vytvoriť pomocou jednej z dvoch syntaxí:

1. var obj = (); // pomocou objektového literálu 2. var obj = new Object(); // pomocou metódy s názvom konstruktor

Vytvorenie objektu pomocou objektového literálu začína definovaním regulárnej premennej. Na pravej strane tohto príkazu je zapísaný objektový literál - toto je čiarkami oddelený zoznam párov uzavretých v zložených zátvorkách (). "meno-hodnota", uzavreté v kučeravých zátvorkách. Názov vlastnosti a hodnota sú oddelené dvojbodkou:

var cat = ( "nohy": 4, "meno": "Murzik", "farba": "Červená" )

Druhým spôsobom vytvárania objektov je použitie konštruktora Object(). V tomto prípade sa najprv použije nový výraz Object() a potom sa definujú a inicializujú vlastnosti výsledného objektu:

Keď priradíme jednu premennú (ktorej hodnota obsahuje odkaz na zloženú hodnotu) k inej premennej, odkaz na zloženú hodnotu sa skopíruje. Výsledkom je, že obe premenné odkazujú na rovnakú zloženú hodnotu a zmeny v hodnote jednej premennej ovplyvnia druhú premennú.

Akýkoľvek výraz, ktorý vráti 0, null, undefined alebo prázdny reťazec, sa interpretuje ako false .

Reťazce sa vytvárajú pomocou dvojitých (") alebo jednoduchých (") úvodzoviek. Reťazec oddelený dvojicou jednoduchých úvodzoviek môže používať dvojité úvodzovky a naopak, jednoduché úvodzovky možno použiť v reťazci uzavretom dvojicou úvodzoviek.

Hodnota null je odkaz na „prázdny“ objekt a má špeciálny účel – zvyčajne sa používa na inicializáciu premennej, ktorej bude neskôr priradená hodnota.

Hodnota (nedefinovaná) je premenná deklarovaná pomocou operátora var, ale nie je inicializovaná.

V JavaScripte môžu byť objekty vytvorené jedným z dvoch spôsobov:

• pomocou objektového literálu
• pomocou metódy nazývanej konštruktor

Objekt obsahuje neusporiadanú kolekciu vlastností, z ktorých každá obsahuje názov a hodnotu. K objektu môžete kedykoľvek pridať nové pomenované hodnoty alebo odstrániť existujúce.