Identifikátory jsou jména proměnných, funkcí a vlastností objektů, mohou být libovolně dlouhé, skládají se z malých i velkých písmen anglické abecedy, číslic a mohou být tvořeny také znakem podtržítko “_” a znakem dolar “$”. Číslice však nesmí stát na začátku identifikátoru a identifikátory se rozlišují i podle velikosti písmen neboť JavaScript je jazykem citlivým na velikost písmen. Je tedy nezbytné dodržovat velikost písmen při psaní identifikátorů nejrůznějších rezervovaných slov, proměnných a názvů funkcí a objektů. Identifikátory uživatelem vytvořených proměnných, funkcí a objektů se nesmí shodovat s identifikátory rezervovaných slov JavaScriptu (viz. Příloha 1).
promenna_1 /* identifikátory čtyř různých proměnných */
$jina_promenna
ahoj
Ahoj
JavaScript umožňuje práci s hodnotami rozličných typů, s nimi lze provádět výpočty, které se v programu zapisují jako výrazy skládající se z operandů a operací. Typ je v podstatě množina hodnot, pro kterou jsou jazykem definovány povolené operace. JavaScript rozlišuje tyto typy hodnot:
Hodnoty tzv. primitivních datových typů undefined, number, string a boolean jsou přímo ukládány do proměnných a pro zápis jejich hodnot existují v jazyku definované formáty hodnot, tazvané literály. V JavaScriptu tedy existují číselné, řetězcové a booleovské literály a literál null.
Typy function a object, tzv. odkazové typy, neobsahují přímo funkce nebo objekty, ale pouze odkazy na ně. Odkazy na funkce a objekty se vyjadřují identifikátory těchto funkcí nebo objektů.
Pokud je potřeba v programu vyjádřit, že proměnná obsahuje odkaz, který neukazuje prostě nikam, lze použít literál null:
var Odkaz_na_nic = null /* odkaz nikam neukazuje */
Typ undefined obsahuje pouze jediný prvek – nedefinovanou hodnotu. V JavaScriptu má nedefinovanou hodnotu proměnná, do které ještě nebyla hodnota přiřazena. Pro otestování proměnné, zda neobsahuje hodnotu undefined lze použít například:
function Isundefined (hodnota) {
return (hodnota == undefined)
}
Typ number je typ číselných hodnot, pro které jsou definovány aritmetické operace. V JavaScriptu existuje pouze jeden číselný typ: 64–bitový formát v plovoucí desetinné čárce. Javascript dále rozeznává dva typy číselných literálů: celočíselné a semilogaritmické.
Celočíselné literálySemilogaritmické literály
Tyto literály mohou mít tvar:
dekadická–číslice [.dekadická–číslice] [exponentová–část]
nebo:
.dekadická–číslice [exponentová–část]
Speciální číselné hodnoty
Pokud během výpočtu vznikne hodnota, kterou nelze v 64 bitové reprezentaci vyjádřit, je výsledek nahrazen speciální hodnotou: kladným nebo záporným nekonečnem (Infinity):
var Nekonecno = 1e300 * 1e300 /* proměnná Nekonecno má hodnotu Infinity */
Při konverzi čísel z textové reprezentace může nastat situace, kdy vstupní řetěz neodpovídá tvaru čísla. V tom případě je výsledkem další speciální hodnota takzvané “nečíslo” – NaN (Not a Number):
var JeNaN = parseInt("Ahoj!") /* proměnná JeNaN má hodnotu NaN */
Hodnoty Infinity a NaN mohou dále vstupovat do výpočtů. Relačně je záporné nekonečno menší a kladné nekonečno větší než jakékoli jiné číslo. Dělení jakéhokoli čísla nekonečnem dává nulu. NaN není rovno žádnému číslu, ani samo sobě. Při aritmetickému výpočtu s NaN je výsledek opět NaN.
Typ string je typem reprezentujícím hodnoty jako krátký text v uvozovkách či apostrofech:
"Tohle je řetězec v uvozovkách"
'A tohle je také řetězec, jenže v apostrofech'
Tato dvojí možnost uvedení řetězcové hodnoty umožňuje naznačit řetězec v řetězci, čehož se využívá při deklaraci ovladačů objektů ve stránce HTML:
"Tohle je 'řetezec' v řetězci"
'A tohle je také "řetezec" v řetězci'
Prázdný řetězec lze vyjádřit dvojicí uvozovek (“”) či apostrofů (‘’).
Řetězec musí být uveden na jedné řádce, pokud je potřeba řetězec rozdělit na více řádek, lze použít operátor +:
"Tento řetězec" +
"se mi nevejde" +
"na jednu řádku."
Pokud je potřeba uvnitř řetězce vyznačit přechod na nový řádek, lze použít dvojici znaků \n:
"První řádek \n Druhý řádek"
Podobně lze vyjádřit jakýkoli znak v řetězci pomocí zpětného lomítka “\” následovaného znakem “x” a dvěma hexadecimálními číslicemi vyjadřujícími hodnotu kódu znaku: například \x41 (znak “A”) a další speciální znaky sloužící k formátování textu:
Typ boolean umožňuje zadat hodnotu pomocí dvou literálů true (pravda) a false (nepravda). S logickými hodnotami je možné v JavaScriptu provádět operace logického součtu ( || ), logického součinu (&&) a negace ( ! ).
Typ function tvoří všechny odkazy na funkce a metody. Odkaz na funkci může být, stejně jako ostatní hodnoty, ukládán do proměnné. Pomocí odkazu na funkci lze příslušnou funkci volat:
function Secti (a, b){
return a + b
}
var Odkaz_Secti = Secti
var Vysledek_Secti = Odkaz_secti (2, 3)
var Vysledek_Secti = Secti (2, 3)
/* Secti je odkaz na funkci, Secti(1,3) je volání funkce */
Typ object tvoří všechny identifikace objektů v JavaScriptu. Odkazy na objekty nemají žádné literály, vyskytují se vždy jen jako obsahy proměnných nebo návratové hodnoty funkcí. Objekty jsou vždy přístupné pouze pomocí odkazů. V JavaScriptu nelze vytvořit kopii objektu, pouze kopii odkazu na objekt, kdy na jeden objekt ukazuje více proměnných obsahujících odkaz:
var Dnes = new Date()
var Dalsi_Dnes = Dnes
var Jine_Dnes = new Date()
/* proměnné Dnes a Dalsi_Dnes obsahují odkaz na stejný objekt */
Pokud je potřeba vyjádřit, že proměnná neodkazuje na žádný objekt, přiřadíme jí tzv. prázdný odkaz označený literálem null.
Proměnné jsou konstrukce JavaScriptu, které v sobě mohou uchovávat hodnotu. Proměnné se deklarují deklaračním příkazem. Tím je buď klíčové slovo var, za kterým je uveden identifikátor proměnné a případně i rovnítko a počáteční hodnota proměnné:
var identifikátor [= výraz] {, identifikátor [= výraz]}
nebo přiřazovací příkaz bez klíčového slova var, s povinnou počáteční hodnotou:
identifikátor = výraz
Proměnné v JavaScriptu nemají pevně přiřazený typ a mohou obsahovat hodnotu libovolného typu. Proměnná nadeklarovaná pomocí klíčového slova var bez uvedení počáteční hodnoty má hodnotu undefined.
JavaScript rozeznává také proměnné globální a lokální. Globální proměnné jsou od svého vzniku viditelné ve všech částech programu a existují do jeho ukončení. Proměnné lokální jsou proměnné nadeklarované pomocí klíčového slova var v těle funkce a po ukončení funkce se automaticky ruší, jejich hodnoty jsou “zapomenuty”.
Pomocí výrazů vznikají v programu nové hodnoty. Výrazy se skládají z operandů, operátorů a závorek. Postup výpočtu hodnot z výrazů se řídí prioritou operátorů a umístěním závorek. Operandem výrazu je buď literál, proměnná nebo volání funkce, která vrací hodnotu příkazem return. Operandy musí mít definovánu hodnotu a typy operandů musí odpovídat operátorům.
Aritmetickými operátory jsou + (sčítání), - (odčítání), * (násobení), / (dělení) a % (modulo), jsou obvyklými matematickými operacemi. Pokud nelze výsledek zobrazit, provede se zaokrouhlení na nejbližší správnou hodnotu.
Dalšími aritmetickými operátory jsou ++ (inkrementace) a -- (dekrementace), jedná se o unární operátory, které mohou být použity pouze na proměnnou a rozdílem je jejich použití jako prefixových (před proměnnou) nebo postfixových (za proměnnou):
var i = 1
var j = ++i /* proměnné i, j mají hodnotu 2 */
ale:
var i = 1
var j = i++
/* proměnná i má hodnotu 2, proměnná j má hodnotu 1 */
Ve druhém případě dojde k inkrementaci až po přiřazení hodnoty do proměnné j, takže proměnná j obsahuje neinkrementovanou hodnotu proměnné i a hodnota i je až následně inkrementována.
Operátor - (unární mínus) invertuje hodnotu operandu, + (unární plus) ponechává hodnotu operandu beze změny.
Logické bitové operátory & (logický bitový součin – AND), | (logické bitové sčítaní – OR), ^ (logická bitová nonekvivalence – XOR) a ~ (logická bitová negace – NOT) provádějí logické operace nad jednotlivými odpovídajícími bity bitové reprezentace operandů:
var i = 0x0f
var j = i & 0xf0
/* proměnné i, j mají hodnotu 15 */
Posouvací bitové operátory << (posun doleva), >> (posun doprava) a >>> (posun doprava s doplňováním 0) provádějí posun bitové reprezentace operandu na levé straně o počet míst daných operandem na straně pravé. Bitové operátory << a >> provádějí každým posunem doleva násobení operandu dvěma a každým posunem doprava celočíselné dělení dvěma, přičemž zachovávají znaménko operandu. Operátor >>> se pro kladné hodnoty operandu chová stejně jako >>, pro záporné hodnoty však mění záporné znaménko na kladné.
var i = 9
var j = i << 2
/* proměnná j má hodnotu 18 */
Logické operátory && (logický součin – and), || (logický součet – or) a ! (logická negace – not) provádějí logické operace nad logickými operandy true a false.
Vyhodnocování logické operace probíhá takzvaným zkráceným způsobem: pokud má při vyhodnocování logického součinu levý operand hodnotu false, pak výsledkem logického součinu je false (bez ohledu na hodnotu pravého operandu). Je–li hodnota levého operandu true, pak výsledkem logického součinu je hodnota pravého operandu. V tom případě však výsledkem logické operace nemusí být logická hodnota, protože nad pravým operandem se neprovádí konverze na logickou hodnotu.
Při vyhodnocování operace logického součtu je výsledkem logického součtu true, pokud je true hodnotou levého operandu, jinak je výsledkem součtu hodnota pravého operandu (výsledkem opět nemusí být logická hodnota).
JavaScript používá ke změně hodnoty proměnné výraz s přiřazovacím operátorem. Binární přiřazovací operátor ( = ) nejprve vypočte hodnotu operandu na pravé straně a poté ji přiřadí do operandu na straně levé. Hodnotu levého operandu pak operátor ještě vrátí jako výsledek binární operace (tak lze přímo testovat výsledek přiřazení):
var i, j
if ((i = funkce())>0) ...
Přiřazovací variantu mají také ostatní binární operátory: +=, -=, *=, /=, %=, &=, |= a ^=:
var i = 5
i += 3
/* je vlastně i=i+3 */
i *= 2
/* je vlastně i=i*2 */
Na základě porovnání hodnot operandů vracejí relační operátory logickou hodnotu. Rozeznáváme následující relační operátory: == (rovno), != (nerovno), > (větší), < (menší), >= (větší nebo rovno), <= (menší nebo rovno). Při porovnání operandů rozdílných typů se nejdříve provede konverze na stejný typ. Při porovnávání odkazů mají smysl pouze == a !=, přičemž se neporovnávají vlastní objekty ale pouze odkazy na ně.
Existují dva další operátory === (přísná rovnost) a !== (přísná nerovnost), které vrací true nebo false, pokud jejich operandy jsou či nejsou stejných typů (neprovádí se typová konverze) a současně se rovnají nebo nerovnají jejich hodnoty.
Operátor + slouží pro spojování řetězců, tento operátor má svoji přiřazovací variantu +=, která vypočtenou hodnotu přiřadí do levého operandu:
var retez = 'Začátek'
retez += ' řetězce.'
/* proměnná retez má hodnotu 'Začátek řetězce' */
Jediným ternárním operátorem JavaScriptu je takzvaný podmíněný operátor ( ? : ), tento má tvar:
podmínka ? výraz : výraz
Nejdříve je vypočtena hodnota podmínky a podle potřeby konvertována na logickou hodnotu, pokud je true, pak výslednou hodnotou podmíněného operátoru je hodnota prvního výrazu za znakem ?, jinak je výslednou hodnotou hodnota výrazu druhého:
var i = 1, j = 2, k
i > j ? k = i : k = j
/* proměnná k má hodnotu 2 */
Operátor čárka “ , ” vyhodnotí svůj levý argument, poté vyhodnotí svůj pravý argument a jeho hodnotu vrátí. Operátor lze užít například při vícenásobném přiřazení:
var i = 0, j = 2, k = 1
Operátor delete lze využít ke zrušení objektu, vlastnosti objektu nebo prvku pole:
delete identifikátor_objektu
delete identifikátor_objektu.identifikátor_vlastnosti
delete identifikátor_pole[index_prvku]
například:
var Pole = new Array("jedna","dva")
delete Pole[0]
/* prvek s hodnotou "jedna" byl zrušen */
Operátor new slouží k vytvoření objektu a jeho operandem je volání konstruktoru objektu, což je speciální funkce zajišťující inicializaci nového objektu:
new volání_konstruktoru
Operátor new posléze vrátí odkaz na vzniklý objekt, pomocí něhož můžeme s objektem manipulovat.
var Ted_hned = new Date()
Operátor this slouží k přístupu k mateřskému objektu metody. Hodnotou operátoru this použitého v těle metody je odkaz na mateřský objekt metody, tedy na objekt, nad kterým byla metoda volána:
function pozor(jmeno, popisek){
alert('Kliknul jste na ovládací prvek ' + jmeno +
' s popiskem: ' + popisek)
}
<INPUT TYPE="button" NAME="Tlacitko" VALUE="Klikni mě!"
onClick = "pozor(this.name, this.value)">
<!-- je ekvivalentní volání "pozor(Tlacitko.name, Tlacitko.value)" -->
Operátor typeof slouží ke zjištění typu operandů, jako výsledek vrací řetězec, který identifikuje typ hodnoty na níž byl operátor použit. Výsledkem může být řetězec “undefined”, “number”, “boolean”, “string”, “function” či “object”.
var Co_je_to = typeof(78)
/* proměnná má hodnotu number */
Operátor void maže hodnotu svého operandu a vrací místo ní nedefinovanou hodnotu:
void Number.MAX_VALUE
/* výraz má hodnotu undefined */
Pokud mají operátory stejnou prioritu rozhoduje o pořadí vyhodnocování levá nebo pravá asociativita. Pravou asociativitu mají přiřazovací operátory a podmíněný operátor. Seznam operátorů podle priority vyhodnocování ve výrazech je uveden na konci práce (viz. Příloha 2).
Velice důležitou vlastností JavaScriptu je jeho automatická typová konverze. Při výpočtu výrazů provádí JavaScript konverzi typů hodnot operandů, tak, aby bylo možno výpočet provést, podle pravidel:
Konverze na řetězec je prováděna metodou toString, která vrací příslušný řetězec: