Premenné, rozsahy a zdvíhanie premenných v JavaScripte. Premenné

Premenná je iba symbolický názov hodnoty. Premenná umožňuje odkazovať na hodnotu podľa názvu, čo znamená, že keď je v programe zadaný názov premennej, hodnota ju nahradí.

Oznam

Pred použitím premennej ju musíte deklarovať. Premenné sú deklarované pomocou kľúčového slova var alebo let, za ktorým nasleduje názov premennej:

Var num; nech num2;

Použitím kľúčového slova var alebo let jedenkrát môžete deklarovať viacero premenných tak, že ich uvediete oddelené čiarkami:

Var num, num2; nech num3, num4;

Inicializácia a priradenie hodnoty

Deklarácie premenných je možné kombinovať s ich inicializáciou. Inicializácia je priradenie počiatočnej hodnoty premennej. Premennej môžete priradiť ľubovoľnú hodnotu pomocou operátora priradenia, ktorý je označený symbolom rovná sa (=):

Var color = "čierna"; nech num = 10, num2 = 15;

Premenným v jazyku JavaScript nie je žiadny typ, takže premennej je možné priradiť hodnotu akéhokoľvek typu a tej istej premennej je možné priradiť hodnotu iného typu:

Var a = 10; nech b = 20; a = "text"; b = "text";

Ak pri deklarácii nebola premennej priradená žiadna hodnota, bude mať špeciálnu hodnotu nedefinovanú, kým jej nebude priradená iná hodnota:

Var a; nech b; console.log (a); // nedefinovaná console.log (b); // nedefinované

Odkazovanie na hodnotu

Keď je premenná deklarovaná, pri použití premennej nie je potrebné zadávať kľúčové slovo var alebo let. Ak sa chcete v programe odvolať na hodnotu premennej, stačí napísať názov premennej, namiesto toho hodnotu uloženú v premennej nahradí interpret JavaScript:

Var x = 10, msg = "Dobrý deň"; výstraha (x); document.write (msg); Skús "

Pretože namiesto názvu premennej je nahradená jej hodnota, môžete hodnotu skopírovať z jednej premennej do druhej:

Var a = 10; nech b; b = a; // Rovnaké ako b = 10;

Ak sa pokúsite použiť nedeklarovanú premennú, zobrazí sa chyba:

Console.log (x); // Chyba

Premenné sú základným stavebným kameňom mnohých programovacích jazykov; sú jedným z najdôležitejších konceptov pre začínajúcich programátorov. JavaScript má mnoho rôznych vlastností pre premenné a tiež niekoľko pravidiel, ktoré je potrebné pri ich pomenovaní dodržiavať. JavaScript má tri kľúčové slová používané na deklarovanie premennej - var, let a const - a každé z nich má vplyv na interpretáciu premennej vo vašom kóde.

Tento tutoriál vám predstaví premenné, spôsob ich deklarácie a pomenovania a vysvetlí rozdiel medzi var, let a const. Okrem toho sa dozviete, čo je to zdvíhanie premenných a ako rozsah ovplyvňuje správanie premennej.

Čo sú to premenné

Premenná je pomenovaný kus pamäte slúžiaci na ukladanie rôznych hodnôt. Informácie, na ktoré je možné viackrát odkazovať, je možné uložiť do premennej na neskoršie použitie alebo úpravu. V. Hodnota JavaScript v rámci premennej môže byť ľubovoľný dátový typ vrátane čísla, reťazca alebo objektu.

Pred jazykovou špecifikáciou ECMAScript 2015 (ES6), z ktorej JavaScript vychádza tento moment, existoval iba jeden spôsob, ako deklarovať premennú - pomocou kľúčového slova var. Preto väčšina starých kódov a príručiek používa na deklarovanie premenných iba var. Pozrime sa na rozdiely medzi var, let a const.

Kľúčové slovo var vám umožňuje predviesť koncept samotnej premennej. V nižšie uvedenom príklade deklarujeme premennú a priradíme jej hodnotu.

// Priraďte hodnotu reťazca 8host k identifikátoru používateľského mena
var username = "8host_blog";

Tento výraz má niekoľko častí:

  • Deklarovanie premennej pomocou kľúčového slova var;
  • Názov premennej (alebo identifikátor), používateľské meno;
  • Operátor priradenia reprezentovaný syntaxou =;
  • Priradená hodnota je "8host_blog".

Teraz môžete vo svojom kóde použiť premennú užívateľského mena. JavaScript si zapamätá, že používateľské meno predstavuje hodnotu 8host_blog.

// Skontrolujte, či sa premenná rovná hodnote
if (používateľské meno === "8host_blog") (
console.log (true);
}
pravda

Ako už bolo spomenuté, premenné je možné vyjadriť pomocou ľubovoľného dátového typu JavaScript. V tomto prípade sú premenné vyjadrené ako reťazec, číslo, objekt, boolovská hodnota a null.

// Priradenie rôznych premenných
var name = "Morty";
var spartans = 300;
var Kingdoms = ["cicavce", "vtáky", "ryby"];
var báseň = (ruže: „červená“, fialky: „modrá“);
var úspech = pravda;
var nič = null;

Pomocou konzoly.log môžete zobraziť hodnotu ľubovoľnej premennej:

// Odoslanie premennej spartans do konzoly
console.log (sparťania);
300

Premenné ukladajú údaje do pamäte, ktoré môžete neskôr použiť alebo zmeniť. Premenným je možné tiež priradiť novú hodnotu. Nasledujúci jednoduchý príklad ukazuje, ako je možné heslo uložiť a potom aktualizovať v premennej.

// Priradenie hodnoty premennej hesla
var heslo = "hunter2";
// Zmena priradenia hodnoty premennej k novej hodnote
heslo = "hunter3";
console.log (heslo);
"hunter3"

