ECMAScript

Den aktuella versionen av sidan har ännu inte granskats av erfarna bidragsgivare och kan skilja sig väsentligt från versionen som granskades den 15 juni 2022; kontroller kräver 2 redigeringar .
ECMAScript
Språkklass Specifikation för programmeringsspråk , funktionellt programmeringsspråk och multiparadigm programmeringsspråk
Framträdde i juni 1997
Författare Brendan Eich och Ecma International
Utvecklaren Brendan Eich
Filtillägg _ .es[2]
Släpp ECMAScript 2022 [Spec 1]  (juni 2022 ) ( 2022-06 )
Typ system Anka
Dialekter JavaScript , JScript , ActionScript , JScript.NET , QtScript
Blev påverkad Själv [1] , C , Schema [1] , Perl [1] , Python , Java [1] , AWK [1]
påverkas Mål-J
Hemsida ecma-international.org _ 

ECMAScript  är ett inbäddningsbart, utbyggbart, I/O- löst programmeringsspråk som används som grund för att bygga andra skriptspråk [3] .

ECMAScript är standardiserat av den internationella organisationen ECMA i ECMA-262- specifikationen . Språktillägg: JavaScript , JScript och ActionScript .

Historik

Språket härstammar från flera tekniker, varav de mest kända är JavaScript- och JScript- språken . Utvecklingen av den första revideringen av specifikationen började i november 1996. Specifikationen antogs i juni 1997. Inlämnad till ISO/IEC JTC 1 för Fast-Tracking- acceptans , fungerade den som grund för den internationella standarden ISO/IEC 16262 . I juni 1998 antog ECMA:s bolagsstämma den andra upplagan av ECMA-262, motsvarande ISO / IEC 16262. Den tredje upplagan av specifikationen skilde sig från den tidigare genom att införa stöd för reguljära uttryck, förbättra strängstöd, införa nya kontrollstrukturer , en undantagsmekanism, formatering vid numerisk inmatning och några andra ändringar[Specifikation 2] .

Semantik och syntax

Datatyper

Fem primitiva datatyper stöds i ECMAScript :

Den numeriska datatypen i ECMAScript motsvarar 64-bitars flyttalsformatet definierat av IEEE 754-2008-standarden , förutom att de olika Not-a-Number- värdena som definieras i standarden [4] är representerade på det språket med det enda specialvärdet NaN [ Specifikation 4] .

Null och odefinierade datatyper hänvisas informellt till som "triviala" typer av David Flanagan , eftersom var och en av dem definierar endast ett värde [5] .

Språket har också en "sammansatt" datatyp [5] :

Utöver de sex datatyperna som anges, stöder ECMAScript ytterligare sju som används uteslutande för att lagra mellanresultat av utvärderade uttryck:

Populariteten för JavaScript-språket och det obetydliga med att bearbeta data av olika typer ledde till spridningen av akademisk forskning inom området för att analysera ECMAScript-datatyper, som syftar till att skapa en fullfjädrad kodanalysator som kan användas i integrerad utveckling miljöer [6] .

Instruktioner

Det finns femton olika typer av instruktioner i ECMAScript, som listas i tabellen nedan:

Instruktionstyper definierade av språkspecifikationen [Specifikation 7]
namn ursprungliga namn Kort information Final ; [Specifikation 8]
Blockera engelsk  blockera {[<instruktioner>]} −
Rörlig deklaration engelsk  VariableStatement var <lista över variabeldeklarationer> +
Tom instruktion engelsk  EmptyStatement ; +
Uttryck engelsk  ExpressionStatement [sträng till ∉ {{, funktion}]-sats +
Skick engelsk  IfStatement if (<инструкция>) <выражение>[ else <выражение>] −
Cykel engelsk  IterationStatement gör <uttryck> medan (<påstående>)

while (<påstående>) <uttryck>
för ([<påstående före start>]; [<påstående>]; [<påstående>]) <uttryck>
för (<variabeldeklaration>; [<påstående>]; [<påstående>] >]) <uttryck>
för (<lvärde-uttryck> i <uttryck>) <uttryck>
för (<variabeldeklaration> i <uttryck>) <uttryck>

+/− [~1]
Fortsättning engelsk  ContinueStatement fortsätt [<identifier>] +
Avbryta engelsk  BreakStatement bryta [<identifierare>] +
Lämna tillbaka engelsk  ReturnStatement returnera [<instruktion>] +
Kombination engelsk  WithStatement med (<påstående>) <uttryck> −
Märka engelsk  Märkt Statement <identifier>: <uttryck> −
Val engelsk  SwitchStatement switch (<påstående>) fall <påstående>: [<uttryck>][case <påstående>: [<uttryck>] ...] [standard: [<uttryck>]] −
Kasta ett undantag engelsk  ThrowStatement kasta <instruktion> +
försök blockera engelsk  TryStatement försök <block> catch (<identifier>) <block>
försök <block> slutligen <block>
försök <block> catch (<identifier>) <block> slutligen <block> 		−
(ny [Spec 9] ) Debugger engelsk  Debugger felsökare −
Autoslutför strängar med semikolon

Trots det obligatoriska semikolonet i de fall som anges i den fjärde kolumnen, deklarerar specifikationen en mekanism för autokomplettering av strängar med semikolon , vilket leder till det faktum att om det finns en radbrytning kan instruktionen före radbrytningen utrustas med detta tecken [ Specifikation 8] , som är föremål för kritik [ 7] .

Instruktioner som ändrar betydelse när du använder en ny rad i [Specifikation 8]
  • Unär postfix ++
  • Unär postfix --
  • Fortsättning
  • Avbryta
  • Lämna tillbaka
  • Kasta ett undantag

Ett exempel på att ändra innebörden av en instruktion

return { status : "komplett" };

Här innehåller den markerade raden en instruktion som är giltig av språket, och eftersom en ny rad följer, utlöses mekanismen för autokomplettering av rader med semikolon. Istället för att funktionen som innehåller ovanstående kod returnerar ett objekt med egenskapen som dess värde status, kommer den att returnera undefined.

Även om den bokstavliga formen av ett objekt inte är ett kodblock, kan enhetliga parenteser leda till fel. Utvecklingen eller antagandet av en lämplig kodningsstandard kan minska sannolikheten för att de inträffar . Valet av indragsstil spelar roll . Speciellt är stilarna Allman och Whitesmith , såväl som Horstman -stilen och GNU-stilen för JavaScript-kod, föråldrade av de flesta riktlinjer [8] i motsats till K&R , 1TBS , BSD KNF- stilarna .

Autoslutförande misslyckande

Om uttrycket som skrivs på nästa rad syntaktiskt sett kan vara en fortsättning på uttrycket på föregående rad, fungerar inte mekanismen för att autokomplettera rader med semikolon [9] .

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

I det här exemplet tolkas hakparenteserna på den andra raden som att de refererar till ett matriselement som returneras av func(). Kommat inom parentes behandlas som motsvarande operator som returnerar 'h2'. Så koden konverteras till följande:

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

Det är vanligt att i kodningsstandarder kräva semikolon även om språkets syntax tillåter att de utelämnas [Coding Standards 1] [Coding Standards 2] [Coding Standards 3] [Coding Standards 4] [Coding Standards 5] .

