ECMAScript

Aktuální verze stránky ještě nebyla zkontrolována zkušenými přispěvateli a může se výrazně lišit od verze recenzované 15. června 2022; kontroly vyžadují 2 úpravy .
ECMAScript
Jazyková třída Specifikace pro programovací jazyky , funkční programovací jazyk a multiparadigmový programovací jazyk
Objevil se v června 1997
Autor Brendan Eich a Ecma International
Vývojář Brendan Eich
Přípona souboru .es[2]
Uvolnění ECMAScript 2022 [Spec 1]  (červen 2022 ) (2022-06)
Typový systém kachna
Dialekty JavaScript , JScript , ActionScript , JScript.NET , QtScript
Byl ovlivněn Self [1] , C , Schéma [1] , Perl [1] , Python , Java [1] , AWK [1]
ovlivnil Cíl-J
webová stránka ecma-international.org _ 

ECMAScript  je vložitelný, rozšiřitelný programovací jazyk bez I/O používaný jako základ pro vytváření dalších skriptovacích jazyků [3] .

ECMAScript je standardizován mezinárodní organizací ECMA ve specifikaci ECMA-262 . Rozšíření jazyka: JavaScript , JScript a ActionScript .

Historie

Jazyk vznikl z několika technologií, z nichž nejznámější jsou jazyky JavaScript a JScript . Vývoj první revize specifikace začal v listopadu 1996. Specifikace byla přijata v červnu 1997. Byl předložen ISO/IEC JTC 1 k přijetí Fast-Tracking a sloužil jako základ pro mezinárodní normu ISO/IEC 16262 . V červnu 1998 přijala valná hromada ECMA druhé vydání ECMA-262, odpovídající ISO / IEC 16262. Třetí vydání specifikace se od předchozího lišilo zavedením podpory regulárních výrazů, zlepšením podpory řetězců, zavedením nových řídicích struktur , mechanismus výjimek, formátování při numerickém vstupu a některé další změny[Specifikace 2] .

Sémantika a syntaxe

Datové typy

ECMAScript podporuje pět primitivních datových typů :

Číselný datový typ v ECMAScript odpovídá 64bitovému formátu čísel s plovoucí desetinnou čárkou definovanému standardem IEEE 754-2008 , kromě toho, že různé hodnoty Not-a-Number definované ve standardu [4] jsou reprezentovány v tomto jazyce. jedinou speciální hodnotou NaN [Specifikace 4] .

Nulové a nedefinované datové typy jsou Davidem Flanaganem neformálně označovány jako „triviální“ typy , protože každý z nich definuje pouze jednu hodnotu [5] .

Jazyk má také "složený" datový typ [5] :

Kromě uvedených šesti datových typů podporuje ECMAScript sedm dalších, které se používají výhradně k ukládání mezivýsledků hodnocených výrazů:

Popularita jazyka JavaScript a netriviálnost zpracování dat různých typů vedla k nasazení akademického výzkumu v oblasti parsování datových typů ECMAScript, jehož cílem je vytvořit plnohodnotný analyzátor kódu, který by mohl být použit v integrovaném vývoji prostředí [6] .

Návod

V ECMAScriptu je patnáct různých druhů instrukcí, které jsou uvedeny v tabulce níže:

Typy instrukcí definované specifikací jazyka [Specifikace 7]
název původní název Stručné informace Konečná ; [Specifikace 8]
Blok Angličtina  blok {[<instrukce>]} −
Deklarace proměnné Angličtina  VariableStatement var <seznam deklarací proměnných> +
Prázdná instrukce Angličtina  EmptyStatement ; +
Výraz Angličtina  ExpressionStatement [string to ∉ {{, function}] příkaz +
Stav Angličtina  IfStatement if (<инструкция>) <выражение>[ else <выражение>] −
Cyklus Angličtina  IterationStatement udělat <výraz> zatímco (<příkaz>)

while (<příkaz>) <výraz>
pro ([<příkaz před začátkem>]; [<příkaz>]; [<příkaz>]) <výraz>
pro (<deklarace proměnné>; [<příkaz>]; [<příkaz >]) <výraz>
pro (<výraz-hodnoty> v <příkazu>) <výraz>
pro (<deklarace proměnné> v <příkazu>) <výraz>

+/− [~1]
Pokračování Angličtina  Pokračovat v prohlášení pokračovat [<identifikátor>] +
Přerušit Angličtina  BreakStatement zlom [<identifikátor>] +
Vrátit se Angličtina  ReturnStatement vrátit [<instrukce>] +
Kombinace Angličtina  S prohlášením s (<příkaz>) <výraz> −
Označení Angličtina  LabelledStatement <identifikátor>: <výraz> −
Výběr Angličtina  SwitchStatement přepínač (<příkaz>) případ <příkaz>: [<výrazy>][ případ <příkaz>: [<výrazy>] ...] [výchozí: [<výrazy>]] −
Vyhození výjimky Angličtina  ThrowStatement hodit <návod> +
zkuste blokovat Angličtina  TryStatement zkuste <blok> chytit (<identifikátor>) <blok>
zkuste <blok> nakonec <blok>
zkuste <blok> chytit (<identifikátor>) <blok> nakonec <blok> 		−
(nový [Spec 9] ) Debugger Angličtina  Debugger debugger −
Automatické doplňování řetězců středníky

Přes povinný středník v případech uvedených ve čtvrtém sloupci specifikace deklaruje mechanismus automatického doplňování řetězců středníky , což vede k tomu, že pokud dojde k zalomení řádku, může být instrukce před zalomením řádku vybavena tímto znakem [ Specifikace 8] , která je předmětem kritiky [7] .

Pokyny, které mění význam při použití nového řádku uvnitř [Specifikace 8]
  • Unární postfix ++
  • Unární postfix --
  • Pokračování
  • Přerušit
  • Vrátit se
  • Vyhození výjimky

Příklad změny významu pokynu

return { stav : "dokončeno" };

Zde zvýrazněný řádek obsahuje instrukci platnou pro daný jazyk, a protože následuje nový řádek, spustí se mechanismus automatického doplňování řádků středníky. Místo toho, aby funkce obsahující výše uvedený kód vracela objekt s vlastností jako hodnotou status, vrátí se undefined.

Ačkoli doslovná forma objektu není blok kódu, jednotné závorky mohou vést k chybám. Vývoj nebo přijetí vhodného standardu kódování může snížit pravděpodobnost jejich výskytu . Roli hraje volba stylu odsazení . Zejména styly Allman a Whitesmith , stejně jako styl Horstman a styl GNU pro kód JavaScript, jsou většinou směrnic [8] zavrženy na rozdíl od stylů K&R , 1TBS , BSD KNF .

Selhání automatického doplňování

Pokud výraz zapsaný na dalším řádku může být syntakticky pokračováním výrazu na předchozím řádku, nefunguje mechanismus automatického doplňování řádků středníky [9] .

func () [ 'h1' , 'h2' ]. forEach ( function ( t ) { handleTag ( t ) })

V tomto příkladu jsou hranaté závorky na druhém řádku interpretovány jako odkaz na prvek pole vrácený funkcí func(). Čárka v závorce je považována za odpovídající operátor vracející 'h2'. Kód je tedy převeden na následující:

func ()[ 'h2' ]. forEach ( function ( t ) { handleTag ( t ); });

V kódovacích standardech je obvyklé vyžadovat středníky, i když syntaxe jazyka umožňuje jejich vynechání [Coding Standards 1] [Coding Standards 2] [Coding Standards 3] [Coding Standards 4] [Coding Standards 5] .

Bloky a rozsah

Dalším rysem ECMAScriptu ve vztahu k jiným jazykům podobným C je to, že v tomto jazyce bloky netvoří rozsah . Proměnné deklarované v bloku platí pro celou funkci obsahující blok [10] [11] .

V této části kódu je proměnná znovu deklarována ve zvýrazněných řádcích:

function foo ( ) { varsum = 0 ; for ( var i = 0 ; i < 42 ; i += 2 ) { var tmp = i + 2 ; součet += i * tmp ; } for ( var i = 1 ; i < 42 ; i += 2 ) { součet += i * i ; } alert ( tmp ); návratový součet ; _ } foo ();

Kromě toho proměnná tmp deklarovaná uvnitř první smyčky (řádek 4) je legální pro přístup z vnější smyčky (řádek 10) podle syntaxe jazyka.

Vzhledem k povaze rozsahu a bloků se doporučuje deklarovat proměnné na začátku funkcí , aby byla zachována kvalita zdrojového kódu [10] [Standardy kódování 1] [Standardy kódování 4] .

Deklarace proměnných

Proměnné jsou definovány pomocí klíčových slov var, let, const. Při deklaraci proměnné je umístěna v rozsahu odpovídajícím v případě varfunkce a v případě let, constbloku kódu. Pokud je proměnná deklarována mimo funkce, je umístěna do globálního rozsahu. K vytvoření proměnné dochází, když je přijato ovládání funkce s její deklarací. Nebo program, pokud je proměnná globální. Když je proměnná vytvořena v ECMAScriptu, získá hodnotu undefined. Pokud je proměnná deklarována s inicializací , k inicializaci nedojde v okamžiku vytvoření proměnné, ale při provedení řádku s instrukcí var[Specifikace 10] .

Při zrušení komentáře u vybraného řádku se na obrazovce nezobrazí číslo , ale nedefinováno :

var a = 42 ; function foo () { alert ( typeof a ); // var a = 10; } foo ();

Když je proměnná vytvořena, získává interní vlastnost {DontDelete} a nelze ji odstranit pomocí operátoru delete[Specification 10] . Výjimkou jsou proměnné deklarované v kontextu eval[12] [Specifikace 11] .

Mnoho zdrojů [13] [14] [15] [16] [17] [18] deklaruje možnost implicitně deklarovat proměnné v ECMAScriptu při přiřazení k platnému identifikátoru, který není formálním funkčním argumentem, bez předchozí deklarace pomocí var. V terminologii specifikace jazyka se však v tomto případě vytváří vlastnost globálního objektu, nikoli proměnná [12] [Specifikace 10] .

Oprava potřeby deklarovat proměnné před jejich použitím v kódovacím standardu [Coding Standards 1] [Coding Standards 4] (nebo opravení potřeby používat jmenné prostory pro všechny globální objekty [Coding Standards 2] ) zabraňuje jemným chybám a předchází nebezpečí interakce shodně pojmenovaných proměnných v různých částech kódu [19] .

Klíčová slova a vyhrazená slova

Následující slova jsou klíčová slova v daném jazyce a nelze je použít jako identifikátory [Spec 12] :

break do instanceof typeof případ jiný nový var chytit konečně vrátit neplatné pokračujte pro přepnutí, zatímco funkce debuggeru default if throw pokus smazat

Ve srovnání s třetím vydáním specifikace [Specifikace 13] bylo v pátém vydání přidáno klíčové slovo debuggers odpovídající instrukcí.

Následující slova se používají jako klíčová slova v navrhovaných rozšířeních a jsou proto vyhrazena pro možnost přizpůsobení těchto rozšíření [Specifikace 14] :

class enum rozšiřuje super const export import

Při použití přísného režimu jsou následující slova považována za vyhrazená pro budoucí použití [Spec 14] :

nářadí nechat soukromé veřejné výnosy balíček rozhraní chráněný static

Oproti třetímu vydání jazykové specifikace se tak výrazně snížil počet slov vyhrazených pro budoucí použití. Dříve jich bylo 31 [Specifikace 15] a kritizována byla přítomnost velkého množství klíčových slov a vyhrazených slov, z nichž většina se v jazyce nepoužívá [20] .

Operátoři

ECMAScript má jak operátory , které používají klíčová slova jako jména , tak operátory , které používají jako jména interpunkční znaménka .

Klasifikace operátorů

V sestupném pořadí podle priority lze operátory ECMAScript rozdělit do následujících skupin:

  • .(přístup k vlastnosti), [](přístup k vlastnosti), ()(volání funkce), new(vytvoření nového objektu),
  • ++(přírůstek), --(dekrementace), -(unární mínus), +(unární plus), ^(bitový doplněk), !(booleovský doplněk), delete(smazat vlastnost), typeof(definovat primitivní datový typ), void(vrátit null),
  • *(násobit), /(rozdělit), %(zbytek dělení),
  • +(sčítání), -(odčítání), +(zřetězení řetězců),
  • <<(levý posun), >>(pravý posun s rozšířením bitového znaménka), >>>(pravý posun s nulovým odsazením),
  • <(menší než), <=(menší nebo rovno), >(větší než), >=(větší než nebo rovno), instanceof(test typu objektu), in(test vlastností),
  • ==(test rovnosti), !=(test nerovnosti), ===(test identity), !==(test neidentity),
  • &(bitová konjunkce ),
  • ^(bitové sčítání modulo 2 ),
  • |(bitová disjunkce ),
  • &&(spojení),
  • ||(disjunkce),
  • ?:( ternární podmíněná operace ),
  • =(přiřazení), *=, /=, +=, -=, <<=, >>=, >>>=, &=, ^=( |=přiřazení s operací),
  • ,(vícenásobný výpočet) [21] .

Operátory ++, --, -, +, ~, !, delete, typeof, void, ?:, =, *=, /=, +=, -=, <<=, >=, >>>=, &=jsou asociativní vpravo (to znamená ^=, |=že jsou a op b op cekvivalentní a op (b op c)). Zbývající operátory ECMAScript jsou ponechány asociativní [22] .

Podle arity jsou operátory ECMAScript rozděleny do následujících skupin:

  • unární ( delete, void, typeof, ++, --, -(unární mínus), +(unární plus), ^, !, new) [Specifikace 16] ,
  • binární ( ., [], (), *, /, %, +(sčítání), ( -odčítání) , ( zřetězení +řetězců ) , <<, >>, >>>, <, <=, >, >=, instanceof, in, ==, !=, ===, !==, &, ^, |, &&, ||, =, *=, /=, +=, -=, ),<<=>=>>>=&=^=|=,
  • ternární ( ?:) [23] ,
  • operátory, které nemají pevný počet operandů ( ()) [24] .

Podle pozice znaménka operace vzhledem k operandům se operátory ECMAScript dělí do následujících skupin:

  • předpona (například , new( ++přírůstek předpony),
  • infix (například +, -),
  • postfix (například ++(přírůstek postfixu), --(úbytek postfixu).

Operátoři jsou také klasifikováni podle typu operandů [25] a podle povahy prováděné akce.

Vlastnosti příkazů ECMAScript

V ECMAScriptu neexistuje žádný operátor, který by vám umožnil zkontrolovat, zda vlastnost patří přímo k objektu nebo zda je zděděna. Tato kontrola se provádí pomocí hasOwnProperty(). Vzhledem k tomu, že tato metoda není operátorem, lze ji přepsat jakoukoliv jinou vlastností [26] .

Operátor +je jediný aritmetický operátor v jazyce, který je přetížen řetězcovými argumenty. Pokud je alespoň jeden z operandů řetězec, +chová se jako zřetězovač , jinak provádí sčítání [27] [Specifikace 17] .

Na rozdíl od jazyků, kde void je datový typ, v ECMAScript je to operátor, který vrací hodnotu undefined[28] .

Operátor ==kontroluje rovnost podle algoritmu skládajícího se z 10 kroků, což v některých případech znamená konverzi typu [Specifikace 18] , která v konečném důsledku může vést k nezřejmým výsledkům [29] .

Příklad výsledků práce ==(ve všech uvedených případech bude hodnota operátoru ===se stejnými argumenty false):

upozornění ( "NaN" == NaN ); // falešný poplach ( NaN == NaN ); // falešné upozornění ( true == 1 ); // true alert ( true == 42 ); // falešné upozornění ( null == 0 ); // falešné upozornění ( 0 == "" ); // true alert ( "" == 0 ); // true alert ( "false" == false ); // falešné upozornění ( false == 0 ); // true alert ( undefined == false ); // falešné upozornění ( null == false ); // falešné upozornění ( undefined == null ); // true alert ( " \t\r\n " == 0 ); // skutečný

Funkce

Funkce v ECMAScriptu jsou objekty [30] [31] . Konstruktor, pomocí kterého jsou vytvořeny, je Function(). Funkce, stejně jako jakékoli jiné objekty, mohou být uloženy v proměnných, objektech a polích, mohou být předány jako argumenty jiným funkcím a mohou být vráceny funkcemi. Funkce, stejně jako jakékoli jiné objekty, mohou mít vlastnosti. Podstatným specifikem funkcí je, že je lze volat [30] .

Definování funkcí

V ECMAScriptu existují dva typy funkcí:

  • vnitřní funkce (například parseInt),
  • funkce definované v textu programu.

Interní funkce jsou vestavěné objekty (viz níže ), nemusí být nutně implementovány v ECMAScriptu [Specifikace 19] .

V textu programu lze pojmenovanou funkci v ECMAScript definovat jedním z následujících způsobů:

// deklarace funkce function sum ( arg1 , arg2 ) { return arg1 + arg2 ; } // definování funkce pomocí příkazu var sum2 = function ( arg1 , arg2 ) { return arg1 + arg2 ; }; // definování funkce pomocí zápisu objektu var sum3 = new Function ( "arg1" , "arg2" , "return arg1 + arg2;" );

Poslední metoda je nejméně preferovaná, protože de facto jde o definování funkce pomocí výrazu, ale zároveň generuje dvojí interpretaci kódu (dodatečná interpretace nastává, když je kód předán konstruktoru), což může negativně ovlivnit výkon [31] .

První dvě metody poskytují podobný, ale ne identický účinek. Aby toho nebylo málo, příkaz použitý při definování funkce může vypadat velmi podobně jako deklarace funkce: za prvé za klíčovým slovem functionmůže následovat identifikátor [Specifikace 20] , za druhé středník může být vynechán kvůli mechanismu dokončování řetězce středníky [Specifikace 8] . Příklad:

// deklarace funkce function sum ( arg1 , arg2 ) { return arg1 + arg2 ; } // definování funkce pomocí výrazu var sum2 = function sum ( arg1 , arg2 ) { return arg1 + arg2 ; } funkční panel () { }; // použijte deklaraci funkce ( funkční lišta (){}) // použijte příslušnou instrukci

Nejvýznamnější rozdíl mezi definicí funkce pomocí deklarace a definicí funkce pomocí výrazu je v tom, že v prvním případě k vytvoření proměnné a jejímu přiřazení jako hodnoty funkce dochází před spuštěním kódu při vstupu do kontextu provádění. . Ve druhém případě proměnná obdrží hodnotu inicializátoru při provedení příkazu přiřazení. Když je proměnná vytvořena po vstupu do kontextu provádění, je inicializována hodnotou undefined[Spec 21] [32] (podrobnosti viz Deklarace proměnných ).

Příklad ilustrující rozdíl v pořadí provádění kódu:

upozornění ( součet ( 3 , 4 )); // 7: proměnná součtu již byla vytvořena v době provedení tohoto řádku a funkce sum ( arg1 , arg2 ) jí byla přiřazena function sum ( arg1 , arg2 ) { return arg1 + arg2 ; } výstraha ( součet2 ( 3 , 4 )); // chyba: proměnná suma2 již byla vytvořena v době provedení tohoto řádku, ale byla k ní přiřazena hodnota nedefinovaná var sum2 = function ( arg1 , arg2 ) { return arg1 + arg2 ; };

Deklarace funkcí by neměly být používány uvnitř podmíněných konstrukcí [33] , i když prohlížeče Gecko to zvládnou intuitivně prostřednictvím implementovaného mechanismu funkcí jako instrukcí [34] .

Přiřazení funkcí

Protože funkce v ECMAScriptu jsou objekty, to znamená, že jsou typu referenčních dat , identifikátory funkcí jsou proměnné, které ukládají odkaz na funkci. To lze ilustrovat následujícím kódem:

var sum = funkce ( arg1 , arg2 ) { return arg1 + arg2 ; }; upozornění ( součet ( 3 , 4 )); // 7 var suma2 = suma ; výstraha ( součet2 ( 4 , 2 )); // 6 suma = null ; výstraha ( součet2 ( 42 , 42 )); // 84

Ve zvýrazněném řádku byste si měli dát pozor na absenci operátoru volání funkce ( ()) na pravé straně zadání. Pokud by v tomto řádku bylo místo sum uvedeno sum(), proměnné suma2 by nebyla přiřazena funkce, ale výsledek jejího volání. Další věc, která stojí za zmínku, je, že po přiřazení suma2 neukazuje na kopii funkce, ale právě na funkci, která ukazuje součet na .

Přetížení funkcí

V ECMAScript není přetížení funkcí vlastností jazyka, ale jeho účinek je zajištěn pomocí jiných mechanismů.

Příklad ukazující absenci přetížení funkcí:

funkce suma ( arg1 , arg2 ) { return arg1 + arg2 ; } funkce součet ( arg1 , arg2 , arg3 ) { return arg1 + arg2 + arg3 ; } upozornění ( součet ( 3 , 4 )); // výstraha NaN ( suma ( 3 , 4 , 5 )); // 12

Pokud je deklarováno více funkcí se stejným názvem, pozdější deklarace přepíší dřívější deklarace [31] .

Efekt přetížení funkcí je však dosažitelný.

1. Zkontrolujte, zda není definováno. Chcete-li zkontrolovat, zda byl funkci předán skutečný argument, můžete zkontrolovat formální argument identity na hodnotu undefined. Například:

funkce součet ( arg1 , arg2 , arg3 ) { if ( arg3 !== nedefinováno ) { return arg1 + arg2 + arg3 ; } else { return arg1 + arg2 ; } } upozornění ( součet ( 3 , 4 )); // 7 alert ( sum ( 3 , 4 , 5 )); // 12

2. Kontrola typu. Kromě toho lze použít typeof, instanceof, constructorke zjištění typu skutečných argumentů a přizpůsobení chování funkce v závislosti na nich.

function sum ( arg1 , arg2 , arg3 ) { switch ( typeof arg3 ) { case "undefined" : return arg1 + arg2 ; případ "číslo" : return arg1 + arg2 + arg3 ; výchozí : return arg1 + arg2 + " (" + arg3 + ")" ; } } upozornění ( součet ( 3 , 4 )); // 7 alert ( sum ( 3 , 4 , 5 )); // 12 alert ( sum ( 3 , 4 , "!" )); // "7 (!)"

3. Přístup k datům o argumentech. Ve funkcích ECMAScript můžete přistupovat k datům argumentů pomocí objektu arguments[Specifikace 22] . Zejména vám umožňuje používat indexování pro přístup ke konkrétním předaným argumentům [31] [35] a vlastnosti length, která ukládá počet skutečně předaných argumentů, což může být užitečné při aplikaci obecného programovacího paradigmatu .

funkce suma () { var res = 0 ; for ( var i = 0 ; i < argumenty . délka ; i ++ ) { res += argumenty [ i ]; } return res ; } upozornění ( součet ( 3 , 4 )); // 7 alert ( sum ( 3 , 4 , 5 )); // 12 alert ( sum ( 3 , 4 , 5 , 7 , 9 )); // 28 Rekurze

Funkce ECMAScript lze volat rekurzivně. Když definujete funkci pomocí příkazu bez uvedení identifikátoru za klíčovým slovem functionuvnitř funkce, můžete se na ni odkazovat pomocí vlastnosti callee objektu arguments[Specifikace 22] .

Příklad rekurzivního faktoriálového výpočtu:

var faktoriál = funkce ( krok , res ) { res = res || 1 ; if ( krok < 2 ) { return res ; } vrátit argumenty . volaný ( krok - 1 , krok * res ); }; výstraha ( faktoriál ( 5 )); // 120

V současné době ECMAScript neimplementuje tail recursion , který se používá k optimalizaci rekurzivních volání [36] .

Zpětná volání

V ECMAScriptu je funkce objektem první třídy a lze ji předat jako argument jiné funkci. Pokud je současně volána ve funkci, které je předána, nazývá se funkce zpětného volání (nebo funkce zpětného volání ). Pokud předaná funkce nemá jméno, jedná se o anonymní funkci zpětného volání ( anonymní funkce zpětného volání ) [37] . Hlavní důvody pro použití funkcí zpětného volání jsou:

  • vyhnout se pojmenování funkcí při práci s nimi (pomáhá snížit počet globálních proměnných) [37] ,
  • delegování volání funkce na jinou funkci (pomáhá zvýšit expresivitu kódu) [37] ,
  • zvýšení výkonu [37] ,
  • zjednodušení zpracování krátkých událostí [38] .

Příklad funkce, která vrací součet výsledků provedení předané funkce na argumentech:

function sumOfResults ( zpětné volání ) { var vysledek = 0 ; for ( var i = 1 ; i < argumenty . délka ; i ++ ) { výsledek += zpětné volání ( argumenty [ i ]); } vrátit výsledek ; } var square = funkce ( x ) { return x * x ; }; upozornění ( sumOfResults ( čtverec , 3 , 4 )); // 25 Uzávěry

Funkce v ECMAScript jsou ze své podstaty lexikálně vymezeny. To znamená, že rozsah je definován v okamžiku, kdy je funkce definována (na rozdíl od dynamického rozsahu, kde je rozsah definován v okamžiku volání funkce) [39] .

Když je funkce deklarována, sekvence vnořených rozsahů funkcí je uložena jako součást stavu funkce. To znamená, že během provádění programu si funkce, které mají přístup k lokálním proměnným uzavíracích funkcí, zachovávají takový přístup po celou dobu provádění programu [39] .

Uzavírací mechanismus lze použít k omezení viditelnosti proměnných v samostatné části programu, takže při sdílení s jiným kódem nedochází ke konfliktům názvů. Za tímto účelem je kód umístěn v anonymní funkci, která je vybavena operátorem volání funkce.

( funkce () { // Část programu, jejíž přístup k proměnným musí být izolován zvenčí. })();

V tomto případě se funkce definované v části programu vnoří vzhledem k přidané anonymní funkci a je možné přistupovat k lokálním proměnným anonymní funkce (které byly před jejím zavedením globální). Nelze k nim však přistupovat zvenčí anonymní funkce: výsledek provedení funkce je ignorován.

Uzávěry se používají nejen k zákazu přístupu k řadě proměnných, ale také k úpravě takového přístupu. Toho je dosaženo pomocí funkcí, které vracejí jiné funkce. Příklad funkce generátoru sériových čísel:

var uniqueId = function () { var id = 0 ; return function () { return id ++ ; }; }(); var aValue = uniqueId (); var otherValue = uniqueId ();

Při použití uzávěru má k proměnné id přístup pouze funkce, která byla přiřazena proměnné uniqueId .

Příklad kari :

var multNumber = function ( arg ) { return function ( mul ) { return arg * mul ; }; }; var multFive = multNumber ( 5 ); upozornění ( multiFive ( 7 )); //35

Příklad vytvoření objektu, který vám umožní přistupovat k vlastnosti výhradně pomocí jejích metod [40] :

var myObject = function () { var value = 0 ; return { přírůstek : funkce ( vč ) { hodnota += typ vč === 'číslo' ? včetně : 1 ; }, getValue : function ( ) { return value ; } } }(); alert ( myObject . value === undefined ); // true alert ( myObject . getValue ()); // 0 myObject . přírůstek ( 9 ) myObject . increment ( 7 ) alert ( myObject . getValue ()); // 16

Pomocí tohoto triku můžete použít uzávěr k emulaci konstant [41] .

var getConstant = function () { var konstanty = { UPPER_BOUND : 100 , LOWER_BOUND : - 100 }; return function ( konstantaName ) { return konstanty [ konstantaNazev ]; }; }(); upozornění ( getConstant ( "LOWER_BOUND" )); // -100

Regulární výrazy

Syntaxe a funkčnost regulárních výrazů v ECMAScriptu byla ovlivněna Perlem 5 [Spec 23] a umožňuje dva druhy syntaxe: literál a objekt .

var literalWay = /pattern/flags; var objectWay = new RegExp ( vzor , příznaky );

V prvním případě jsou šablona ( pattern) a příznaky ( flags) specifikovány explicitně, bez dalších nadbytečných syntaktických znaků: lomítka slouží jako jejich oddělovače . Ve druhém případě musí být šablonou a příznaky proměnné obsahující řetězcové hodnoty nebo přímo řetězcové hodnoty. Doslovný zápis je preferován v tom, že nevyžaduje dvojité [~ 2] escapování metaznaků regulárního výrazu, na rozdíl od objektové formy [42] .

Následující symboly mohou být použity jako příznaky v ECMAScript:

Příznaky regulárního výrazu [42] [Spec 23]
Vlajka Popis
g g globální režim: vzor se použije na všechny shody v řetězci, regulární výraz se nezastaví po nalezení první shody vzoru
i a malá a velká písmena - ignorování : při porovnávání jsou malá a velká písmena ve vzoru a řetězcích ignorována
m víceřádkový režim: s řádkem obsahujícím znaky nového řádku se zachází jako s několika řádky oddělenými znaky odřádkování; regex funguje na všech řádcích

Každý regulární výraz je objekt s následujícími vlastnostmi:

Vlastnosti objektu regulárního výrazu ECMAScript [42] [Specifikace 23]
Vlastnictví Typ Popis
global logický ukazuje, zda je nastaven příznakg
ignoreCase logický ukazuje, zda je nastaven příznaki
multiline logický ukazuje, zda je nastaven příznakm
lastIndex číselné odpovídá číslu pozice v řetězci, kde byla nalezena shoda se vzorem v důsledku předchozí aplikace regulárního výrazu, nebo 0, pokud regulární výraz nebyl dříve aplikován
source tětiva řetězec odpovídající vzoru regulárního výrazu

Kromě toho jsou pro regulární výrazy definovány následující metody:

Objektové metody regulárního výrazu v ECMAScriptu [42] [Specifikace 23]
Metoda návratový typ Popis
exec(handledString) objekt (pole) popřnull tvoří pole podřetězců , které odpovídají zadanému vzoru , přičemž bere v úvahu nastavené příznaky . pokud vzorunull neodpovídá žádný podřetězec
test(handledString) logický truepokud existuje řetězec odpovídající vzoru a falsejinak

Objekty

Implementace v jazyce

Objekty ECMAScript jsou neuspořádané kolekce vlastností , z nichž každá má jeden nebo více atributů , které určují, jak lze vlastnost použít – například pokud je hodnota atributu ReadOnly nastavena na hodnotu true , pak jakýkoli pokus o změnu kódu pomocí kódu ECMAScript hodnota tohoto majetku selže. Vlastnosti jsou kontejnery , které zapouzdřují jiné objekty, hodnoty primitivních typů a metody [Specifikace 24] .

Atributy vlastnosti objektu ECMAScript [Spec 25]
název Popis
pouze ke čtení Vlastnost je vlastnost pouze pro čtení. Pokus o změnu hodnoty této vlastnosti provedený v programu zůstane marný. V některých případech se hodnota vlastnosti se sadou atributů ReadOnly mění v důsledku akcí prostředí jazykového rozšíření, takže ReadOnly by nemělo být chápáno jako neměnné.
DontEnum Vlastnost není vyčíslena smyčkoufor-in
DontDelete Pokusy o odstranění této vlastnosti budou ignorovány.
Vnitřní Nemovitost je vnitřní. Nemá žádné jméno a nelze k němu přistupovat pomocí přístupových prvků . Přístup k těmto vlastnostem je určen implementací jazyka.

Objekty ECMAScript se dělí na základní (nativní) a rozšiřující (hostitelské) objekty. Bází rozumíme jakékoli objekty, které jsou nezávislé na prostředí souvisejícím s rozšířením jazyka. Některé ze základních objektů jsou vestavěny : existují od samého začátku provádění programu. Jiné mohou být vytvořeny, když je program spuštěn. Objekty rozšíření poskytuje rozšíření ECMAScript a pro ECMAScript to znamená, že jsou součástí Document Object Model nebo Browser Object Model [Specifikace 3] .

Syntaxe

Objektové a doslovné formy lze použít k určení objektů. Objektová forma specifikace objektu má syntaxi podobnou Javě, ale na rozdíl od ní se závorky v ECMAScriptu vyžadují pouze při předávání argumentů konstruktoru [43] . Následující položky jsou syntakticky ekvivalentní:

varobj1 = nový objekt ( ); var obj2 = nový objekt ; var obj3 = {};

Druhá možnost se však nedoporučuje [43] . Douglas Crockford doporučuje vyhnout se i první možnosti a dát přednost doslovné formě, kterou považuje za velkou výhodu jazyka [44] .

Specifikace jazyka pracuje s konceptem vlastnosti objektu , volá metodu funkci použitou jako vlastnost objektu [Specifikace 3] .

Každý objekt v jazyce má následující vlastnosti:

Vlastnosti objektů ECMAScript [43]
název Stručný popis
constructor Funkce použitá k vytvoření objektu (ve výše uvedených příkladech je to Object())
hasOwnProperty(propertyName) Označuje, zda daná vlastnost existuje v objektu (nikoli v jeho prototypu )
isPrototypeOf(object) Určuje, zda je objekt v řetězci prototypu objektu argumentu
propertyIsEnumerable(propertyName) Označuje, zda je vlastnost s daným názvem ve smyčce vyčíslitelnáfor-in
toString() Vrátí řetězcovou reprezentaci objektu
hodnota() Vrátí hodnotu this . Pokud je objekt výsledkem volání konstruktoru objektu rozšíření , je hodnota valueOf()závislá na implementaci [Spec 26] . Často je návratovou hodnotou hodnota primitivního typu odpovídající objektu. Výsledek této metody je zpravidla stejný jako výsledek toString(). Objekty vytvořené pomocí konstruktoru Date() jsou ukázkovým příkladem, kde se výsledky toString()a valueOf()neshodují [43] .

Vlastnosti objektu jsou přístupné pomocí notace s tečkami a závorkami :

var obj = nový objekt (); alert ( obj . konstruktor === obj [ "konstruktor" ]); // true - pro přístup k vlastnosti použijte notaci s tečkami a závorkami var foo = obj [ "toString" ]; // pomocí zápisu hranatých závorek k uložení funkce do proměnné var result = obj [ "toString" ](); // uložení výsledku volání funkce do proměnné alert ( foo ()); // zobrazení výsledku volání uložené funkce na obrazovce alert ( result ); varboo = objekt _ _ toString ; // podobné s tečkovým zápisem var res = obj . toString (); výstraha ( boo ()); upozornění ( res );

Nové vlastnosti lze nastavovat dynamicky.

varcountry = nový objekt ( ); země [ "jméno" ] = "Rusko" ; // použijte závorku země . založeníRok = 862 ; // použijte tečkovou notaci var country2 = { "jméno" : "Rusko" , "rok nadace" : 862 }; // použijte doslovný tvar

Přístupy k vytváření objektů

Vytváření objektů způsobem popsaným v předchozí části může být nepraktické kvůli nutnosti duplikovat kód [45] . Pokud program manipuluje s velkým množstvím objektů stejného typu, má vývojář možnost zvolit jednu z technik používaných v jazyce [45] :

továrna na předměty funkce, která vytvoří objekt a vrátí jej jako jeho hodnotu, konstruktér funkce, která používá klíčové slovo thisk vytvoření vlastností objektu, který vytváří pomocí operátoru new, prototypový přístup použití vlastnosti prototypefunkce k zobrazení obecných vlastností objektů, konstruktor-prototyp smíšeného přístupu použití konstruktoru k nastavení vlastností objektů, které nejsou metodami, a prototypový přístup k metodám nastavení, metoda dynamického prototypu uzavření kódu souvisejícího s funkcí vytváření objektů založených na smíšeném přístupu konstruktor-prototyp do jedné funkce, zajišťující, že vlastnosti prototypu jsou přiřazeny jednou, metoda parazitního konstruktoru použití news ​​funkcí objektové továrny.

V jazyce nejsou žádné třídy , ale lze je emulovat pomocí konstruktorů. Příklad emulace třídy v ECMAScript:

function MyClass () { this . mojeHodnota1 = 1 ; toto . mojeHodnota2 = 2 ; } Moje třída . prototyp . myMethod = function () { return this . myValue1 * toto . mojeHodnota2 ; } var mc = new MyClass (); mc _ mojeHodnota1 = mc . mojeHodnota2 * 2 ; var i = mc . mojeMetoda ();

Vlastnosti dědičnosti v ECMAScriptu

U každé ze složek objektu lze uvažovat o dědičnosti. Při dědění rozhraní rodiče, aniž by dítě využívalo funkcionalitu předka, se mluví o dědění rozhraní. Při dědění stavu dědí podřízený objekt datovou strukturu předchůdce. Při dědění funkčnosti mluvíme o dědičnosti spolu s rozhraním a kódem metod. Zpravidla to s sebou nese nutnost organizovat dědičnost státu, díky čemuž je rozumné kombinovat dědění státu a dědění funkčnosti do dědičnosti implementační [46] .

S ohledem na ECMAScript se neuplatňuje pouze dědičnost rozhraní, protože funkce v jazyce nemají podpisy [45] .

Možnosti, které jazyk poskytuje pro uspořádání dědictví, lze posoudit například podle seznamu dvanácti různých způsobů uspořádání dědictví , který uvádí Stoyan Stefanov [47] .

ECMAScript 6

Přijetí ES6 odstranilo mnoho tříd problémů s JavaScriptem [48] [49] [50] [51] .

Poznámky

  1. ↑ 1 2 3 4 5 _ Axel Rauschmayer. Povaha JavaScriptu // Mluvení JavaScriptu . - První vydání. - O'Reilly Media, 2014. - S. 41. - ISBN 978-1-449-36503-5 .
  2. ↑ Typ média pro skriptování – 2006.
  3. ↑ Zakas N. ECMAScript // Profesionální JavaScript pro webové vývojáře. — 2. vyd. - USA, Kanada: Wiley Publishing, Inc, 2009. - S. 3-7. - ISBN 978-0-470-22780-0 .
  4. ↑ Aiken A., Applegate M., Bailey D. a další. 6.2. Operations with NaNs // IEEE Standard for Floating-Point Arithmetic / Chair Zuras D., Editor Cowlishaw M. - USA, 2008. - S. 34. - ISBN 978-0-7381-5753-5 .
  5. ↑ 1 2 David Flanagan. 3. Datové typy a hodnoty // JavaScript. Podrobný návod = JavaScript. The Definite Guide / Přeložil A. Kiselev. - 5. vyd. - Petrohrad. : "Symbol-Plus" , 2008. - S.  39 -66. — ISBN 5-93286-103-7 .
  6. ↑ Jensen S., Møller A., ​​​​Thiemann P. Typová analýza pro JavaScript  //  Poznámky z přednášek z informatiky : Sborník konf. / The 16th International Static Analysis Symposium (SAS 2009), Los Angeles, USA, 9. - 11. srpna 2009. - Springer Berlin / Heidelberg, 2009. - Vol. 5673 . - str. 238 - 255 . - ISBN 978-3-642-03236-3 .  (nedostupný odkaz)
  7. ↑ Crockford D.A.3. Vložení středníku // JavaScript: Dobré části. - 2008. - S. 102. - ISBN 978-0-596-51774-8 .
  8. ↑ Dr. Axel Rauschmayer. Syntaxe JavaScriptu // Mluvení JavaScriptu . - První vydání. - O'Reilly Media, 2014. - S. 378. - ISBN 978-1-449-36503-5 .
  9. ↑ Dr. Axel Rauschmayer. Syntaxe JavaScriptu // Mluvení JavaScriptu . - První vydání. - O'Reilly Media, 2014. - S. 41. - ISBN 978-1-449-36503-5 .
  10. ↑ 1 2 Crockford D. A.2. Rozsah // JavaScript: Dobré části. - 2008. - S. 36. - ISBN 978-0-596-51774-8 .
  11. ↑ David Flanagan. 4.3.1. Žádný rozsah bloku // JavaScript. Podrobný návod = JavaScript. The Definite Guide / Přeložil A. Kiselev. - 5. vyd. - Petrohrad. : "Symbol-Plus" , 2008. - S.  70 -71. — ISBN 5-93286-103-7 .
  12. ↑ 1 2 Soshnikov, Dmitry Subtleties ECMA-262-3. Část 2. Objekt proměnných. (27. června 2009). Získáno 6. listopadu 2009. Archivováno z originálu 18. února 2012.
  13. ↑ David Flanagan. 4.2. Deklarování proměnných // JavaScript. Podrobný návod = JavaScript. The Definite Guide / Přeložil A. Kiselev. - 5. vyd. - Petrohrad. : "Symbol-Plus" , 2008. - S.  68 . — ISBN 5-93286-103-7 .
  14. ↑ Petr-Paul Koch. Implicitní deklarace proměnné // ppk v JavaScriptu / Editor: Wendy Sharp. — 1. vyd. - New Riders Press, 2006. - 528 s. - ISBN 978-0-321-42330-6 .
  15. ↑ Zakas N. Variables // Profesionální JavaScript pro webové vývojáře. — 2. vyd. - USA, Kanada: Wiley Publishing, Inc, 2009. - S. 26, 27. - ISBN 978-0-470-22780-0 .
  16. ↑ Souders S. Používejte místní proměnné // Ještě rychlejší webové stránky: Výkonnost Best Practices for Web Developers. — 1. vyd. - USA: O'Reilly Media, 2009. - S. 81-83. — ISBN 0596522304 .
  17. ↑ Easttom C. Deklarace proměnných // Pokročilý Javascript. — 3. vyd. - USA: Wordware Publishing, Inc, 2008. - 81 - 83 s. — ISBN 1-59822-033-0 .
  18. ↑ Keith J. Variables // Skriptování DOM: Webový design s JavaScriptem a objektovým modelem dokumentu. — 1. vyd. - USA: Wordware Publishing, Inc, 2005. - 18 - 20 s. — ISBN 1590595335 .
  19. ↑ Petr-Paul Koch. Kapitola 5 Jádro. Sekce D. Proměnné // ppk v JavaScriptu / Editor: Wendy Sharp. — 1. vyd. - New Riders Press, 2006. - 528 s. - ISBN 978-0-321-42330-6 .
  20. ↑ Crockford D.A.4. Reserved Words // JavaScript: The Good Parts. - 2008. - 170 s. - ISBN 978-0-596-51774-8 .
  21. ↑ David Flanagan. 5.2. Přehled operátora // JavaScript. Podrobný návod = JavaScript. The Definite Guide / Přeložil A. Kiselev. - 5. vyd. - Petrohrad. : "Symbol-Plus" , 2008. - S.  78 -79. — ISBN 5-93286-103-7 .
  22. ↑ David Flanagan. 5.2.4 Asociativita operátora // JavaScript. Podrobný návod = JavaScript. The Definite Guide / Přeložil A. Kiselev. - 5. vyd. - Petrohrad. : "Symbol-Plus" , 2008. - S.  81 . — ISBN 5-93286-103-7 .
  23. ↑ David Flanagan. 5.2.1 Počet operandů // JavaScript. Podrobný návod = JavaScript. The Definite Guide / Přeložil A. Kiselev. - 5. vyd. - Petrohrad. : "Symbol-Plus" , 2008. - S.  79 . — ISBN 5-93286-103-7 .
  24. ↑ David Flanagan. 5.10.8 Operátor volání funkce // JavaScript. Podrobný návod = JavaScript. The Definite Guide / Přeložil A. Kiselev. - 5. vyd. - Petrohrad. : "Symbol-Plus" , 2008. - S.  98 . — ISBN 5-93286-103-7 .
  25. ↑ David Flanagan. 5.2.2 Typ operandů // JavaScript. Podrobný návod = JavaScript. The Definite Guide / Přeložil A. Kiselev. - 5. vyd. - Petrohrad. : "Symbol-Plus" , 2008. - S.  80 . — ISBN 5-93286-103-7 .
  26. ↑ Crockford D.A.13. hasOwnProperty // JavaScript: Dobré části. - 2008. - S. 107. - ISBN 978-0-596-51774-8 .
  27. ↑ Crockford D.A.8. + // JavaScript: Dobré části. - 2008. - 170 s. - ISBN 978-0-596-51774-8 .
  28. ↑ Crockford D.B.12. void // JavaScript: The Good Parts. - 2008. - 170 s. - ISBN 978-0-596-51774-8 .
  29. ↑ Crockford D.B.1. == // JavaScript: Dobré části. - 2008. - 170 s. - ISBN 978-0-596-51774-8 .
  30. ↑ 1 2 Crockford D. 4.1. Function Objects // JavaScript: The Good Parts. - 2008. - S. 26. - ISBN 978-0-596-51774-8 .
  31. ↑ 1 2 3 4 Zakas N. The Function Type // Profesionální JavaScript pro webové vývojáře. — 2. vyd. - USA, Kanada: Wiley Publishing, Inc, 2009. - S. 122-130. - ISBN 978-0-470-22780-0 .
  32. ↑ Soshnikov, Dmitry Subtleties ECMA-262-3. Část 1. Kontexty provádění. (26. června 2009). Získáno 12. října 2010. Archivováno z originálu 16. října 2010.
  33. ↑ Juriy "kangax" Zajcev. Výrazy pojmenované funkce demystified  (anglicky)  (link is down) . — Článek podrobně popisující rozdíl mezi definicí funkce pomocí deklarace a definicí funkce pomocí výrazu. Získáno 19. října 2009. Archivováno z originálu 19. června 2009.
  34. ↑ Maian et al. Podmíněné definování funkce  (anglicky)  (odkaz není k dispozici) . Funkce a rozsah funkcí . — Popis podrobností o implementaci funkcí jako výrazů v kontextu deklarací v rámci podmínek. Získáno 19. října 2009. Archivováno z originálu 14. října 2008.
  35. ↑ Crockford D. 4.4. Argumenty // JavaScript: The Good Parts. - 2008. - S. 31. - ISBN 978-0-596-51774-8 .
  36. ↑ Crockford D. 4.8. Rekurze // JavaScript: Dobré části. - 2008. - S. 35. - ISBN 978-0-596-51774-8 .
  37. ↑ 1 2 3 4 Stefanov S. Funkce zpětného volání // Objektově orientovaný JavaScript: Vytvářejte škálovatelné, opakovaně použitelné vysoce kvalitní aplikace a knihovny JavaScript. — 1. vyd. - Packt Publishing, 2008. - S. 73, 74. - ISBN 184719414.
  38. ↑ Crockford D. 4.11. Zpětná volání // JavaScript: The Good Parts. - 2008. - S. 40. - ISBN 978-0-596-51774-8 .
  39. ↑ 1 2 David Flanagan. 8.8. Rozsah funkcí a uzávěry // JavaScript. Podrobný návod = JavaScript. The Definite Guide / Přeložil A. Kiselev. - 5. vyd. - Petrohrad. : "Symbol-Plus" , 2008. - S.  156 -163. — ISBN 5-93286-103-7 .
  40. ↑ Crockford D. 4.10. Uzavření // JavaScript: Dobré části. - 2008. - 170 s. - ISBN 978-0-596-51774-8 .
  41. ↑ Harmes R., Diaz D. Constants // Pro JavaScript™ Design Patterns. - USA: Apress, 2008. - S. 37, 38. - ISBN 1-59059-908-X .
  42. ↑ 1 2 3 4 Zakas N. The RegExp Type // Profesionální JavaScript pro webové vývojáře. — 2. vyd. - USA, Kanada: Wiley Publishing, Inc, 2009. - S. 115-122. - ISBN 978-0-470-22780-0 .
  43. ↑ 1 2 3 4 Zakas N. The Object Type // Profesionální JavaScript pro webové vývojáře. — 2. vyd. - USA, Kanada: Wiley Publishing, Inc, 2009. - S. 40-41. - ISBN 978-0-470-22780-0 .
  44. ↑ Crockford D. JSON // JavaScript: The Good Parts. - 2008. - S. 136. - ISBN 978-0-596-51774-8 .
  45. ↑ 1 2 3 Zakas N. 6. Objektově orientované programování // Profesionální JavaScript pro webové vývojáře. — 2. vyd. - USA, Kanada: Wiley Publishing, Inc, 2009. - S. 151-182. - ISBN 978-0-470-22780-0 .
  46. ↑ Kuzněcov, Michail Implementační dědičnost v systémech distribuovaných objektů . Nakladatelství "Otevřené systémy" (11. prosince 2002). Získáno 1. listopadu 2009. Archivováno z originálu 17. února 2010.
  47. ↑ Stefanov S. Kapitola 6. Dědičnost. Shrnutí // Objektově orientovaný JavaScript: Vytvářejte škálovatelné, opakovaně použitelné vysoce kvalitní aplikace a knihovny JavaScript. — 1. vyd. - Packt Publishing, 2008. - S. 194-198. — ISBN 184719414.
  48. ↑ ECMAScript 6 . Získáno 17. března 2017. Archivováno z originálu 20. prosince 2016.
  49. ↑ Úvod do JS iterátorů v ES6 . Získáno 17. března 2017. Archivováno z originálu 10. června 2017.
  50. ↑ Úvod ES6 . Získáno 17. března 2017. Archivováno z originálu 20. prosince 2016.
  51. ↑ ES6 funkce šipek . Získáno 17. března 2017. Archivováno z originálu 20. prosince 2016.

ECMAScript standardy

Specifikace ECMAScriptu

  1. ↑ Standard ECMA-262. 13. vydání . ecma-international.org (červen 2022).
  2. ↑ TC39. Stručná historie // Specifikace jazyka ECMAScript . — 5. vyd. - 2009. Archivovaná kopie (nepřístupný odkaz) . Získáno 8. prosince 2009. Archivováno z originálu dne 12. dubna 2015. 
  3. ↑ 123 TC39 . _ 4.3. Definice // Specifikace jazyka ECMAScript . — 5. vyd. - 2009. - S. 4. Archivovaný výtisk (nepřístupný odkaz) . Získáno 11. listopadu 2009. Archivováno z originálu 12. dubna 2015.  
  4. ↑ TC39. 8.5. Typ čísla // Specifikace jazyka ECMAScript . — 5. vyd. - 2009. - S. 29. Archivovaný výtisk (nepřístupný odkaz) . Získáno 11. listopadu 2009. Archivováno z originálu 12. dubna 2015. 
  5. ↑ 1 2 3 4 TC39. 8. Typy // Specifikace jazyka ECMAScript . — 3. vyd. - 1999. - S. 24.
  6. ↑ 1 2 3 4 TC39. 8. Typy // 3. vydání, prosinec 1999.pdf Specifikace jazyka ECMAScript . — 5. vyd. - 2009. - S. 28.  (nepřístupný odkaz)
  7. ↑ TC39. 12. Příkazy // Specifikace jazyka ECMAScript . — 5. vyd. - 2009. - S. 86-97. Archivovaná kopie (nedostupný odkaz) . Získáno 11. listopadu 2009. Archivováno z originálu 12. dubna 2015. 
  8. ↑ 1 2 3 4 TC39. 7.9. Automatické vkládání středníků // Specifikace jazyka ECMAScript . — 5. vyd. - 2009. - S. 25-28. Archivovaná kopie (nedostupný odkaz) . Získáno 11. listopadu 2009. Archivováno z originálu 12. dubna 2015. 
  9. ↑ TC39. 12. Příkazy // Specifikace jazyka ECMAScript . — 3. vyd. - 1999. - S. 61-71. Archivovaná kopie (nedostupný odkaz) . Získáno 11. listopadu 2009. Archivováno z originálu 12. dubna 2015. 
  10. ↑ 123 TC39 . _ 12.2. Příkaz proměnné // Specifikace jazyka ECMAScript . — 5. vyd. - 2009. - S. 87, 88. Archivovaný výtisk (nepřístupný odkaz) . Získáno 11. listopadu 2009. Archivováno z originálu 12. dubna 2015.  
  11. ↑ TC39. 10.2.2. Eval Code // 3. vydání, prosinec 1999.pdf Specifikace jazyka ECMAScript . — 3. vyd. - 1999. - S. 39.  (nepřístupný odkaz)
  12. ↑ TC39. 7.6.1.1. Klíčová slova // Specifikace jazyka ECMAScript . — 5. vyd. - 2009. - S. 18. Archivovaný výtisk (nepřístupný odkaz) . Získáno 11. listopadu 2009. Archivováno z originálu 12. dubna 2015. 
  13. ↑ TC39. 7.5.2. Klíčová slova // 3. vydání, prosinec 1999.pdf Specifikace jazyka ECMAScript . — 3. vyd. - 1999. - S. 13-14.  (nedostupný odkaz)
  14. ↑ 12 TC39 . 7.6.1. Vyhrazená slova // Specifikace jazyka ECMAScript . — 5. vyd. - 2009. - S. 18, 19. Archivovaný výtisk (nepřístupný odkaz) . Získáno 11. listopadu 2009. Archivováno z originálu 12. dubna 2015. 
  15. ↑ TC39. 7.5.3. Budoucí vyhrazená slova // 3. vydání, prosinec 1999.pdf Specifikace jazyka ECMAScript . — 3. vyd. - 1999. - S. 15.  (nepřístupný odkaz)
  16. ↑ TC39. 11.4. Unární operátory // Specifikace jazyka ECMAScript . — 5. vyd. - 2009. - S. 70-72. Archivovaná kopie (nedostupný odkaz) . Získáno 11. listopadu 2009. Archivováno z originálu 12. dubna 2015. 
  17. ↑ TC39. 11.6.1 Operátor přidání (+) // Specifikace jazyka ECMAScript . — 5. vyd. - 2009. - S. 74, 75. Archivovaný výtisk (nepřístupný odkaz) . Získáno 11. listopadu 2009. Archivováno z originálu 12. dubna 2015. 
  18. ↑ TC39. 11.9.3. Algoritmus porovnání abstraktní rovnosti // Specifikace jazyka ECMAScript . — 5. vyd. - 2009. - S. 80, 81. Archivovaný výtisk (nepřístupný odkaz) . Získáno 11. listopadu 2009. Archivováno z originálu 12. dubna 2015. 
  19. ↑ TC39. 4.3. Definice // Specifikace jazyka ECMAScript . — 5. vyd. - 2009. - S. 4-7. Archivovaná kopie (nedostupný odkaz) . Získáno 11. listopadu 2009. Archivováno z originálu 12. dubna 2015. 
  20. ↑ TC39. 13 Definice funkce // Specifikace jazyka ECMAScript . — 5. vyd. - 2009. - S. 97, 98. Archivovaný výtisk (nepřístupný odkaz) . Získáno 11. listopadu 2009. Archivováno z originálu 12. dubna 2015. 
  21. ↑ TC39. 12.2 Příkaz proměnné // Specifikace jazyka ECMAScript . — 5. vyd. - 2009. - S. 87, 88. Archivovaný výtisk (nepřístupný odkaz) . Získáno 11. listopadu 2009. Archivováno z originálu 12. dubna 2015. 
  22. ↑ 12 TC39 . 10.6. Objekt argumentů // Specifikace jazyka ECMAScript . — 5. vyd. - 2009. - S. 60-62. Archivovaná kopie (nedostupný odkaz) . Získáno 11. listopadu 2009. Archivováno z originálu 12. dubna 2015. 
  23. ↑ 1 2 3 4 TC39. 15.10. Objekty RegExp (regulární výraz) // Specifikace jazyka ECMAScript . — 5. vyd. - 2009. - S. 179-196. Archivovaná kopie (nedostupný odkaz) . Získáno 11. listopadu 2009. Archivováno z originálu 12. dubna 2015. 
  24. ↑ TC39. 4.2. Přehled jazyka // Specifikace jazyka ECMAScript . — 5. vyd. - 2009. - S. 2-4. Archivovaná kopie (nedostupný odkaz) . Získáno 11. listopadu 2009. Archivováno z originálu 12. dubna 2015. 
  25. ↑ TC39. 8.6.1. Atributy vlastností // Specifikace jazyka ECMAScript . — 3. vyd. - 1999. - S. 25, 26. Archivovaný výtisk (nepřístupný odkaz) . Získáno 11. listopadu 2009. Archivováno z originálu 12. dubna 2015. 
  26. ↑ TC39. Vlastnosti objektu Prototyp objektu // Specifikace jazyka ECMAScript . — 5. vyd. - 2009. - S. 114-116. Archivovaná kopie (nedostupný odkaz) . Získáno 11. listopadu 2009. Archivováno z originálu 12. dubna 2015. 

Komentáře

  1. ↑ Pouze pro do-while
  2. ↑ Jedno zpětné lomítko unikne metaznakům řetězce (například \t). Dvojité zpětné lomítko se používá k opuštění metaznaků regulárního výrazu (například \\s)

Standardy kódování JavaScriptu

  1. ↑ 1 2 3 Crockford , Douglas Code Conventions for JavaScript Programming Language  . JavaScript Douglase Crockforda . Standard formátování kódu JavaScriptu Douglase Crockforda. Získáno 5. října 2009. Archivováno z originálu 18. února 2012.
  2. ↑ 1 2 Konvence kódu  JavaScript . echo webový rámec . Next App, Inc. — Kódovací standard JavaScript přijatý pro Echo Web Framework. Získáno 5. října 2009. Archivováno z originálu 18. února 2012.
  3. ↑ Amaram, Rahul Javascript Naming Conventions , Coding Guidelines and Best Practices  . echo webový rámec . — Standard formátování kódu JavaScript Raoula Amarama. Získáno 5. října 2009. Archivováno z originálu 18. února 2012.
  4. ↑ 1 2 3 Komenda, Klaus Pokyny a standardy kódování JavaScriptu  . Stránky rakouského webového vývojáře Klause Komenda . — Standard formátování kódu JavaScript od Klause Komenda. Získáno 5. října 2009. Archivováno z originálu 18. února 2012.
  5. ↑ Styl kódování JavaScriptu  . Gnome. — Standard kódování JavaScriptu GNOME. Datum přístupu: 24. prosince 2009. Archivováno z originálu 18. února 2012.

Odkazy

 ECMAScript
Dialekty
Motory
( srovnání )
Rámce ,
knihovny
JavaScript
( porovnat )
na straně klienta
na straně serveru
Knihovny
( seznam )
  • SWFOobject
  • SWFAadresa
ActionScriptPureMVC
Více
implementací
Lidé
jiný
 Mezinárodní standardy Ecma