V skutočnom programe bude heslo pravdepodobne bezpečne uložené v databáze. Tento jednoduchý príklad však ilustruje situáciu, v ktorej môžete aktualizovať hodnotu premennej. Hodnota premennej hesla bola hunter2, ale bola jej priradená nová hodnota, hunter3 a novú hodnotu teraz použije JavaScript.

Variabilné pomenovanie

V JavaScripte sa názvy premenných nazývajú identifikátory. V príručke nájdete niekoľko pravidiel pre pomenovanie identifikátorov. Tu sú v skratke:

  • Názvy premenných môžu obsahovať iba písmená, čísla (0-9), znak dolára ($) a podčiarkovník (_).
  • Názvy premenných nemôžu obsahovať medzery.
  • Názvy premenných nesmú začínať číslom.
  • Existuje niekoľko vyhradených kľúčových slov, ktoré nemožno použiť ako názvy premenných.
  • V názvoch premenných sa rozlišujú malé a veľké písmena.

JavaScript má tiež konvenciu camelCase pre názvy funkcií a premenných deklarované pomocou var alebo let. V tomto prípade je prvé slovo napísané malými písmenami a každé ďalšie slovo začína na veľké písmeno(slová sa píšu bez medzier medzi nimi). Väčšina premenných, ktoré nie sú konštantami, sa bude až na niekoľko výnimiek riadiť týmto dohovorom. Názvy premenných, ktoré sú konštantné (deklarované kľúčové slovo const) sa zvyčajne píšu veľkými písmenami.

Zdá sa, že existuje niekoľko pravidiel, ale zdá sa to iba na prvý pohľad. Pri častej práci s JavaScriptom si ich rýchlo zapamätáte.

Rozdiel medzi var, let a const

JavaScript používa na deklarovanie premenných tri rôzne kľúčové slová, ktoré dodávajú ďalšiu vrstvu zložitosti. Tieto kľúčové slová sa líšia variabilným rozsahom, zdvíhaním a opätovným priradením.

Možno sa pýtate, ktoré z troch kľúčových slov by ste vo svojich programoch mali použiť. Bežnou praxou je používať const tak často, ako je to len možné, a púšťať slučky a na opätovné priradenie. V starom kóde sa zvyčajne používa var.

Rozsah JavaScript

Rozsah v JavaScripte sa vzťahuje na aktuálny kontext kódu, ktorý určuje prístupnosť premenných. Rozsah môže byť miestny a globálny:

  • Globálne premenné sú tie, ktoré sú deklarované mimo bloku.
  • Miestne premenné sú tie, ktoré sú deklarované vo vnútri bloku.

V nižšie uvedenom príklade vytvoríme globálnu premennú.


var tvor = "vlk";

Viete, že premenné je možné znova priradiť. V miestnom rozsahu môžete vytvárať nové premenné s rovnakým názvom ako premenné vo vonkajšom rozsahu bez zmeny alebo prepísania pôvodnej hodnoty.

Nasledujúci príklad vytvára globálne variabilné druhy. Vnútri funkcie je lokálna premenná s rovnakým názvom. Ich odoslaním do konzoly uvidíte, že hodnota premennej sa líši v závislosti od rozsahu, ale pôvodná hodnota sa nemení.

// Inicializácia globálnej premennej
var species = "človek";
transformácia funkcie () (
// Inicializácia lokálnej premennej s rozsahom funkcií
var species = "vlkodlak";
console.log (druh);
}
// Zaznamenanie globálnej a lokálnej premennej
console.log (druh);
transform ();
console.log (druh);
ľudský
vlkolak
ľudský

V tomto prípade je lokálna premenná nastavená na úrovni funkcie. Premenné deklarované pomocou kľúčového slova var vždy patria do tohto rozsahu (to znamená, že rozpoznávajú funkcie, ktoré majú samostatný rozsah). Lokálna premenná teda nie je k dispozícii v globálnom rozsahu.

Nové kľúčové slová let a const sú však blokované. To znamená, že nový lokálny rozsah je vytvorený z akéhokoľvek bloku, vrátane funkčných blokov, if, príkazov a pre a počas slučiek.

Na ilustráciu rozdielu medzi premennými na úrovni funkcií a blokov vytvorte novú premennú v bloku if pomocou príkazu let.

var fullMoon = true;
// Inicializácia globálnej premennej
nech species = "človek";
if (fullMoon) (
// Inicializácia premennej s rozsahom bloku
nech druhy = "vlkodlak";

}


Nie je spln. Lupin je v súčasnosti človek.

V tomto prípade má variabilný druh jednu globálnu hodnotu (ľudská) a jednu miestnu hodnotu (vlkodlak). Ak však použijete var, budete mať iný výsledok.

// Na inicializáciu premennej použite var
var species = "človek";
if (fullMoon) (
// Pokus o vytvorenie novej premennej v bloku
var species = "vlkodlak";
console.log (`Je mesiac v splne. Lupin je v súčasnej dobe $ (druh) .`);
}
console.log (`Nie je spln. Lupin je momentálne $ (druh) .`);
Je spln. Lupin je v súčasnosti vlkolak.
Nie je spln. Lupin je v súčasnosti vlkolak.

Výsledkom je, že globálne aj blokové premenné vracajú rovnakú hodnotu, vlkodlak. Dôvodom je, že var namiesto toho, aby vytvoril novú lokálnu premennú, znova priradí rovnakú premennú v rovnakom rozsahu. var nechápe, že ak musí byť súčasťou iného, ​​nového rozsahu. Všeobecne je vhodné deklarovať premenné na úrovni bloku, pretože sa tým znižuje riziko neúmyselného prepísania hodnôt premenných.