Block och omfattning

En annan egenskap hos ECMAScript i förhållande till andra C-liknande språk är att i det här språket bildar block inte ett omfång . Variabler som deklareras i ett block gäller för hela funktionen som innehåller blocket [10] [11] .

I det här avsnittet av koden deklareras variabeln på nytt i de markerade raderna:

function foo ( ) { varsum = 0 ; för ( var i = 0 ; i < 42 ; i += 2 ) { var tmp = i + 2 ; summa += i * tmp ; } for ( var i = 1 ; i < 42 ; i += 2 ) { summa += i * jag ; } alert ( tmp ); retursumma ; _ } foo ();

Dessutom är variabeln tmp som deklareras inuti den första av looparna (rad 4) laglig att komma åt från utsidan av loopen (rad 10) enligt språkets syntax.

På grund av räckvidden och blockens karaktär rekommenderas det att deklarera variabler i början av funktioner för att bibehålla källkodens kvalitet [10] [Coding standards 1] [Coding standards 4] .

Variabeldeklarationer

Variabler definieras med nyckelord var, let, const. När en variabel deklareras placeras den i det omfång som motsvarar i fallet med en varfunktion, och i fallet let, constmed ett kodblock. Om en variabel deklareras utanför funktioner, placeras den i det globala omfånget. Skapandet av en variabel sker när kontrollen av funktionen med dess deklaration tas emot. Eller ett program om variabeln är global. När en variabel skapas i ECMAScript får den värdet undefined. Om en variabel deklareras med initialisering sker initiering inte i det ögonblick då variabeln skapas, utan när raden med instruktionen var[Specifikation 10] exekveras .

När du tar bort den valda raden kommer skärmen inte att visa nummer utan odefinierat :

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

När en variabel skapas får den den interna egenskapen {DontDelete} och kan inte tas bort med operatorn delete[Specifikation 10] . Undantaget är variabler som deklareras i sammanhanget eval[12] [Specifikation 11] .

Många källor [13] [14] [15] [16] [17] [18] deklarerar möjligheten att implicit deklarera variabler i ECMAScript när man tilldelar en giltig identifierare som inte är ett formellt funktionsargument utan att först deklarera med var. Men i språkspecifikationens terminologi skapas i detta fall en egenskap för det globala objektet, inte en variabel [12] [Specifikation 10] .

Genom att i kodningsstandarden fixa behovet av att deklarera variabler innan de används [Coding Standards 1] [Coding Standards 4] (eller fixa behovet av att använda namnutrymmen för alla globala objekt [Coding Standards 2] ) undviks subtila fel, vilket förhindrar faran för interaktion av identiskt namngivna variabler i olika delar av koden [19] .

Nyckelord och reserverade ord

Följande ord är nyckelord på språket och kan inte användas som identifierare [Spec 12] :

bryta gör instans av typ av fall annat nytt var fånga äntligen tillbaka tom fortsätt för att byta medan debugger funktion detta med standard om kasta radera i försök

Jämfört med den tredje utgåvan av specifikationen [Specifikation 13] lade den femte utgåvan till ett nyckelord debuggermed motsvarande instruktion.

Följande ord används som nyckelord i föreslagna tillägg och är därför reserverade för möjligheten att anpassa dessa tillägg [Specifikation 14] :

klass enum sträcker sig super const export import

När du använder strikt läge, behandlas följande ord som reserverade för framtida användning [Spec 14] :

redskap låter privat offentligt ge gränssnittspaket skyddat statiskt

Jämfört med den tredje upplagan av språkspecifikationen har alltså antalet ord som reserverats för framtida bruk minskat avsevärt. Tidigare fanns det 31 [Specifikation 15] , och förekomsten av ett stort antal nyckelord och reserverade ord, varav de flesta inte används i språket, kritiserades [20] .

Operatörer

ECMAScript har både operatorer som använder nyckelord som namn och operatorer som använder skiljetecken som namn .

Klassificering av operatörer

I fallande prioritetsordning kan ECMAScript-operatorer delas in i följande grupper:

  • .(egenskapsåtkomst), [](egendomsåtkomst), ()(funktionsanrop), new(skapande av nytt objekt),
  • ++(öka), --(minska), -(unär minus), +(unär plus), ^(bitvis komplement), !(booleskt komplement), delete(delete egenskap), typeof(definiera primitiv datatyp), void(retur null),
  • *(multiplicera), /(dela), %(resten av divisionen),
  • +(addition), -(subtraktion), +(strängsammansättning),
  • <<(vänster växling), >>(höger växling med teckenbitförlängning), >>>(höger växling med noll stoppning),
  • <(mindre än), <=(mindre än eller lika med), >(större än), >=(större än eller lika med), instanceof(objekttypstest), in(egenskapstest),
  • ==(jämlikhetstest), !=(ojämlikt test), ===(identitetstest), !==(icke-identitetstest),
  • &(bitvis konjunktion ),
  • ^(bitvis addition modulo 2 ),
  • |(bitvis disjunktion ),
  • &&(samband),
  • ||(åtskiljande),
  • ?:( ternär villkorlig operation ),
  • =(uppdrag), *=, /=, +=, -=, <<=, >>=, >>>=, &=, ^=, |=(uppdrag med operation),
  • ,(multipel beräkning) [21] .

Operatörerna ++, --, -, +, ~, !, delete, typeof, void, ?:, , , , =, *=, /=, +=, -=, <<=, >=, >>>=, &=, ^=, är högerassociativa |=(det vill säga de är a op b op clikvärdiga med a op (b op c)). De återstående ECMAScript-operatorerna lämnas associativa [22] .

Enligt arity är ECMAScript-operatorer indelade i följande grupper:

  • unary ( delete, void, typeof, ++, --, -(arär minus), +(unär plus), ^, !, new) [Specifikation 16] ,
  • binär ( ., [], (), *, /, %, +(addition), ( -subtraktion), ( +strängsammansättning) , <<, >>, >>>, <, <=, >, >=, instanceof, in, ==, !=, ===, !==, &, ^, |, &&, ||, =, *=, /=, +=, -=, <<=, >=, >>>=, ),&=^=|=,
  • ternär ( ?:) [23] ,
  • operatorer som inte har ett fast antal operander ( ()) [24] .