Premenné zdvíhania

Väčšina doterajších príkladov použila na deklarovanie premennej kľúčové slovo var a premenná bola inicializovaná hodnotou. Po deklarovaní a inicializácii môžete pristupovať k hodnote alebo znova priradiť premennú.

Ak sa pokúsite použiť premennú pred jej deklarovaním a inicializáciou, vráti sa nedefinovaná.


console.log (x);
// Variabilné priradenie
var x = 100;
nedefinované

Ak však vynecháte kľúčové slovo var, premenná nebude deklarovaná, ale iba inicializovaná. To vráti ReferenceError a zastaví spustenie skriptu.

// Pokus o použitie premennej pred jej deklarovaním
console.log (x);
// Variabilné priradenie bez var
x = 100;
ReferenceError: x nie je definované

Súvisí to so zdvíhaním - toto je správanie JavaScriptu, ktoré presúva deklarácie premenných a funkcií na vrchol svojho rozsahu. Pretože je zdvihnutá iba skutočná deklarácia a nie inicializácia, v prvom prípade sa vráti nedefinované.

Aby sme tento koncept lepšie demonštrovali, spísali sme nasledujúci kód a vysvetlili sme, ako ho JavaScript číta:

// Kód, ktorý sme napísali
console.log (x);
var x = 100;
// Ako si to interpretoval JavaScript
var x;
console.log (x);
x = 100;

JavaScript pred vykonaním skriptu uloží x do pamäte ako premennú. Pretože premenná bola volaná skôr, ako bola definovaná, výsledok sa vráti nedefinovaný a nie 100. To však nevyvolá ReferenceError ani nezastaví skript. Kľúčové slovo var v skutočnosti nezmenilo umiestnenie var, ale ukazuje, ako zdvíhanie funguje. Toto správanie môže spôsobovať problémy, pretože programátor, ktorý napísal tento kód, pravdepodobne očakáva, že výstup x bude pravdivý a nie nedefinovaný.

Tiež zdvíhanie môže viesť k nepredvídateľným výsledkom, ako v nasledujúcom príklade:


var x = 100;
funkčný zdvihák () (
// Podmienka, ktorá by nemala mať vplyv na výsledok kódu
ak (nepravda) (
var x = 200;
}
console.log (x);
}
zdvihák ();
nedefinované

V tomto prípade je globálna premenná x 100. V závislosti od príkazu if sa x môže zmeniť na 200, ale keďže podmienka bola falošná, nemalo by to ovplyvniť hodnotu x. Namiesto toho bolo x zdvihnuté pred spustením funkcie kladkostroj () a hodnota sa stala nedefinovanou.

Toto nepredvídateľné správanie môže spôsobiť chyby programu. Pretože let a const sú definované na úrovni bloku, nebudú sa zdvíhať rovnakým spôsobom ako v nasledujúcom príklade.

// Inicializácia x v globálnom rozsahu
nech x = true;
funkčný zdvihák () (
// Inicializujte x v rozsahu funkcie
ak (3 === 4) (
nech x = false;
}
console.log (x);
}
zdvihák ();
pravda

Duplicitné deklarácie premenných, ktoré sú možné s var, spôsobia chybu pomocou let a const.

// Pokus o prepísanie premennej deklarovanej pomocou var
var x = 1;
var x = 2;
console.log (x);
2
// Pokus o prepísanie premennej deklarovanej pomocou let
nech y = 1;
nech y = 2;
console.log (y);

Uncaught SyntaxError: Identifikátor „y“ už bol deklarovaný
Premenné deklarované pomocou var môžu byť teda ovplyvnené zdvíhaním. Zdvíhanie je mechanizmus v jazyku JavaScript, kde sú deklarácie premenných uložené v pamäti. To môže viesť k nedefinovaným premenným vo vašom kóde. Kľúčové slová let a const riešia tento problém zahodením chyby, keď sa pokúsite použiť premennú pred jej deklarovaním alebo deklarovať premennú viackrát.

Konštanty

Mnoho programovacích jazykov používa konštanty - to sú hodnoty, ktoré nemožno zmeniť. To znamená, že hodnotám priradeným ku konštante nemožno opätovne priradiť.

Podľa konvencie sú identifikátory const veľkými písmenami. To ich odlišuje od ostatných premenných.

V nižšie uvedenom príklade je premenná SPECIES inicializovaná ako konštanta pomocou kľúčového slova const. Pokus o opätovné priradenie premennej bude mať za následok chybu.

// Priradenie hodnoty konšt
konšt DRUHY = "človek";
// Pokus o opätovné priradenie hodnoty
DRUHY = "vlkodlak";
console.log (DRUHY);
Uncaught TypeError: Priradenie k konštantnej premennej.

Pretože konštantné hodnoty nemožno opätovne priradiť, musia byť deklarované a inicializované súčasne, inak dôjde k chybe.

// Deklarujte, ale neinicializujte konštantu
const TODO;
console.log (TODO);
Uncaught SyntaxError: Chýba inicializátor v vyhlásení const

Hodnoty, ktoré sa nedajú zmeniť počas programovania, sa nazývajú nemenné a hodnoty, ktoré je možné meniť, sa nazývajú premenlivé (to je zrejmé). Konštantné hodnoty nie je možné znova priradiť, ale sú premenlivé, pretože vlastnosti objektov deklarovaných pomocou const je možné zmeniť.

// Vytvorte objekt CAR s dvoma vlastnosťami
const CAR = (
farba: "modrá",
cena: 15 000
}
// Úprava vlastnosti CAR
CAR.cena = 20000;
console.log (CAR);
(farba: "modrá", cena: 20 000)

Konštanty vám umožňujú povedať iným programátorom, ktorí pracujú na projekte, a sebe, že daná premenná by nemala byť preradená. Ak chcete deklarovať premennú, ktorej je možné opätovne priradiť, použite let.

Záver

V tomto návode ste sa dozvedeli, čo je to premenná, oboznámili ste sa s pravidlami pomenovania premenných a naučili ste sa znova priradiť ich hodnoty. Tiež ste sa dozvedeli o určovaní rozsahu a zdvíhaní, obmedzeniach kľúčového slova var a o tom, ako tieto problémy opraviť príkazom let a const.

V tomto prípade sú x, y a z premenné:

Od vyššie uvedeného príkladu môžete očakávať:

  • x si ponechá hodnotu 5
  • y si ponechá hodnotu 6
  • z si ponechá hodnotu 11

Presne ako algebra

V tomto prípade sú price1, price2 a total premenné:

Pri programovaní, rovnako ako v algebre, používame na ukladanie hodnôt premenné (ako cena1).

Pri programovaní, rovnako ako v algebre, používame vo výrazoch premenné (celkom = cena1 + cena2).

Z vyššie uvedeného príkladu môžete vypočítať celkovú hodnotu 11.

Premenné JavaScript sú kontajnery na ukladanie hodnôt údajov.

JavaScript identifikátory

Všetko premenné JavaScript by mal byť identifikované s jedinečné mená.

Tieto jedinečné mená sa nazývajú identifikátory.

Identifikátormi môžu byť krátke názvy (napríklad x a y) alebo popisnejšie názvy (vek, súčet, celkový objem).

Všeobecné pravidlá pre vytváranie názvov pre premenné (jedinečné identifikátory) sú:

  • Mená môžu obsahovať písmená, číslice, podčiarkovníky a znaky dolára.
  • Mená musia začínať písmenom
  • Mená môžu tiež začínať znakmi $ a _ (v tomto návode ho však nebudeme používať)
  • V názvoch sa rozlišujú malé a veľké písmená (y a Y sú rôzne premenné)
  • Vyhradené slová (ako napríklad kľúčové slová JavaScript) nemožno použiť ako názvy

V identifikátoroch JavaScript sa rozlišujú malé a veľké písmena.

Operátor priradenia

V JavaScripte je znamienko rovnosti (=) operátorom „priradenia“, nie „rovným“.

To sa líši od algebry. Nasledujúce nemá zmysel v algebre:

V JavaScripte to však dáva zmysel: priradí hodnotu x + 5 x.

(Vypočíta hodnotu x + 5 a výsledok vloží do x. Hodnota x sa zvýši o 5)

Operátor „rovný“ je v jazyku JavaScript zapísaný ako ==.

Dátové typy JavaScript

Premenné JavaScript môžu obsahovať čísla ako 100 a textové hodnoty ako „John Doe“.

Pri programovaní sa textové hodnoty nazývajú textové reťazce.

JavaScript môže pracovať s odlišné typyúdaje, ale zatiaľ si predstavte iba čísla a reťazce.

Reťazce sú napísané v dvojitých alebo jednoduchých úvodzovkách. Čísla sú napísané bez úvodzoviek.

Ak okolo čísla vložíte úvodzovky, bude sa s ním zaobchádzať ako s textovým reťazcom.

Deklarácia (vytváranie) premenných JavaScript

Vytvorenie premennej v JavaScripte sa nazýva „deklarovanie“ premennej.

Deklarujete premennú JavaScript pomocou kľúčové slovo var:

Po deklarovaní je premenná irelevantná. (Technicky je to dôležité nedefinované)

Komu priradiť hodnotu premennej, použite znamienko rovnosti:

carName = "Volvo";

Premennej môžete tiež priradiť hodnotu, keď ju deklarujete:

var carName = "Volvo";

V nižšie uvedenom príklade vytvoríme premennú s názvom carName a priradíme k nej hodnotu „Volvo“.

Potom hodnotu „opustíme“ v položke HTML pomocou id = „demo“:

príklad

Skúste to sami “

Jedno tvrdenie, veľa premenných

V jednom príkaze môžete deklarovať mnoho premenných.

Začnite svoju aplikáciu s var a rozdeľte premenné pomocou čiarka:

Vyhlásenie môže zahŕňať niekoľko riadkov:

Hodnota = nedefinovaná

V. počítačové programy, premenné sú často deklarované bez hodnoty. Hodnota môže byť niečo, čo je potrebné vypočítať, alebo niečo, čo bude poskytnuté neskôr ako vstup používateľa.

Premenná deklarovaná bez hodnoty bude mať hodnotu nedefinované.

Po vykonaní tohto príkazu bude premenná carName nedefinovaná.

Táto kapitola obsahuje základnú gramatiku, deklarácie premenných, dátové typy a doslovné výrazy.

Základy

JavaScript si požičiava veľkú časť svojej syntaxe z Javy, ale bol tiež ovplyvnený jazykmi ako Awk, Perl a Python.

JavaScript rozlišujú sa malé a veľké písmená a používa kódovanie znakov Unicode... Napríklad slovo Früh (v nemčine) môže byť použité ako názov premennej.

Var Früh = "foobar";

Premenná früh však nie je rovnaká ako Früh, pretože JavaScript rozlišuje veľké a malé písmena.

Komentáre (1)

Syntax komentáre je rovnaký ako v C ++ a v mnohých ďalších jazykoch:

// Komentujte jeden riadok. / * Komentár pokrývajúci viac riadkov. * / / * Nemôžete vnoriť / * komentár do komentára * / Chyba syntaxe * /

reklamy

V jazyku JavaScript existujú tri druhy vyhlásení:

var Deklaruje premennú, inicializáciu variabilná hodnota m je voliteľné. nechaj Deklaruje lokálnu premennú v rozsahu bloku, inicializácia premennej na hodnotu je voliteľná. konšt Deklaruje pomenovanú konštantu určenú len na čítanie.