Enligt positionen för operationens tecken i förhållande till operanderna är ECMAScript-operatorer indelade i följande grupper:

  • prefix (till exempel new, ++(prefixökning),
  • infix (till exempel +, -),
  • postfix (till exempel ++(postfix inkrement), --(postfix decrement).

Operatörer klassificeras också efter typen av operander [25] och arten av den utförda åtgärden.

Funktioner i ECMAScript-satser

Det finns ingen operator i ECMAScript som låter dig kontrollera om en egenskap hör direkt till ett objekt eller är ärvd. Denna kontroll utförs med hjälp av hasOwnProperty(). På grund av det faktum att denna metod inte är en operatör kan den skrivas över av vilken annan egenskap som helst [26] .

Operator +är den enda aritmetiska operatorn i språket som är överbelastad för strängargument. Om minst en av operanderna är en sträng, +fungerar den som en sammanlänkning , annars utför den addition [27] [Specifikation 17] .

Till skillnad från språk där void är en datatyp, är det i ECMAScript en operator som returnerar ett värde undefined[28] .

Operatören ==kontrollerar jämlikhet enligt en algoritm som består av 10 steg, vilket i vissa fall innebär typkonvertering [Specifikation 18] , vilket i slutändan kan leda till icke-uppenbara resultat [29] .

Ett exempel på resultatet av arbetet ==(i alla de listade fallen kommer värdet av operatören ===med samma argument att vara false):

alert ( "NaN" == NaN ); // falsk varning ( NaN == NaN ); // falsk varning ( true == 1 ); // true alert ( true == 42 ); // falsk varning ( null == 0 ); // falsk varning ( 0 == "" ); // true alert ( "" == 0 ); // true alert ( "false" == falskt ); // falsk varning ( falsk == 0 ); // true alert ( odefinierad == false ); // false alert ( null == false ); // falsk varning ( odefinierad == null ); // true alert ( " \t\r\n " == 0 ); // Sann

Funktioner

Funktioner i ECMAScript är objekt [30] [31] . Konstruktören som de skapas med är Function(). Funktioner, som alla andra objekt, kan lagras i variabler, objekt och arrayer, kan skickas som argument till andra funktioner och kan returneras av funktioner. Funktioner, som alla andra objekt, kan ha egenskaper. En väsentlig specifik egenskap hos funktioner är att de kan kallas [30] .

Definiera funktioner

Det finns två typer av funktioner i ECMAScript:

  • interna funktioner (till exempel parseInt),
  • funktioner definierade i programtexten.

Interna funktioner är inbyggda objekt (se nedan ), inte nödvändigtvis implementerade i ECMAScript [Specifikation 19] .

I programmets text kan en namngiven funktion i ECMAScript definieras på något av följande sätt:

// funktionsdeklaration funktion summa ( arg1 , arg2 ) { return arg1 + arg2 ; } // definiera en funktion med hjälp av en sats var sum2 = function ( arg1 , arg2 ) { return arg1 + arg2 ; }; // definiera en funktion med hjälp av objektnotation var sum3 = new Function ( "arg1" , "arg2" , "return arg1 + arg2;" );

Den senare metoden är den minst föredragna, eftersom det de facto handlar om att definiera en funktion med hjälp av ett uttryck, men samtidigt genererar den en dubbeltolkning av koden (en ytterligare tolkning sker när koden skickas till konstruktorn), vilket kan påverka prestandan negativt [31] .

De två första metoderna ger en liknande men inte identisk effekt. För att göra saken värre kan satsen som används när man definierar en funktion se väldigt lik en funktionsdeklaration: för det första kan nyckelordet functionföljas av en identifierare [Specifikation 20] , för det andra kan semikolon utelämnas på grund av strängkompletteringsmekanismen semikolon [Specifikation 8] . Exempel:

// funktionsdeklaration funktion summa ( arg1 , arg2 ) { return arg1 + arg2 ; } // definiera en funktion med hjälp av ett uttryck var sum2 = funktion summa ( arg1 , arg2 ) { return arg1 + arg2 ; } funktionsfält () { }; // använd funktionsdeklarationen ( funktionsfält ( ){}) // använd lämplig instruktion

Den viktigaste skillnaden mellan att definiera en funktion med hjälp av en deklaration och att definiera en funktion med hjälp av ett uttryck är att i det förra fallet sker skapandet av en variabel och dess tilldelning som värdet på funktionen innan koden exekveras när exekveringskontexten går in . I det andra fallet får variabeln värdet av initialiseraren när tilldelningssatsen exekveras. När en variabel skapas vid inträde i en exekveringskontext, initieras den med värdet undefined[Spec 21] [32] (se Variable Declarations för detaljer ).

Ett exempel som illustrerar skillnaden i kodexekveringsordning:

alert ( summa ( 3 , 4 )); // 7: summavariabeln har redan skapats när denna rad exekveras, och funktionen summa ( arg1 , arg2 ) har tilldelats den funktion summa ( arg1 , arg2 ) { return arg1 + arg2 ; } alert ( sum2 ( 3 , 4 )); // error: variabel summa2 har redan skapats när den här raden körs, men undefined har tilldelats den var sum2 = function ( arg1 , arg2 ) { return arg1 + arg2 ; };

Funktionsdeklarationer bör inte användas i villkorliga konstruktioner [33] , även om Gecko-webbläsare kommer att hantera detta intuitivt genom den implementerade funktionsmekanismen som instruktioner [34] .

Funktionstilldelningar

Eftersom funktioner i ECMAScript är objekt, det vill säga de är av en referensdatatyp , är funktionsidentifierare variabler som lagrar en referens till funktionen. Detta kan illustreras med följande kod:

var summa = function ( arg1 , arg2 ) { return arg1 + arg2 ; }; alert ( summa ( 3 , 4 )); // 7 var summa2 = summa ; alert ( sum2 ( 4 , 2 )); // 6 summa = null ; alert ( sum2 ( 42 , 42 )); // 84

I den markerade raden bör du vara uppmärksam på frånvaron av funktionsanropsoperatören ( ()) på höger sida av uppdraget. Om istället för summa indikerades på denna rad sum(), skulle variabeln sum2 inte tilldelas en funktion, utan resultatet av dess anrop. En annan sak som är värd att notera är att efter tilldelningen pekar summa2 inte på en kopia av funktionen, utan på just den funktion som summan pekar på .

Funktionsöverbelastning

I ECMAScript är funktionsöverbelastning inte en egenskap hos språket, men dess effekt tillhandahålls genom användning av andra mekanismer.

Ett exempel som visar frånvaron av funktionsöverbelastning:

function summa ( arg1 , arg2 ) { return arg1 + arg2 ; } function summa ( arg1 , arg2 , arg3 ) { return arg1 + arg2 + arg3 ; } alert ( summa ( 3 , 4 )); // NaN- varning ( summa ( 3 , 4 , 5 )); // 12

Om flera funktioner med samma namn deklareras, skriver senare deklarationer över tidigare deklarationer [31] .

Effekten av funktionsöverbelastning är dock uppnåbar.

1. Kontrollera om det finns odefinierat. För att kontrollera om det faktiska argumentet skickades till funktionen, kan du kontrollera det formella argumentet för identitet till värdet av undefined. Till exempel:

function summa ( arg1 , arg2 , arg3 ) { if ( arg3 !== odefinierad ) { return arg1 + arg2 + arg3 ; } else { return arg1 + arg2 ; } } alert ( summa ( 3 , 4 )); // 7 alert ( summa ( 3 , 4 , 5 )); // 12

2. Skriv check. Dessutom kan typeof, instanceof, constructoranvändas för att ta reda på typen av faktiska argument och anpassa funktionens beteende beroende på dem.

function summa ( arg1 , arg2 , arg3 ) { switch ( typeof arg3 ) { case "undefined" : return arg1 + arg2 ; case "number" : return arg1 + arg2 + arg3 ; default : return arg1 + arg2 + " (" + arg3 + ")" ; } } alert ( summa ( 3 , 4 )); // 7 alert ( summa ( 3 , 4 , 5 )); // 12 alert ( summa ( 3 , 4 , "!" )); // "7 (!)"

3. Tillgång till data om argument. I ECMAScript-funktioner kan du komma åt argumentdata med hjälp av objektet arguments[Specification 22] . I synnerhet låter den dig använda indexering för att komma åt specifika argument som skickats [31] [35] och en egenskap lengthsom lagrar antalet argument som faktiskt skickas, vilket kan vara användbart när du använder det generiska programmeringsparadigmet .

function summa () { var res = 0 ; for ( var i = 0 ; i < argument . längd ; i ++ ) { res += argument [ i ]; } returnera res ; } alert ( summa ( 3 , 4 )); // 7 alert ( summa ( 3 , 4 , 5 )); // 12 alert ( summa ( 3 , 4 , 5 , 7 , 9 )); // 28 Rekursion

ECMAScript-funktioner kan anropas rekursivt. När du definierar en funktion med hjälp av en sats utan att ange en identifierare efter nyckelordet functioni funktionen, kan du referera till den med callee-egenskapen för objektet arguments[Specification 22] .

Ett exempel på rekursiv faktorberäkning:

var factorial = funktion ( steg , res ) { res = res || 1 ; if ( steg < 2 ) { return res ; } returnerar argument . callee ( steg - 1 , steg * res ); }; varning ( faktoriell ( 5 )); // 120

För närvarande implementerar inte ECMAScript svansrekursion , som används för att optimera rekursiva anrop [36] .

Återuppringningar

I ECMAScript är en funktion ett förstaklassobjekt och kan skickas som ett argument till en annan funktion. Om den samtidigt anropas i funktionen som den skickas till, så kallas den för en återuppringningsfunktion (eller återuppringningsfunktion ). Om den godkända funktionen inte har ett namn är det en anonym återuppringningsfunktion ( anonym återuppringningsfunktion ) [37] . De främsta anledningarna till att använda återuppringningsfunktioner är:

  • undvika funktionsnamn när du arbetar med det (hjälper till att minska antalet globala variabler) [37] ,
  • delegera ett funktionsanrop till en annan funktion (hjälper till att öka kodens uttrycksförmåga) [37] ,
  • prestandaökning [37] ,
  • förenkling av hanteringen av korta händelser [38] .

Ett exempel på en funktion som returnerar summan av resultaten av exekvering av den godkända funktionen på argumenten:

function sumOfResults ( återuppringning ) { var result = 0 ; for ( var i = 1 ; i < argument . length ; i ++ ) { result += callback ( argument [ i ]); } returnera resultat ; } var square = function ( x ) { return x * x ; }; alert ( sumOfResults ( square , 3 , 4 )); // 25 Stängningar

Funktioner i ECMAScript är i sig lexikalt omfångade. Detta innebär att omfattningen definieras vid den tidpunkt då funktionen definieras (till skillnad från dynamiskt omfång, där omfattningen definieras vid den tidpunkt då funktionen anropas) [39] .

När en funktion deklareras lagras sekvensen av kapslade funktionsomfång som en del av funktionens tillstånd. Det vill säga under programexekveringen behåller funktioner som har tillgång till lokala variabler för omslutande funktioner sådan åtkomst under programmets exekvering [39] .

Stängningsmekanismen kan användas för att begränsa synligheten av variabler i en fristående del av programmet så att det inte finns några namnkonflikter när de delas med annan kod. För att göra detta placeras koden i en anonym funktion, försedd med en funktionsanropsoperatör.

( function () { // Del av programmet vars åtkomst till variabler måste isoleras utifrån. })();

I det här fallet blir funktionerna som definieras i programdelen kapslade med avseende på den tillagda anonyma funktionen, och det är möjligt att komma åt de lokala variablerna för den anonyma funktionen (som var globala innan den introducerades). De kan dock inte nås utanför den anonyma funktionen: resultatet av funktionskörningen ignoreras.

Stängningar används inte bara för att förbjuda åtkomst till ett antal variabler, utan också för att ändra sådan åtkomst. Detta uppnås med funktioner som returnerar andra funktioner. Ett exempel på en serienummergeneratorfunktion:

var uniqueId = function () { var id = 0 ; return function () { return id ++ ; }; }(); var aValue = unikt ID (); var anotherValue = unikt ID ();

Genom att använda en stängning har endast den funktion som tilldelats variabeln uniqueId tillgång till id -variabeln .

Curry exempel :

var multNumber = function ( arg ) { return function ( mul ) { return arg * mul ; }; }; var multFive = multNumber ( 5 ); alert ( multFive ( 7 )); //35

Ett exempel på att skapa ett objekt som låter dig komma åt egenskapen enbart med hjälp av dess metoder [40] :

var myObject = function () { var value = 0 ; return { increment : function ( inc ) { value += typeof inc === 'nummer' ? ink : 1 ; }, getValue : function ( ) { return value ; } } }(); alert ( myObject . value === odefinierat ); // true alert ( myObject . getValue ()); // 0 myObject . öka ( 9 ) myObject . öka ( 7 ) alert ( myObject . getValue ()); // 16

Med det här tricket kan du använda en stängning för att emulera konstanter [41] .

var getConstant = function () { var constants = { UPPER_BOUND : 100 , LOWER_BOUND : - 100 }; return function ( constantName ) { return constants [ constantName ]; }; }(); alert ( getConstant ( "LOWER_BOUND" )); // -100

Reguljära uttryck

Syntaxen och funktionaliteten för reguljära uttryck i ECMAScript påverkades av Perl 5 [Spec 23] och tillåter två typer av syntax: literal och object .

var literalWay = /mönster/flaggor; var objectWay = new RegExp ( mönster , flaggor );

I det första fallet anges mallen ( pattern) och flaggorna ( flags) explicit, utan ytterligare redundanta syntaktiska tecken: snedstreck fungerar som avgränsare . I det andra fallet måste mallen och flaggorna vara variabler som innehåller strängvärden, eller direkt strängvärden. Den bokstavliga notationen är att föredra eftersom den inte kräver dubbel [~ 2] escape av reguljära uttrycksmetatecken, till skillnad från objektformen [42] .

Följande symboler kan användas som flaggor i ECMAScript:

Flaggor för reguljära uttryck [42] [Spec 23]
Flagga Beskrivning
g g globalt läge: mönstret tillämpas på alla matchningar i strängen, det reguljära uttrycket slutar inte efter att mönstrets första matchning har hittats
i och skiftläge - ignorering : vid matchning ignoreras skiftläge för mönstertecken och strängar
m flerradsläge : en rad som innehåller nya radstecken behandlas som flera rader åtskilda av radmatningstecken; regex fungerar på alla linjer

Varje reguljärt uttryck är ett objekt med följande egenskaper:

Egenskaper för ECMAScript reguljära uttrycksobjekt [42] [Specifikation 23]
Fast egendom Sorts Beskrivning
global logisk visar om flaggan är inställdg
ignoreCase logisk visar om flaggan är inställdi
multiline logisk visar om flaggan är inställdm
lastIndex numerisk matchar positionsnumret i strängen där mönstermatchningen hittades som ett resultat av den tidigare tillämpningen av det reguljära uttrycket, eller 0 om det reguljära uttrycket inte tidigare tillämpats
source sträng sträng som matchar det reguljära uttrycksmönstret

Dessutom definieras följande metoder för reguljära uttryck:

Reguljära uttrycksobjektmetoder i ECMAScript [ 42] [Specifikation 23]
Metod returtyp Beskrivning
exec(handledString) objekt (array) ellernull bildar en array av delsträngar som matchar det angivna mönstret , med hänsyn till setflaggorna . nullom ingen delsträng matchar mönstret
test(handledString) logisk trueom det finns en sträng som matchar mönstret och falseannat

Objekt

Implementering på språket

ECMAScript-objekt är oordnade samlingar av egenskaper , som var och en har ett eller flera attribut som bestämmer hur egenskapen kan användas - till exempel om värdet på ReadOnly-attributet är satt till true , då kan varje försök genom att exekvera ECMAScript-kod ändra värdet på den egenskapen kommer att misslyckas. . Egenskaper är behållare som kapslar in andra objekt, värden av primitiva typer och metoder [Specifikation 24] .

ECMAScript-objektegenskapsattribut [Spec 25]
namn Beskrivning
skrivskyddad Fastigheten är en skrivskyddad fastighet. Ett försök att ändra värdet på den här egenskapen, gjort i programmet, kommer att förbli meningslöst. I vissa fall ändras värdet på en egenskap med ReadOnly-attributuppsättningen på grund av åtgärderna i språktilläggsmiljön, så ReadOnly ska inte förstås som oföränderlig.
DontEnum Egenskapen är inte uppräknad efter loopfor-in
Ta inte bort Försök att ta bort den här egenskapen kommer att ignoreras.
Inre Fastigheten är intern. Den har inget namn och kan inte nås med accessorer . Tillgången till dessa egenskaper bestäms av språkimplementeringen.

ECMAScript-objekt är indelade i grundläggande (native) och extension (värd) objekt. Med bas menar vi alla objekt som är oberoende av miljön relaterade till utvidgningen av språket. Några av de grundläggande objekten är inbyggda : existerande från början av programmets körning. Andra kan skapas när programmet körs. Tilläggsobjekt tillhandahålls av ECMAScript-tillägget, och för ECMAScript betyder detta att de är en del av Document Object Model eller Browser Object Model [Specifikation 3] .

Syntax

Objekt och bokstavliga former kan användas för att specificera objekt. Objektformen för att specificera ett objekt har en syntax som liknar Java, men till skillnad från den måste parenteser i ECMAScript endast användas när argument skickas till en konstruktor [43] . Följande poster är syntaktiskt likvärdiga:

varobj1 = nytt objekt ( ); var obj2 = nytt objekt ; var obj3 = {};

Det andra alternativet rekommenderas dock inte [43] . Douglas Crockford rekommenderar att man också undviker det första alternativet och föredrar den bokstavliga formen, som han anser är en stor fördel med språket [44] .

Språkspecifikationen arbetar med begreppet ett objekts egenskap , kallar en metod för en funktion som används som en egenskap hos ett objekt [Specifikation 3] .

Varje objekt i språket har följande egenskaper:

Egenskaper för ECMAScript-objekt [43]
namn Kort beskrivning
constructor Funktionen som används för att skapa objektet (i exemplen ovan är det Object())
hasOwnProperty(propertyName) Anger om den givna egenskapen finns i objektet (inte i dess prototyp )
isPrototypeOf(objekt) Bestämmer om ett objekt finns i argumentobjektets prototypkedja
propertyIsEnumerable(propertyName) Indikerar om egenskapen med det angivna namnet kan räknas upp i slinganfor-in
att stränga() Returnerar strängrepresentationen av objektet
värdet av() Returnerar detta värde . Om objektet är resultatet av ett anrop till ett tilläggsobjekts konstruktor är värdet valueOf()implementeringsberoende [Spec 26] . Ofta är returvärdet ett primitivt typvärde som motsvarar ett objekt. Som regel är resultatet av denna metod detsamma som resultatet av toString(). Objekt skapade med en konstruktor Date() är ett utmärkt exempel där resultaten av toString()och valueOf()inte matchar [43] .

Objektegenskaper nås med hjälp av punkt- och parentesnotation :

var obj = nytt objekt (); alert ( obj . konstruktor === obj [ "konstruktör" ]); // true - använd punkt- och parentesnotation för att komma åt egenskapen var foo = obj [ "toString" ]; // använder parentesnotation för att lagra funktionen i en variabel var result = obj [ "toString" ](); // sparar resultatet av funktionsanropet till en variabelvarning ( foo ( )); // visar resultatet av anropet av den lagrade funktionen på skärmen varning ( resultat ); varboo = obj . _ toString ; // liknande med punktnotation var res = obj . toString (); varning ( boo ()); varning ( res );

Nya egenskaper kan ställas in dynamiskt.

varcountry = nytt objekt ( ); country [ "name" ] = "Ryssland" ; // använd parentes beteckning land . grundår = 862 ; // använd punktnotation var country2 = { "name" : "Ryssland" , "foundationYear" : 862 }; // använd bokstavlig form

Tillvägagångssätt för att skapa objekt

Att skapa objekt på det sätt som beskrivs i föregående avsnitt kan vara opraktiskt på grund av behovet av att duplicera kod [45] . Om programmet manipulerar ett stort antal objekt av samma typ, har utvecklaren möjlighet att välja en av teknikerna som används i språket [45] :

föremålsfabrik en funktion som skapar ett objekt och returnerar det som dess värde, konstruktör en funktion som använder nyckelordet thisför att bilda egenskaperna för objektet som det skapar med operatorn new, prototyp tillvägagångssätt använda egenskapen prototypeför en funktion för att visa objektens allmänna egenskaper, blandad tillvägagångssätt konstruktör-prototyp använda en konstruktor för att ställa in egenskaper för objekt som inte är metoder och en prototypmetod för att ställa in metoder, dynamisk prototypmetod avsluta koden relaterad till funktionen att skapa objekt baserade på den blandade konstruktor-prototyp-metoden till en funktion, vilket säkerställer att prototypegenskaper tilldelas en gång, parasitisk konstruktormetod använd newmed objektfabriksfunktion.

Det finns inga klasser i språket , men de kan emuleras med hjälp av konstruktorer. Ett exempel på klassemulering i ECMAScript:

function MyClass () { this . mittValue1 = 1 ; detta . myValue2 = 2 ; } Min klass . prototyp . myMethod = function () { returnera detta . myValue1 * detta . mittValue2 ; } var mc = new MyClass (); mc . mittValue1 = mc . mittValue2 * 2 ; var i = mc . myMethod ();

Funktioner för arv i ECMAScript

För var och en av objektets komponenter kan arv övervägas. När man ärver gränssnittet till en förälder utan att barnet använder förfaderns funktionalitet talar man om nedärvning av gränssnittet. När det ärver tillstånd, ärver det underordnade objektet datastrukturen för det förfaderobjektet. När vi ärver funktionalitet talar vi om arv tillsammans med gränssnittet och koden för metoder. I regel medför detta behov av att organisera statsarv, vilket gör det rimligt att kombinera statligt arv och funktionsarv till genomförandearv [46] .

När det gäller ECMAScript gäller inte bara gränssnittsarv, eftersom funktioner i språket inte har signaturer [45] .

Möjligheterna som språket ger för att organisera arv kan till exempel bedömas av den lista som Stoyan Stefanov [47] gav över tolv olika sätt att organisera arv.

ECMAScript 6

Antagandet av ES6 har eliminerat många klasser av JavaScript-problem [48] [49] [50] [51] .

Anteckningar

  1. ↑ 1 2 3 4 5 _ Axel Rauschmayer. The Nature of JavaScript // Att tala JavaScript . - Första upplagan. - O'Reilly Media, 2014. - P. 41. - ISBN 978-1-449-36503-5 .
  2. ↑ Skriptmediatyp - 2006.
  3. ↑ Zakas N. ECMAScript // Professionell JavaScript för webbutvecklare. — 2:a uppl. - USA, Kanada: Wiley Publishing, Inc, 2009. - S. 3-7. - ISBN 978-0-470-22780-0 .
  4. ↑ Aiken A., Applegate M., Bailey D. och andra. 6.2. Operations with NaNs // IEEE Standard for Floating-Point Arithmetic / Chair Zuras D., Editor Cowlishaw M. - USA, 2008. - P. 34. - ISBN 978-0-7381-5753-5 .
  5. ↑ 1 2 David Flanagan. 3. Datatyper och värden // JavaScript. Detaljerad guide = JavaScript. The Definite Guide / Översatt av A. Kiselev. - 5:e uppl. - St Petersburg. : "Symbol-Plus" , 2008. - S.  39 -66. — ISBN 5-93286-103-7 .
  6. ↑ Jensen S., Møller A., ​​​​Thiemann P. Typanalys för JavaScript  //  Lecture Notes in Computer Science : Proceedings of Conf. / The 16th International Static Analysis Symposium (SAS 2009), Los Angeles, USA, 9 - 11 augusti 2009. - Springer Berlin / Heidelberg, 2009. - Vol. 5673 . - S. 238 - 255 . - ISBN 978-3-642-03236-3 .  (inte tillgänglig länk)
  7. ↑ Crockford D.A.3. Semikoloninsättning // JavaScript: De goda delarna. - 2008. - S. 102. - ISBN 978-0-596-51774-8 .
  8. ↑ Dr. Axel Rauschmayer. JavaScripts syntax // Talar JavaScript . - Första upplagan. - O'Reilly Media, 2014. - P. 378. - ISBN 978-1-449-36503-5 .
  9. ↑ Dr. Axel Rauschmayer. JavaScripts syntax // Talar JavaScript . - Första upplagan. - O'Reilly Media, 2014. - P. 41. - ISBN 978-1-449-36503-5 .
  10. ↑ 1 2 Crockford D. A.2. Omfattning // JavaScript: De goda delarna. - 2008. - P. 36. - ISBN 978-0-596-51774-8 .
  11. ↑ David Flanagan. 4.3.1. Inget blockomfång // JavaScript. Detaljerad guide = JavaScript. The Definite Guide / Översatt av A. Kiselev. - 5:e uppl. - St Petersburg. : "Symbol-Plus" , 2008. - S.  70 -71. — ISBN 5-93286-103-7 .
  12. ↑ 1 2 Soshnikov, Dmitry Subtiliteter ECMA-262-3. Del 2. Objekt av variabler. (27 juni 2009). Hämtad 6 november 2009. Arkiverad från originalet 18 februari 2012.
  13. ↑ David Flanagan. 4.2. Deklarera variabler // JavaScript. Detaljerad guide = JavaScript. The Definite Guide / Översatt av A. Kiselev. - 5:e uppl. - St Petersburg. : "Symbol-Plus" , 2008. - S.  68 . — ISBN 5-93286-103-7 .
  14. ↑ Peter-Paul Koch. Implicit variabeldeklaration // ppk på JavaScript / Redaktör: Wendy Sharp. — 1:a uppl. - New Riders Press, 2006. - 528 sid. - ISBN 978-0-321-42330-6 .
  15. ↑ Zakas N. Variables // Professionell JavaScript för webbutvecklare. — 2:a uppl. - USA, Kanada: Wiley Publishing, Inc, 2009. - P. 26, 27. - ISBN 978-0-470-22780-0 .
  16. ↑ Souders S. Använd lokala variabler // Even Faster Web Sites: Performance Best Practices for Web Developers. — 1:a uppl. - USA: O'Reilly Media, 2009. - S. 81-83. — ISBN 0596522304 .
  17. ↑ Easttom C. Variable Declaration // Advanced Javascript. — 3:e uppl. - USA: Wordware Publishing, Inc., 2008. - 81 - 83 sid. — ISBN 1-59822-033-0 .
  18. ↑ Keith J. Variables // DOM-skript: webbdesign med JavaScript och dokumentobjektmodellen. — 1:a uppl. - USA: Wordware Publishing, Inc., 2005. - 18 - 20 sid. — ISBN 1590595335 .
  19. ↑ Peter-Paul Koch. Kapitel 5 Kärna. Avsnitt D. Variabler // ppk på JavaScript / Redaktör: Wendy Sharp. — 1:a uppl. - New Riders Press, 2006. - 528 sid. - ISBN 978-0-321-42330-6 .
  20. ↑ Crockford D.A.4. Reserverade ord // JavaScript: De goda delarna. - 2008. - 170 sid. - ISBN 978-0-596-51774-8 .
  21. ↑ David Flanagan. 5.2. Operatörsöversikt // JavaScript. Detaljerad guide = JavaScript. The Definite Guide / Översatt av A. Kiselev. - 5:e uppl. - St Petersburg. : "Symbol-Plus" , 2008. - S.  78 -79. — ISBN 5-93286-103-7 .
  22. ↑ David Flanagan. 5.2.4 Operatörsassociativitet // JavaScript. Detaljerad guide = JavaScript. The Definite Guide / Översatt av A. Kiselev. - 5:e uppl. - St Petersburg. : "Symbol-Plus" , 2008. - S.  81 . — ISBN 5-93286-103-7 .
  23. ↑ David Flanagan. 5.2.1 Antal operander // JavaScript. Detaljerad guide = JavaScript. The Definite Guide / Översatt av A. Kiselev. - 5:e uppl. - St Petersburg. : "Symbol-Plus" , 2008. - S.  79 . — ISBN 5-93286-103-7 .
  24. ↑ David Flanagan. 5.10.8 Funktionsanropsoperatör // JavaScript. Detaljerad guide = JavaScript. The Definite Guide / Översatt av A. Kiselev. - 5:e uppl. - St Petersburg. : "Symbol-Plus" , 2008. - S.  98 . — ISBN 5-93286-103-7 .
  25. ↑ David Flanagan. 5.2.2 Typ av operander // JavaScript. Detaljerad guide = JavaScript. The Definite Guide / Översatt av A. Kiselev. - 5:e uppl. - St Petersburg. : "Symbol-Plus" , 2008. - S.  80 . — ISBN 5-93286-103-7 .
  26. ↑ Crockford D.A.13. hasOwnProperty // JavaScript: De goda delarna. - 2008. - S. 107. - ISBN 978-0-596-51774-8 .
  27. ↑ Crockford D.A.8. + // JavaScript: De goda delarna. - 2008. - 170 sid. - ISBN 978-0-596-51774-8 .
  28. ↑ Crockford D.B.12. void // JavaScript: The Good Parts. - 2008. - 170 sid. - ISBN 978-0-596-51774-8 .
  29. ↑ Crockford D.B.1. == // JavaScript: De goda delarna. - 2008. - 170 sid. - ISBN 978-0-596-51774-8 .
  30. ↑ 1 2 Crockford D. 4.1. Funktionsobjekt // JavaScript: De goda delarna. - 2008. - P. 26. - ISBN 978-0-596-51774-8 .
  31. ↑ 1 2 3 4 Zakas N. Funktionstypen // Professionell JavaScript för webbutvecklare. — 2:a uppl. - USA, Kanada: Wiley Publishing, Inc, 2009. - S. 122-130. - ISBN 978-0-470-22780-0 .
  32. ↑ Soshnikov, Dmitry Subtiliteter ECMA-262-3. Del 1. Utförandesammanhang. (26 juni 2009). Hämtad 12 oktober 2010. Arkiverad från originalet 16 oktober 2010.
  33. ↑ Juriy "kangax" Zaytsev. Namngivna funktionsuttryck avmystifierade  (engelska)  (länken är nere) . — En artikel som beskriver skillnaden mellan att definiera en funktion med en deklaration och att definiera en funktion med ett uttryck. Hämtad 19 oktober 2009. Arkiverad från originalet 19 juni 2009.
  34. ↑ Maian et al. Villkorligt definiera en funktion  (engelska)  (länk ej tillgänglig) . Funktioner och funktionsomfång . — Beskrivning av genomförandedetaljerna för funktioner som uttryck i samband med deklarationer inom villkor. Hämtad 19 oktober 2009. Arkiverad från originalet 14 oktober 2008.
  35. ↑ Crockford D. 4.4. Argument // JavaScript: De goda delarna. - 2008. - P. 31. - ISBN 978-0-596-51774-8 .
  36. ↑ Crockford D. 4.8. Rekursion // JavaScript: De goda delarna. - 2008. - S. 35. - ISBN 978-0-596-51774-8 .
  37. ↑ 1 2 3 4 Stefanov S. Återuppringningsfunktioner // Objektorienterad JavaScript: Skapa skalbara, återanvändbara JavaScript-applikationer och bibliotek av hög kvalitet. — 1:a uppl. - Packt Publishing, 2008. - P. 73, 74. - ISBN 184719414.
  38. ↑ Crockford D. 4.11. Callbacks // JavaScript: The Good Parts. - 2008. - S. 40. - ISBN 978-0-596-51774-8 .
  39. ↑ 1 2 David Flanagan. 8.8. Funktionsomfång och stängningar // JavaScript. Detaljerad guide = JavaScript. The Definite Guide / Översatt av A. Kiselev. - 5:e uppl. - St Petersburg. : "Symbol-Plus" , 2008. - S.  156 -163. — ISBN 5-93286-103-7 .
  40. ↑ Crockford D. 4.10. Stängning // JavaScript: De goda delarna. - 2008. - 170 sid. - ISBN 978-0-596-51774-8 .
  41. ↑ Harmes R., Diaz D. Constants // Pro JavaScript™ Design Patterns. - USA: Apress, 2008. - P. 37, 38. - ISBN 1-59059-908-X .
  42. ↑ 1 2 3 4 Zakas N. RegExp-typen // Professionell JavaScript för webbutvecklare. — 2:a uppl. - USA, Kanada: Wiley Publishing, Inc, 2009. - S. 115-122. - ISBN 978-0-470-22780-0 .
  43. ↑ 1 2 3 4 Zakas N. Objekttypen // Professionell JavaScript för webbutvecklare. — 2:a uppl. - USA, Kanada: Wiley Publishing, Inc, 2009. - S. 40-41. - ISBN 978-0-470-22780-0 .
  44. ↑ Crockford D. JSON // JavaScript: De goda delarna. - 2008. - S. 136. - ISBN 978-0-596-51774-8 .
  45. ↑ 1 2 3 Zakas N. 6. Objektorienterad programmering // Professionell JavaScript för webbutvecklare. — 2:a uppl. - USA, Kanada: Wiley Publishing, Inc, 2009. - S. 151-182. - ISBN 978-0-470-22780-0 .
  46. ↑ Kuznetsov, Mikhail Implementeringsarv i distribuerade objektsystem . Förlaget "Öppna system" (11 december 2002). Hämtad 1 november 2009. Arkiverad från originalet 17 februari 2010.
  47. ↑ Stefanov S. Kapitel 6. Arv. Sammanfattning // Objektorienterad JavaScript: Skapa skalbara, återanvändbara högkvalitativa JavaScript-applikationer och -bibliotek. — 1:a uppl. - Packt Publishing, 2008. - S. 194-198. — ISBN 184719414.
  48. ↑ ECMAScript 6 . Hämtad 17 mars 2017. Arkiverad från originalet 20 december 2016.
  49. ↑ En introduktion till JS-iteratorer i ES6 . Hämtad 17 mars 2017. Arkiverad från originalet 10 juni 2017.
  50. ↑ ES6 Introduktion . Hämtad 17 mars 2017. Arkiverad från originalet 20 december 2016.
  51. ↑ ES6 pilfunktioner . Hämtad 17 mars 2017. Arkiverad från originalet 20 december 2016.

ECMAScript-standarder

ECMAScript-specifikationer

  1. ↑ Standard ECMA-262. 13:e upplagan . ecma-international.org (juni 2022).
  2. ↑ TC39. Kort historik // ECMAScript-språkspecifikation . — 5:e uppl. - 2009. Arkiverad kopia (otillgänglig länk) . Hämtad 8 december 2009. Arkiverad från originalet 12 april 2015. 
  3. ↑ 123 TC39 . _ 4.3. Definitioner // ECMAScript-språkspecifikation . — 5:e uppl. - 2009. - S. 4. Arkiverad kopia (otillgänglig länk) . Hämtad 11 november 2009. Arkiverad från originalet 12 april 2015.  
  4. ↑ TC39. 8.5. Nummertyp // ECMAScript-språkspecifikation . — 5:e uppl. - 2009. - S. 29. Arkiverad kopia (otillgänglig länk) . Hämtad 11 november 2009. Arkiverad från originalet 12 april 2015. 
  5. ↑ 1 2 3 4 TC39. 8. Typer // ECMAScript-språkspecifikation . — 3:e uppl. - 1999. - S. 24.
  6. ↑ 1 2 3 4 TC39. 8. Typer // 3:e upplagan, december 1999.pdf ECMAScript Language Specification . — 5:e uppl. - 2009. - S. 28.  (otillgänglig länk)
  7. ↑ TC39. 12. Uttalanden // ECMAScript-språkspecifikation . — 5:e uppl. - 2009. - S. 86-97. Arkiverad kopia (inte tillgänglig länk) . Hämtad 11 november 2009. Arkiverad från originalet 12 april 2015. 
  8. ↑ 1 2 3 4 TC39. 7.9. Automatisk semikoloninsättning // ECMAScript-språkspecifikation . — 5:e uppl. - 2009. - S. 25-28. Arkiverad kopia (inte tillgänglig länk) . Hämtad 11 november 2009. Arkiverad från originalet 12 april 2015. 
  9. ↑ TC39. 12. Uttalanden // ECMAScript-språkspecifikation . — 3:e uppl. - 1999. - S. 61-71. Arkiverad kopia (inte tillgänglig länk) . Hämtad 11 november 2009. Arkiverad från originalet 12 april 2015. 
  10. ↑ 123 TC39 . _ 12.2. Variable Statement // ECMAScript Language Specification . — 5:e uppl. - 2009. - S. 87, 88. Arkiverad kopia (otillgänglig länk) . Hämtad 11 november 2009. Arkiverad från originalet 12 april 2015.  
  11. ↑ TC39. 10.2.2. Eval Code // 3:e upplagan, december 1999.pdf ECMAScript Language Specification . — 3:e uppl. - 1999. - S. 39.  (otillgänglig länk)
  12. ↑ TC39. 7.6.1.1. Nyckelord // ECMAScript-språkspecifikation . — 5:e uppl. - 2009. - S. 18. Arkiverad kopia (otillgänglig länk) . Hämtad 11 november 2009. Arkiverad från originalet 12 april 2015. 
  13. ↑ TC39. 7.5.2. Nyckelord // 3:e upplagan, december 1999.pdf ECMAScript Language Specification . — 3:e uppl. - 1999. - S. 13-14.  (inte tillgänglig länk)
  14. ↑ 12 TC39 . 7.6.1. Reserverade ord // ECMAScript-språkspecifikation . — 5:e uppl. - 2009. - S. 18, 19. Arkiverad kopia (otillgänglig länk) . Hämtad 11 november 2009. Arkiverad från originalet 12 april 2015. 
  15. ↑ TC39. 7.5.3. Future Reserved Words // 3:e upplagan, december 1999.pdf ECMAScript Language Specification . — 3:e uppl. - 1999. - S. 15.  (otillgänglig länk)
  16. ↑ TC39. 11.4. Unary Operators // ECMAScript Language Specification . — 5:e uppl. - 2009. - S. 70-72. Arkiverad kopia (inte tillgänglig länk) . Hämtad 11 november 2009. Arkiverad från originalet 12 april 2015. 
  17. ↑ TC39. 11.6.1 Tilläggsoperatorn (+) // ECMAScript Language Specification . — 5:e uppl. - 2009. - S. 74, 75. Arkiverad kopia (otillgänglig länk) . Hämtad 11 november 2009. Arkiverad från originalet 12 april 2015. 
  18. ↑ TC39. 11.9.3. The Abstract Equality Comparison Algorithm // ECMAScript-språkspecifikation . — 5:e uppl. - 2009. - S. 80, 81. Arkiverad kopia (otillgänglig länk) . Hämtad 11 november 2009. Arkiverad från originalet 12 april 2015. 
  19. ↑ TC39. 4.3. Definitioner // ECMAScript-språkspecifikation . — 5:e uppl. - 2009. - S. 4-7. Arkiverad kopia (inte tillgänglig länk) . Hämtad 11 november 2009. Arkiverad från originalet 12 april 2015. 
  20. ↑ TC39. 13 Funktionsdefinition // ECMAScript-språkspecifikation . — 5:e uppl. - 2009. - S. 97, 98. Arkiverad kopia (otillgänglig länk) . Hämtad 11 november 2009. Arkiverad från originalet 12 april 2015. 
  21. ↑ TC39. 12.2 Variabelsats // ECMAScript-språkspecifikation . — 5:e uppl. - 2009. - S. 87, 88. Arkiverad kopia (otillgänglig länk) . Hämtad 11 november 2009. Arkiverad från originalet 12 april 2015. 
  22. ↑ 12 TC39 . 10.6. Argument Objekt // ECMAScript-språkspecifikation . — 5:e uppl. - 2009. - S. 60-62. Arkiverad kopia (inte tillgänglig länk) . Hämtad 11 november 2009. Arkiverad från originalet 12 april 2015. 
  23. ↑ 1 2 3 4 TC39. 15.10. RegExp-objekt (reguljärt uttryck) // ECMAScript-språkspecifikation . — 5:e uppl. - 2009. - S. 179-196. Arkiverad kopia (inte tillgänglig länk) . Hämtad 11 november 2009. Arkiverad från originalet 12 april 2015. 
  24. ↑ TC39. 4.2. Språköversikt // ECMAScript-språkspecifikation . — 5:e uppl. - 2009. - S. 2-4. Arkiverad kopia (inte tillgänglig länk) . Hämtad 11 november 2009. Arkiverad från originalet 12 april 2015. 
  25. ↑ TC39. 8.6.1. Egenskapsattribut // ECMAScript Language Specification . — 3:e uppl. - 1999. - S. 25, 26. Arkiverad kopia (otillgänglig länk) . Hämtad 11 november 2009. Arkiverad från originalet 12 april 2015. 
  26. ↑ TC39. Egenskaper för objektprototypobjektet // ECMAScript-språkspecifikation . — 5:e uppl. - 2009. - S. 114-116. Arkiverad kopia (inte tillgänglig länk) . Hämtad 11 november 2009. Arkiverad från originalet 12 april 2015. 

Kommentarer

  1. ↑ Endast för att göra-under tiden
  2. ↑ Ett enda omvänt snedstreck undkommer strängmetatecken (till exempel \t). Ett dubbelt omvänt snedstreck används för att undkomma reguljära uttrycksmetatecken (till exempel \\s)

JavaScript-kodningsstandarder

  1. ↑ 1 2 3 Crockford, Douglas Kodkonventioner för programmeringsspråket JavaScript  . Douglas Crockfords JavaScript . Douglas Crockfords JavaScript-kodformateringsstandard. Hämtad 5 oktober 2009. Arkiverad från originalet 18 februari 2012.
  2. ↑ 1 2 JavaScript -kodkonventioner  . echo webbramverk . Next App, Inc. — En JavaScript-kodningsstandard antagen för Echo Web Framework. Hämtad 5 oktober 2009. Arkiverad från originalet 18 februari 2012.
  3. ↑ Amaram, Rahul Javascript Naming Conventions , Coding Guidelines and Best Practices  . echo webbramverk . — Raoul Amarams JavaScript-kodformateringsstandard. Hämtad 5 oktober 2009. Arkiverad från originalet 18 februari 2012.
  4. ↑ 1 2 3 Komenda, Klaus JavaScript-kodningsriktlinjer och  standarder . Webbplats för den österrikiska webbutvecklaren Klaus Komend . — JavaScript-kodformateringsstandard av Klaus Komend. Hämtad 5 oktober 2009. Arkiverad från originalet 18 februari 2012.
  5. ↑ JavaScript  -kodningsstil . tomte. — GNOME JavaScript-kodningsstandard. Datum för åtkomst: 24 december 2009. Arkiverad från originalet den 18 februari 2012.

Länkar

 ECMAScript
Dialekter
Motorer
( jämförelse )
Ramar ,
bibliotek
JavaScript
( jämför )
klientsidan
serversidan
Bibliotek
( lista )
  • SWFObject
  • SWFAddress
ActionScriptPureMVC
Flera
implementeringar
människor
Övrig
 Ecma internationella standarder