Premenné

Premenné môžete použiť ako symbolické názvy hodnôt vo vašej aplikácii. Názvy premenných sa nazývajú identifikátory a musia dodržiavať určité pravidlá.

Identifikátory JavaScript musia začínať písmenom, podčiarkovníkom (_) alebo znakom dolára ($); nasledujúce znaky môžu byť tiež čísla (0-9). Pretože v jazyku JavaScript sa rozlišujú malé a veľké písmena, písmena obsahujú znaky „A“ až „Z“ ( veľké písmená) a znaky „a“ ​​až „z“ (malé písmená).

V identifikátoroch, ako sú å alebo ü, môžete použiť písmená ISO 8859-1 alebo Unicode. Oba znaky môžete použiť aj v identifikátoroch.

Niekoľko príkladov platných mien: Number_hits, temp99, _name.

Deklarácia premenných

Premennú môžete deklarovať tromi spôsobmi:

  • Použitie kľúčového slova var. Napríklad var x = 42. Túto syntax je možné použiť na deklaráciu lokálnych aj globálnych premenných.
  • Stačí premennej priradiť hodnotu. Napríklad x = 42. Takto deklarované premenné sú globálne. Takéto vyhlásenie vytvára prísny režim. Táto metóda sa neodporúča.
  • Použitie kľúčového slova let. Napríklad nech y = 13. Túto syntax je možné použiť na deklaráciu lokálnej premennej v rozsahu bloku.

Priradenie hodnôt

Premenná deklarovaná pomocou var alebo let bez priradenia počiatočnej hodnoty nie je definovaná.

Ak sa pokúsite získať prístup k nedeklarovanej premennej alebo premennej pred jej deklarovaním, vyvolá sa výnimka ReferenceError:

Var a; console.log ("Hodnota a je" + a); // Hodnota premennej a je nedefinovaná console.log ("Hodnota b je" + b); // Uncaught ReferenceError: b not defined console.log ("Hodnota c je" + c); // Hodnota premennej c je nedefinovaná var c; console.log ("Hodnota x je" + x); // Uncaught ReferenceError: x is not defined let x;

Môžete použiť undefined na určenie, či má premenná hodnotu. V nasledujúcom príklade nemá premennej vstup priradenú hodnotu a príkaz if bude vyhodnotený ako pravdivý:

var vstup; if (input === undefined) (doThis ( ); ) else (doThat ( ) ; }

Pri použití v booleovskom kontexte sa nedefinovaná hodnota správa ako falošná. Nasledujúci kód napríklad spustí funkciu myFunction, pretože prvok myArray nie je definovaný:

var myArray =; if (! myArray [0]) (myFunction ( ) ; }

Nedefinovaná hodnota sa prevedie na NaN, ak sa použije v číselnom kontexte:

var a; a + 2; // NaN

Ak je pole vytvorené v skripte najvyššej úrovne pomocou literálu, JavaScript interpretuje pole vždy, keď vyhodnotí výraz, ktorý obsahuje literál. Okrem toho sa literál použitý vo funkcii vytvorí vždy, keď sa funkcia zavolá.

Extra čiarky v poli literálov

Nie je potrebné zahrnúť všetky prvky do doslovného poľa. Ak vložíte dve čiarky za sebou, chýbajúce prvky budú nedefinované. Napríklad:

var ryba = ["lev" ,, "anjel"]; // [„Lev“, nedefinovaný, „anjel“]

Toto pole má 2 prvky s hodnotami a jeden prázdny (ryba je „lev“, ryba nie je definovaná a ryba je „anjel“).

Ak na koniec zoznamu položiek uvediete čiarku, bude ignorovaná. V nasledujúcom príklade je dĺžka poľa 3. Žiadny myList. Všetky ostatné čiarky v zozname označujú novú položku.

Komentár: Extra čiarky môžu v starších verziách prehliadačov spôsobiť chyby, preto je najlepšie sa ich používaniu vyhnúť.

var myList = ["domov" ,, "škola",]; // ["domov", nedefinované, "škola"]

V nasledujúcom príklade je dĺžka poľa štyri a prvky myList a myList nie sú definované:

var myList = [, "domov" ,, "škola"]; //

V nasledujúcom príklade je dĺžka poľa štyri a prvky myList a myList nie sú definované. Ignoruje sa iba posledná čiarka.

var myList = ["domov" ,, "škola" ,,]; // ["domov", nedefinované, "škola", nedefinované]

Pochopenie správania extra čiarok je dôležité pre pochopenie JavaScriptu ako jazyka. Pri písaní vlastného kódu však majte na pamäti, že explicitné vyhlásenie chýbajúcich prvkov za nedefinovaných zlepšuje prehľadnosť kódu a jednoduchú údržbu.

Booleovské literály

Booleovský typ má dve doslovné hodnoty: true a false.

Nezamieňajte si primitívne booleovské hodnoty true a false s pravdivými a nepravdivými hodnotami booleovského objektu. Booleovský objekt je obalový objekt nad boolovským primitívom. Ak chcete získať viac detailné informácie, prečítajte si Boolean.

Celé číslo doslovne

Celé čísla môžu byť zapísané v desiatkových, hexadecimálnych, osmičkových a binárnych systémoch.

  • Desatinný celočíselný literál pozostáva zo sekvencie číslic bez úvodnej nuly.
  • Začiatočná nula v celom čísle znamená, že je v osmičkách. Osmičkové celé čísla pozostávajú iba z číslic 0-7.
  • Úvodné znaky 0x (alebo 0X) označujú, že číslo je hexadecimálne. Hexadecimálne celé čísla môžu pozostávať z číslic 0-9 a písmena a-f a A-F.
  • Úvodné znaky 0b (alebo 0B) označujú, že číslo je binárne. Binárne čísla môžu obsahovať iba číslice 0 a 1.

Niekoľko príkladov celočíselných literálov:

0, 117 a -345 (desatinné) 015, 0001 a -077 (osmičkové) 0x1123, 0x00111 a -0xF1A7 (hex) 0b11, 0b0011 a -0b11 (binárne)

Doslovný bod s pohyblivou rádovou čiarkou

Čísla s pohyblivou rádovou čiarkou môžu pozostávať z nasledujúcich častí:

  • Desatinné celé číslo, ktoré môže mať pred znamienkom znamienko (symbol „+“ alebo „-“),
  • Desatinná čiarka ("."),
  • Zlomková časť (ďalšie desatinné číslo),
  • Vystavovateľ.

Exponent pozostáva z „e“ alebo „E“, za ktorým nasleduje celé číslo, ktoré môže mať znamienko. Číslo s pohyblivou rádovou čiarkou musí obsahovať aspoň jednu číslicu a buď desatinnú čiarku, alebo znak „e“ (alebo „E“).

Stručnejšie, syntax je nasledovná:

[(+ | -)] [. číslice] [(E | e) [(+ | -)] číslice]

3,14 -3,1E + 12 -,33333333333333333333333 .1e -23

Objekt doslovne

Objektový literál je zoznam nulových alebo viacerých párov názvov vlastností a súvisiacich hodnôt, uzavretý v rovnátka(()). Na začiatku výrazu by ste nemali používať objektový literál, pretože výsledkom bude chyba alebo správanie, ktoré neočakávate, pretože znak „(“ bude interpretovaný ako začiatok bloku.

V nasledujúcom príklade je vlastnosti myCar objektu automobilu priradený reťazec „Saturn“, vlastnosť getCar je výsledkom volania funkcie CarTypes („Honda“) a špeciálnou vlastnosťou je hodnota premennej Predaj. :

var Predaj = "Toyota"; funkcia CarTypes ( meno) (if (name == "Honda") (návratové meno;) else (návrat „Prepáčte, nepredávame“+ meno + "." ; )) var car = (myCar: "Saturn", getCar: CarTypes ( „Honda“), špeciálne: Predaj); konzola. log ( auto. moje auto); // Konzola Saturn. log ( auto. getCar); // Konzola Honda. log ( auto. špeciálne); // Toyota

Okrem toho môžete v názvoch vlastností použiť číselné alebo reťazcové literály alebo vnoriť jeden objekt do druhého. Napríklad:

var car = (manyCars: (a: "Saab", "b": "Jeep"), 7: "Mazda"); konzola. log ( auto. veľaAutá. b); // Jeep konzola. log ( auto [7]); // Mazda

Názov vlastnosti objektu môže byť ľubovoľný reťazec vrátane prázdneho reťazca. Ak názov vlastnosti nie je platným identifikátorom JavaScript, musí byť uzavretý v úvodzovkách. Na označenie týchto mien použite hranaté zátvorky(), ani bodka (.):

var neobvykláPropertyNames = ("": "Prázdny reťazec", "!": "Bang!") konzola. log ( neobvykléVlastnéMená. ""); // SyntaxError: Neočakávaný reťazec konzola. log ( neobvykléVlastnéMená [""]); // Konzola "Prázdny reťazec". log ( neobvykléVlastnéMená. ! ); // SyntaxError: Neočakávaný token! konzola. log ( neobvykléVlastnéMená ["!" ]); // "Bang!"

V ES2015 sú objektové literály rozšírené o podporu nastavenia prototypu v skrátenej konštrukcii pre foo: nastavenie foo, definovanie metód, super hovory a vyhodnocovanie názvov vlastností vo výrazoch. Spolu robia objektové literály a deklarácie tried podobnými a tiež umožňujú objektovému dizajnu využívať výhody rovnakých schopností.

Var obj = (// __proto__ __proto__: theProtoObj, // Krátka notácia pre 'handler: handler' handler, // Methods toString () (// Super calls return "d" + super.toString ();), // Dynamic výpočet názvov vlastností ["prop_" + (() => 42) ()]: 42);

Pozrite sa na nasledujúci príklad:

var foo = (a: "alfa", 2: "dva"); konzola. log ( foo. a); // alfa konzola. log ( foo [2]); // dva // console.log (foo.2); // SyntaxError: Neočakávané číslo// console.log (foo [a]); // ReferenceError: a nie je definovaná konzola. log ( foo ["a"]); // alfa konzola. log ( foo ["2"]); // dva

Doslova RegExp

Doslovný výraz regexp je vzor medzi lomkami. Nasledujúci príklad je doslovným regulárnym výrazom:

Var re = / ab + c /;

Reťazec doslovný

Reťazcový literál je nula alebo viac znakov uzavretých v dvojitých (") alebo jednoduchých (") úvodzovkách. Reťazec musí byť oddelený úvodzovkami rovnakého typu, t.j. buď jednolôžkové, alebo obe dvojité. Napríklad:

"foo" "bar" "1234" "jeden riadok \ n ďalší riadok" "Johnova mačka"

Na reťazcový literál môžete zavolať ľubovoľnú z metód objektu String: JavaScript reťazec doslovne prevedie na dočasný objekt String, zavolá metódu a potom dočasný objekt String zničí. Vlastnosť String.length môžete použiť aj s doslovným reťazcom:

Konzola. log ( „Johnova mačka“. Dĺžka); // Počet znakov v reťazci vrátane medzery.// V tomto prípade je dĺžka reťazca 10.

Šablóny reťazcov sú k dispozícii aj v ES2015. Reťazce sú syntaktickým cukrom na stavbu reťazcov. Je to podobné schopnostiam interpolácie reťazcov v jazykoch Perl, Python a ďalších. Okrem toho je možné pridať značku, ktorá umožní prispôsobenie konštrukcie reťazcov, čím sa zabráni útokom na injekciu a budovaniu dátových štruktúr vysoký stupeň z obsahu reťazca.

// Jednoduché vytváranie reťazcov pomocou doslovného reťazca `V JavaScripte \ n" je riadok. "// Viacriadkové reťazce` V JavaScripte to nie je legálne. // Interpolácia reťazcov var name =" Bobby ", time = "dnes"; `Dobrý deň, $ (name), how are you $ (time)?` // Vytvorte predponu Požiadavka HTTP používa sa na interpretáciu náhrad a konštrukciu POST`http: //foo.org/bar? a = $ (a) & b = $ (b) Typ obsahu: aplikácia /json X-poverenia: $ (poverenia) („foo“ : $ (foo), "bar": $ (bar)) `(myOnReadyStateChangeHandler);

Reťazcové literály by ste mali používať, pokiaľ konkrétne nepotrebujete objekt String. Ďalšie informácie o objekte String nájdete v článku String.

Použitie špeciálnych znakov v reťazcoch

Okrem bežných znakov môžete do reťazcov zahrnúť aj špeciálne znaky.

"jeden riadok \ n ďalší riadok"

Nasledujúca tabuľka uvádza špeciálne znaky, ktoré môžete použiť.

Špeciálne znaky v JavaScripte
Symbol Význam
\ b Backspace
\ f Preklad alebo informačný kanál stránok (informačný kanál)
\ n Line feed (nový riadok)
\ r Návrat vozíka
\ t Tab (Tab)
\ v Zvislá karta
\" Apostrof alebo jednoduchý citát
\" Dvojitý citát
\\ Spätné lomítko
\XXX

Znak Latin-1 reprezentovaný tromi osmičkovými číslami XXX od 0 do 377. Napríklad \ 251 (symbol ©).
\ X Xx

Znak Latin-1 reprezentovaný dvoma hexadecimálnymi číslami Xx 00 až FF. Napríklad \ xA9 (znak ©).
\ u XXXX

Znak Unicode reprezentovaný štyrmi hexadecimálnymi číslami XXXX... Napríklad \ u00A9 (znak ©).
\ u (XXXXX) Postava je v UTF-32BE. Napríklad \ u (2F804) znamená to isté ako pravidelný vstup\ uD87E \ uDC04.

Unikajúce postavy

V prípade znakov, ktoré nie sú uvedené v predchádzajúcej tabuľke, sa úvodné spätné lomítko ignoruje. Toto použitie je zastarané a mali by ste sa mu vyhnúť.

Do reťazca môžete vložiť úvodzovku tak, že pred ňu vložíte spätné lomítko. Hovorí sa tomu unikajúce úvodzovky. Napríklad:

var citát = „Čítal„ Kremáciu Sama McGeeho “od R.W. Service.“; konzola. log ( citát); // Čítal „Kremácia Sama McGeeho“ od R.W. Služba.

Ak chcete do reťazca zaradiť spätné lomítko, musíte mu predchádzať ďalšou spätnou lomkou. Napríklad:

var home = "c: \\ temp"; // c: \ teplota

Môžete tiež uniknúť novým riadkom. Z obsahu reťazca bude odstránené spätné lomítko a informačný kanál. Napríklad:

var str = "konzola \ je prerušená \ vo viacerých \ riadkoch." log ( str); // tento reťazec je prerušený na viacerých riadkoch.

Aj keď JavaScript nepodporuje syntax „heredoc“ (formátovaný text v premennej s jedným reťazcom), môžete ho emulovať pridaním nového riadka a spätného lomítka na koniec každého riadka:

var poem = "Ruže sú červené, \ n \ Fialky sú modré. \ n \ Som schizofrenik, \ n \ A ja tiež."

Ďalšie informácie

Táto kapitola sa zameriava na základnú syntax deklarácií a typov. Pre viac informácií o JavaScript konštrukcie, čítať:

Nasledujúca kapitola sa zaoberá konštrukciami riadenia a spracovaním chýb.

Pri práci v jazyku Javascript môžeme zadávať číselné, reťazcové a logické hodnoty, ale fungujú, ak program obsahuje potrebné informácie. Za týmto účelom boli vytvorené premenné, ktoré vám umožňujú ukladať rôzne druhy informácií samy o sebe a sú ako akýsi kontajner, na ktorý sa môžeme kedykoľvek obrátiť a získať informácie, ktoré sa v ňom nachádzajú.

Variabilná tvorba

Premenná sa vytvára v dvoch krokoch: deklarovanie premennej a priradenie jej názvu.

Najprv musíme deklarovať premennú, to znamená, že ju deklarujeme, to sa robí pomocou kľúčového slova var. Ďalej napíšeme inštrukciu, toto je názov premennej, jej názov, ako sa na ňu budeme odvolávať, napríklad napíšem dwstv.


Je len na vás, aké premenné pomenujete, ale aby javascript fungoval, je potrebné dodržať niekoľko pravidiel:

  • prvé pravidlo, vyhnite sa používaniu vyhradených slov... Niektoré slová v jazyku JavaScript sa používajú v samotnom systéme, napríklad slovo var, pomocou ktorého deklarujeme premennú. Niektoré slová, ako napríklad výstraha, dokument, okno, sa navyše považujú za špeciálne vlastnosti webovej stránky. Ak sa ich pokúsite použiť ako premenné, zobrazí sa chybové hlásenie. Tu nájdete zoznam vyhradených slov.
  • druhé pravidlo, názov premennej musí začínať písmenom, $ alebo _... To znamená, že premenná nemôže začínať číslom alebo interpunkčným znamienkom: názov 1dwstv a & dwstv nebude fungovať, ale názvy $ dwstv a _dwstv budú.
  • tretie pravidlo, názov premennej môže obsahovať písmená, číslice, symboly $ a _ a v názve nemožno použiť medzery ani iné špeciálne znaky: dws & tv a dws tv sú neplatné názvy, ale tento formát môže byť dws_tv a dwstv1 alebo dws_tv_1.
  • štvrté pravidlo, názvy premenných rozlišujú veľké a malé písmena... Tlmočník JavaScript interpretuje malé a veľké písmena odlišne, to znamená, že premenná DWSTV sa líši od premennej dwstv, ako aj od premenných DwStv a Dwstv.
  • piate pravidlo, n neodporúča sa používať iné znaky ako latinku, premenné písané azbukou, budú síce fungovať, ale nie je to zaručené, okrem toho ich kolegovia z iných krajín nepochopia.

Toto je päť hlavných pravidiel, ktoré odporúčam dodržiavať, okrem nich chcem ešte povedať, priradiť svojim premenným jasné a expresívne názvy. Pomenujte premenné podľa typu údajov, ktoré do nich ukladáte, pomôže vám to v budúcnosti porozumieť tomu, čo je napísané, a pri pohľade na tieto premenné bude zrejmé, o čom reč je.

Pri pomenovávaní premenných sa snažte, aby boli čitateľné. Pri použití viacerých slov pridajte medzi ne podčiarkovník alebo každé slovo za prvým začnite veľkým písmenom. Napríklad dwsTv alebo dws_tv.

Použitie premenných

Na začiatku hodiny sme zistili, z čoho sa premenná skladá, a keď už vieme, ako ju vytvoriť, môžeme do nej podľa vlastného uváženia uložiť akékoľvek dátové typy.

Na vloženie údajov do premennej použite špeciálna postava, znamienko rovnosti (=), sa nazýva operácia priradenia pretože slúži na priradenie hodnoty premennej.


Poďme napríklad vložiť digitálnu hodnotu do premennej dwstv, počet predplatiteľov je 8500, deklarovať premennú var dwstv; a do druhého riadka vložíme hodnotu dwstv = 8500;

Var dwstv; dwstv = 7200;

A tak sme v prvom riadku vytvorili premennú a v druhom sme doň uložili hodnotu. Môžeme tiež vytvoriť premennú a uložiť do nej hodnoty pomocou jednej inštrukcie, napríklad:

Var dwstv = 7200;

Do premennej môžeme uložiť akékoľvek dátové typy, ktorými sme prešli v predchádzajúcich lekciách, môžu to byť číselné, reťazcové a logické hodnoty:

Var dwstv = 7200; var lekcie = 'JavaScript'; var youtubeKanal = 'DwsTV'; var subscribers = „7700“; var obsah = true;

Tiež môžeme ušetriť miesto a čas deklarovaním premenných jedným kľúčom var, napríklad:

Var lekcie = 'JavaScript', youtubeKanal = 'DwsTV', predplatitelia = '7700', obsah = true;

Potom, čo sme hodnoty uložili do premenných, máme možnosť k týmto údajom pristupovať. Na tento účel stačí použiť názov samotnej premennej.

Ak napríklad potrebujeme otvoriť dialógové okno s upozornením a zobraziť hodnotu uloženú v premennej kanal, stačí, ak do funkcie varovania napíšeme názov premennej.

Alert (kanal);

Upozorňujeme, že premenné neuzatvárame do úvodzoviek - slúžia iba na reťazce, a preto nepíšeme výstrahu („kanal“), pretože v tomto prípade dostaneme slová kanal, nie hodnotu uloženú v premennej.

Teraz si myslím, že ste prišli na to, prečo by mali byť reťazce citované: interpret JavaScriptu považuje slová bez úvodzoviek buď za špeciálne objekty (napríklad príkaz alert ()), alebo za názvy premenných.

A je tu aj taký moment, keď sme premennú deklarovali pomocou kľúčového slova var, a chceme v premennej zmeniť hodnotu, nie je potrebné ju znova deklarovať napísaním slova var, stačí zavolať meno premennej a priradiť jej novú hodnotu.

Predplatitelia = „10 000“;

Na konci tejto hodiny chcem povedať, že naučením sa akéhokoľvek jazyka sa nenaučíte programovať. Nepochybne sa naučíte niečo nové, ale s najväčšou pravdepodobnosťou si váš mozog tieto informácie nepamätá, pretože s nimi nepracujete. Naučiť sa jazyk bez praxe nie je možné, takže z tejto lekcie dostanete malú úlohu, aby vám poskytnuté informácie zodpovedali a mohli ste s nimi pracovať.

Praktická úloha:

Vytvorte tri premenné, jednu s číselnou hodnotou, druhú s hodnotou reťazca a tretiu s booleovskou hodnotou. Všetky premenné deklarujte pomocou jedného kľúčového slova var a zobrazte ich na stránke. Potom premennú prepíšte číselnou hodnotou a výsledok zobrazte pomocou funkcie alert ().


Na začiatku nasledujúceho videa analyzujeme tento problém, podelíme sa o vaše výsledky v komentároch a v prípade akýchkoľvek otázok napíšte. Komu sa hodina páčila a chce projekt podporiť, stačí ho zdieľať na sociálnych sieťach.

V nasledujúcej lekcii sa bližšie pozrieme na to, ako pracovať s dátovými typmi a premennými, zoznámime sa s matematickými operáciami a poradím ich vykonávania a tiež analyzujeme metódy kombinovania reťazcových a číselných hodnôt.

Lekciu pripravil Denis Gorelov.