ECMAScript

Den aktuelle version af siden er endnu ikke blevet gennemgået af erfarne bidragydere og kan afvige væsentligt fra den version , der blev gennemgået den 15. juni 2022; checks kræver 2 redigeringer .
ECMAScript
Sprog klasse Specifikation for programmeringssprog , funktionelt programmeringssprog og multiparadigme programmeringssprog
Dukkede op i juni 1997
Forfatter Brendan Eich og Ecma International
Udvikler Brendan Eich
Filtypenavn _ .es[2]
Frigøre ECMAScript 2022 [Spec 1]  (juni 2022 ) ( 2022-06 )
Type system and
Dialekter JavaScript , JScript , ActionScript , JScript.NET , QtScript
Blev påvirket Self [1] , C , Scheme [1] , Perl [1] , Python , Java [1] , AWK [1]
påvirket Mål-J
Internet side ecma-international.org _ 

ECMAScript  er et integreret, udvidbart, I/O -løst programmeringssprog, der bruges som grundlag for at bygge andre scriptsprog [3] .

ECMAScript er standardiseret af den internationale organisation ECMA i ECMA-262- specifikationen . Sprogudvidelser: JavaScript , JScript og ActionScript .

Historie

Sproget stammer fra flere teknologier, hvoraf de mest berømte er JavaScript- og JScript -sprogene . Udviklingen af ​​den første revision af specifikationen begyndte i november 1996. Specifikationen blev vedtaget i juni 1997. Indsendt til ISO/IEC JTC 1 for Fast-Tracking- accept tjente det som grundlag for den internationale standard ISO/IEC 16262 . I juni 1998 vedtog ECMAs generalforsamling den anden udgave af ECMA-262, svarende til ISO/IEC 16262. Den tredje udgave af specifikationen adskilte sig fra den forrige ved at introducere understøttelse af regulære udtryk, forbedre strengunderstøttelse, introducere nye kontrolstrukturer , en undtagelsesmekanisme, formatering ved numerisk input og nogle andre ændringer[Specifikation 2] .

Semantik og syntaks

Datatyper

Fem primitive datatyper understøttes i ECMAScript :

Den numeriske datatype i ECMAScript svarer til 64-bit flydende talformatet defineret af IEEE 754-2008 standarden , bortset fra at de forskellige Not-a-Number værdier defineret i standarden [4] er repræsenteret på det sprog ved den enkelte specielle værdi NaN [ Specifikation 4] .

Nul og udefinerede datatyper omtales uformelt som "trivielle" typer af David Flanagan , da hver af dem kun definerer én værdi [5] .

Sproget har også en "sammensat" datatype [5] :

Ud over de seks anførte datatyper understøtter ECMAScript yderligere syv, der udelukkende bruges til at gemme mellemresultater af evaluerede udtryk:

Populariteten af ​​JavaScript-sproget og ikke-trivialiteten ved at behandle data af forskellige typer førte til udbredelsen af ​​akademisk forskning inden for parsing af ECMAScript-datatyper, som har til formål at skabe en fuldgyldig kodeanalysator, der kunne bruges i integreret udvikling miljøer [6] .

Instruktioner

Der er femten forskellige slags instruktioner i ECMAScript, som er angivet i tabellen nedenfor:

Instruktionstyper defineret af sprogspecifikationen [Specifikation 7]
Navn oprindelige navn Kort information Finale ; [Specifikation 8]
Blok engelsk  blok {[<instruktioner>]} −
Variabel erklæring engelsk  Variable Statement var <liste over variabeldeklarationer> +
Tom instruktion engelsk  EmptyStatement ; +
Udtryk engelsk  ExpressionStatement [streng til ∉ {{, funktion}] sætning +
Tilstand engelsk  IfStatement if (<инструкция>) <выражение>[ else <выражение>] −
Cyklus engelsk  Iteration Statement lav <udtryk> mens (<udsagn>)

mens (<udsagn>) <udtryk>
for ([<udsagn før start>]; [<udsagn>]; [<udsagn>]) <udtryk>
for (<variabelerklæring>; [<udsagn>]; [<udsagn>] >]) <udtryk>
for (<lværdi-udtryk> i <udsagn>) <udtryk>
for (<variabelerklæring> i <udsagn>) <udtryk>

+/− [~1]
Fortsættelse engelsk  Fortsæt Statement fortsæt [<identifikator>] +
Afbryde engelsk  BreakStatement bryde [<identifikator>] +
Vend tilbage engelsk  Returerklæring returner [<instruktion>] +
Kombination engelsk  WithStatement med (<udsagn>) <udtryk> −
Etiket engelsk  Mærket Statement <identifikator>: <udtryk> −
Valg engelsk  SwitchStatement switch (<udsagn>) case <statement>: [<udtryk>][ case <statement>: [<udtryk>] ...] [standard: [<udtryk>]] −
At kaste en undtagelse engelsk  ThrowStatement smid <instruktion> +
prøv at blokere engelsk  TryStatement prøv <blok> catch (<identifikator>) <blok>
prøv <blok> til sidst <blok>
prøv <blok> catch (<identifikator>) <blok> til sidst <blok> 		−
(ny [Spec 9] ) Debugger engelsk  Debugger debugger −
Autofuldfør strenge med semikolon

På trods af det obligatoriske semikolon i de tilfælde, der er nævnt i fjerde kolonne, erklærer specifikationen en mekanisme til autofuldførelse af strenge med semikolon , hvilket fører til, at hvis der er et linjeskift, kan instruktionen før linjeskiftet udstyres med dette tegn [ Specifikation 8] , som er genstand for kritik [7] .

Instruktioner, der ændrer betydning, når du bruger en ny linje i [Specifikation 8]
  • Unær postfix ++
  • Unær postfix --
  • Fortsættelse
  • Afbryde
  • Vend tilbage
  • At kaste en undtagelse

Et eksempel på at ændre betydningen af ​​en instruktion

return { status : "complete" };

Her indeholder den fremhævede linje en instruktion, der er gyldig af sproget, og da en ny linje følger, udløses mekanismen til autofuldførelse af linjer med semikolon. I stedet for at funktionen, der indeholder ovenstående kode, returnerer et objekt med egenskaben som værdi status, vil den returnere undefined.

Selvom den bogstavelige form af et objekt ikke er en kodeblok, kan ensartede parenteser føre til fejl. Udvikling eller vedtagelse af en passende kodningsstandard kan reducere sandsynligheden for, at de opstår . Valget af indrykningsstil spiller en rolle . Især Allman- og Whitesmith-stilene , såvel som Horstman -stilen og GNU-stilen til JavaScript-kode, er forældet af de fleste retningslinjer [8] i modsætning til K&R , 1TBS , BSD KNF -stilene .

Autofuldførelsesfejl

Hvis udtrykket skrevet på næste linje syntaktisk kan være en fortsættelse af udtrykket på den foregående linje, virker mekanismen til autofuldførelse af linjer med semikolon ikke [9] .

func () [ 'h1' , 'h2' ]. forHver ( funktion ( t ) { handleTag ( t ) })

I dette eksempel fortolkes de firkantede parenteser på den anden linje som at henvise til et array-element returneret af func(). Kommaet i parentes behandles som den tilsvarende operator, der returnerer 'h2'. Så koden konverteres til følgende:

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

Det er sædvanligt i kodningsstandarder at kræve semikolon, selvom sprogets syntaks tillader dem at blive udeladt [Coding Standards 1] [Coding Standards 2] [Coding Standards 3] [Coding Standards 4] [Coding Standards 5] .

Blokke og omfang

Et andet træk ved ECMAScript i forhold til andre C-lignende sprog er, at i dette sprog danner blokke ikke et omfang . Variable deklarerede i en blok gælder for hele funktionen, der indeholder blokken [10] [11] .

I denne sektion af kode er variablen generklæret i de fremhævede linjer:

function foo ( ) { varsum = 0 ; for ( var i = 0 ; i < 42 ; i += 2 ) { var tmp = i + 2 ; sum += i * tmp ; } for ( var i = 1 ; i < 42 ; i += 2 ) { sum += i * i ; } advarsel ( tmp ); retursum ; _ } foo ();

Derudover er variablen tmp erklæret inde i den første af sløjfene (linje 4) lovlig at få adgang til uden for sløjfen (linje 10) i henhold til sprogets syntaks.

På grund af arten af ​​omfang og blokke anbefales det at deklarere variabler i begyndelsen af ​​funktioner for at opretholde kildekodekvaliteten [10] [Kodningsstandarder 1] [Kodningsstandarder 4] .

Variable erklæringer

Variabler defineres ved hjælp af nøgleord var, let, const. Når en variabel deklareres, placeres den i det omfang, der svarer til en varfunktion, og i tilfælde let, constaf en kodeblok. Hvis en variabel erklæres uden for funktioner, placeres den i det globale omfang. Oprettelse af en variabel sker, når kontrollen af ​​funktionen med dens erklæring modtages. Eller et program, hvis variablen er global. Når en variabel oprettes i ECMAScript, får den værdien undefined. Hvis en variabel erklæres med initialisering , sker initialisering ikke i det øjeblik, variablen oprettes, men når linjen med instruktionen var[Specifikation 10] udføres .

Når du fjerner kommentarer til den valgte linje, viser skærmen ikke nummer , men udefineret :

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

Når en variabel oprettes, erhverver den den interne egenskab {DontDelete} og kan ikke slettes ved hjælp af delete[Specifikation 10] -operatoren . Undtagelsen er variable erklæret i kontekst eval[12] [Specifikation 11] .

Mange kilder [13] [14] [15] [16] [17] [18] erklærer muligheden for implicit at erklære variable i ECMAScript, når der tildeles til en gyldig identifikator, der ikke er et formelt funktionsargument uden først at erklære med var. Men i sprogspecifikationens terminologi oprettes i dette tilfælde en egenskab for det globale objekt, ikke en variabel [12] [Specifikation 10] .

Ved at rette i kodningsstandarden behovet for at deklarere variabler, før de bruges [Coding Standards 1] [Coding Standards 4] (eller fikse behovet for at bruge navnerum for alle globale objekter [Coding Standards 2] ) undgår du subtile fejl, hvilket forhindrer faren for interaktion af identisk navngivne variable i forskellige dele af koden [19] .

Nøgleord og reserverede ord

Følgende ord er nøgleord på sproget og kan ikke bruges som identifikatorer [Spec 12] :

break do instans af typeof sag andet nyt var fange endelig returnere ugyldig fortsæt til skift mens debugger funktion dette med standard hvis kast slet i forsøget

Sammenlignet med den tredje udgave af specifikationen [Specifikation 13] tilføjede den femte udgave et nøgleord debuggermed den tilsvarende instruktion.

Følgende ord bruges som nøgleord i foreslåede udvidelser og er derfor forbeholdt muligheden for at tilpasse disse udvidelser [Specifikation 14] :

klasse enum strækker sig super const eksport import

Når du bruger streng tilstand, behandles følgende ord som reserveret til fremtidig brug [Spec 14] :

redskaber lade privat offentligt udbytte grænsefladepakke beskyttet statisk

I forhold til tredje udgave af sprogspecifikationen er antallet af ord, der er reserveret til fremtidig brug, således faldet markant. Tidligere var der 31 [Specifikation 15] , og tilstedeværelsen af ​​et stort antal søgeord og reserverede ord, hvoraf de fleste ikke bruges i sproget, blev kritiseret [20] .

Operatører

ECMAScript har både operatorer, der bruger nøgleord som navne, og operatorer, der bruger tegnsætningstegn som navne .

Klassifikation af operatører

I faldende rækkefølge kan ECMAScript-operatorer opdeles i følgende grupper:

  • .(egenskabsadgang), [](egenskabsadgang), ()(funktionskald), new(oprettelse af nyt objekt),
  • ++(tilvækst), --(dekrement), -(unær minus), +(unarær plus), ^(bitvist komplement), !(boolesk komplement), delete(slet egenskab), typeof(definer primitiv datatype), void(retur null),
  • *(multiplicere), /(dele), %(resten af ​​division),
  • +(addition), -(subtraktion), +(strengsammenkædning),
  • <<(venstre skift), >>(højre skift med fortegn bit forlængelse), >>>(højre skift med nul polstring),
  • <(mindre end), <=(mindre end eller lig med), >(større end), >=(større end eller lig med), instanceof(objekttypetest), in(egenskabstest),
  • ==(ligestillingstest), !=(ulige test), ===(identitetstest), !==(ikke-identitetstest),
  • &(bitvis konjunktion ),
  • ^(bitvis addition modulo 2 ),
  • |(bitvis disjunktion ),
  • &&(sammenhæng),
  • ||(adskillelse),
  • ?:( ternær betinget drift ),
  • =(opgave), *=, /=, +=, -=, <<=, >>=, >>>=, &=, ^=, |=(opgave med betjening),
  • ,(multiple computation) [21] .

Operatorerne ++, --, -, +, ~, !, delete, typeof, void, ?:, , , , , , , , , , , , , , , , =, *=, /=, +=, -=, <<=, >=, >>>=, &=, ^=, er højreassociative |=(det vil sige, at de a op b op csvarer til a op (b op c)). De resterende ECMAScript-operatorer efterlades associative [22] .

Efter arity er ECMAScript-operatorer opdelt i følgende grupper:

  • unær ( delete, void, typeof, ++, --, -(unær minus), +(unarær plus), ^, !, new) [Specifikation 16] ,
  • binær ( ., [], (), *, /, %, +(addition), ( -subtraktion), ( +strengsammenkædning) , <<, >>, >>>, <, <=, >, >=, instanceof, in, ==, !=, ===, !==, &, ^, |, &&, ||, =, *=, /=, +=, -=, <<=, >=, >>>=, ),&=^=|=,
  • ternær ( ?:) [23] ,
  • operatorer, der ikke har et fast antal operander ( ()) [24] .

I henhold til positionen af ​​tegnet for operationen i forhold til operanderne er ECMAScript-operatorer opdelt i følgende grupper:

  • præfiks (f.eks. new, ++(forhøjelse af præfiks),
  • infix (f.eks. +, -),
  • postfix (f.eks. ++(postfix increment), --(postfix decrement).

Operatører klassificeres også efter typen af ​​operander [25] og arten af ​​den udførte handling.

Funktioner i ECMAScript-sætninger

Der er ingen operator i ECMAScript, der giver dig mulighed for at kontrollere, om en egenskab hører direkte til et objekt eller er nedarvet. Denne kontrol udføres ved hjælp af hasOwnProperty(). På grund af det faktum, at denne metode ikke er en operatør, kan den overskrives af enhver anden egenskab [26] .

Operator +er den eneste aritmetiske operator i sproget, der er overbelastet for strengargumenter. Hvis mindst en af ​​operanderne er en streng, +fungerer den som en sammenkædning , ellers udfører den addition [27] [Specifikation 17] .

I modsætning til sprog, hvor void er en datatype, er det i ECMAScript en operator, der returnerer en værdi undefined[28] .

Operatøren ==kontrollerer for lighed i henhold til en algoritme bestående af 10 trin, hvilket i nogle tilfælde indebærer typekonvertering [Specifikation 18] , hvilket i sidste ende kan føre til ikke-oplagte resultater [29] .

Et eksempel på resultaterne af arbejdet ==(i alle de nævnte tilfælde vil værdien af ​​operatøren ===med de samme argumenter være false):

alarm ( "NaN" == NaN ); // falsk advarsel ( NaN == NaN ); // falsk advarsel ( sand == 1 ); // true alarm ( sand == 42 ); // falsk advarsel ( null == 0 ); // falsk advarsel ( 0 == "" ); // true advarsel ( "" == 0 ); // true advarsel ( "false" == falsk ); // falsk advarsel ( falsk == 0 ); // true advarsel ( udefineret == falsk ); // falsk advarsel ( null == falsk ); // falsk advarsel ( udefineret == null ); // true advarsel ( " \t\r\n " == 0 ); // rigtigt

Funktioner

Funktioner i ECMAScript er objekter [30] [31] . Konstruktøren, som de er oprettet med, er Function(). Funktioner, som alle andre objekter, kan lagres i variabler, objekter og arrays, kan overføres som argumenter til andre funktioner og kan returneres af funktioner. Funktioner, som alle andre objekter, kan have egenskaber. Et væsentligt specifikt træk ved funktioner er, at de kan kaldes [30] .

Definere funktioner

Der er to typer funktioner i ECMAScript:

  • interne funktioner (f.eks. parseInt),
  • funktioner defineret i programteksten.

Interne funktioner er indbyggede objekter (se nedenfor ), ikke nødvendigvis implementeret i ECMAScript [Specifikation 19] .

I programmets tekst kan en navngivet funktion i ECMAScript defineres på en af ​​følgende måder:

// funktionserklæring funktion sum ( arg1 , arg2 ) { return arg1 + arg2 ; } // definere en funktion ved hjælp af en sætning var sum2 = function ( arg1 , arg2 ) { return arg1 + arg2 ; }; // definere en funktion ved hjælp af objektnotation var sum3 = new Function ( "arg1" , "arg2" , "return arg1 + arg2;" );

Sidstnævnte metode er den mindst foretrukne, da det de facto handler om at definere en funktion ved hjælp af et udtryk, men samtidig genererer den en dobbeltfortolkning af koden (en yderligere fortolkning sker, når koden sendes til konstruktøren), hvilket kan påvirke ydeevnen negativt [31] .

De to første metoder giver en lignende, men ikke identisk effekt. For at gøre ondt værre kan den sætning, der bruges, når en funktion defineres, ligne en funktionsdeklaration: For det første kan nøgleordet functionefterfølges af en identifikator [Specifikation 20] , for det andet kan semikolon udelades på grund af strengfuldførelsesmekanismen semikolon [Specifikation 8] . Eksempel:

// funktionserklæring funktion sum ( arg1 , arg2 ) { return arg1 + arg2 ; } // definere en funktion ved hjælp af et udtryk var sum2 = funktion sum ( arg1 , arg2 ) { return arg1 + arg2 ; } funktionslinje () { }; // brug funktionserklæringen ( funktionslinje ( ){}) // brug den relevante instruktion

Den væsentligste forskel mellem at definere en funktion ved hjælp af en erklæring og at definere en funktion ved hjælp af et udtryk er, at i førstnævnte tilfælde sker oprettelsen af ​​en variabel og dens tildeling som værdien af ​​funktionen, før koden udføres, når man går ind i udførelseskonteksten . I det andet tilfælde modtager variablen værdien af ​​initializeren, når tildelingssætningen udføres. Når en variabel oprettes ved indtræden i en eksekveringskontekst, initialiseres den med værdien undefined[Spec 21] [32] (se Variable Declarations for detaljer ).

Et eksempel, der illustrerer forskellen i kodeudførelsesrækkefølge:

alarm ( sum ( 3 , 4 )); // 7: sumvariablen er allerede blevet oprettet på det tidspunkt, hvor denne linje udføres, og funktionen sum ( arg1 , arg2 ) er blevet tildelt den funktion sum ( arg1 , arg2 ) { return arg1 + arg2 ; } alarm ( sum2 ( 3 , 4 )); // fejl: variabel sum2 er allerede blevet oprettet på det tidspunkt, hvor denne linje udføres, men undefined er blevet tildelt den var sum2 = function ( arg1 , arg2 ) { return arg1 + arg2 ; };

Funktionserklæringer bør ikke bruges i betingede konstruktioner [33] , selvom Gecko-browsere vil håndtere dette intuitivt gennem den implementerede mekanisme af funktioner som instruktioner [34] .

Funktionstildelinger

Da funktioner i ECMAScript er objekter, dvs. de er af en referencedatatype , er funktionsidentifikatorer variabler, der gemmer en reference til funktionen. Dette kan illustreres med følgende kode:

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

I den fremhævede linje skal du være opmærksom på fraværet af funktionsopkaldsoperatøren ( ()) i højre side af opgaven. Hvis i stedet for sum blev angivet i denne linje sum(), ville variablen sum2 ikke blive tildelt en funktion, men resultatet af dens kald. En anden ting, der er værd at bemærke, er, at sum2 efter tildeling ikke peger på en kopi af funktionen, men på netop den funktion, som sum peger på .

Funktion overbelastning

I ECMAScript er funktionsoverbelastning ikke en egenskab ved sproget, men dets effekt opnås ved brug af andre mekanismer.

Et eksempel, der viser fraværet af funktionsoverbelastning:

function sum ( arg1 , arg2 ) { return arg1 + arg2 ; } function sum ( arg1 , arg2 , arg3 ) { return arg1 + arg2 + arg3 ; } alarm ( sum ( 3 , 4 )); // NaN- advarsel ( sum ( 3 , 4 , 5 )); // 12

Hvis flere funktioner med samme navn erklæres, overskriver senere erklæringer tidligere erklæringer [31] .

Effekten af ​​funktionsoverbelastning er dog opnåelig.

1. Tjek for udefineret. For at kontrollere, om det faktiske argument blev overført til funktionen, kan du kontrollere det formelle argument for identitet til værdien af undefined​​. For eksempel:

function sum ( arg1 , arg2 , arg3 ) { if ( arg3 !== udefineret ) { return arg1 + arg2 + arg3 ; } else { return arg1 + arg2 ; } } alarm ( sum ( 3 , 4 )); // 7 alarm ( sum ( 3 , 4 , 5 )); // 12

2. Skriv check. Derudover kan typeof, instanceof, constructorbruges til at finde ud af typen af ​​faktiske argumenter og tilpasse funktionsadfærden afhængigt af dem.

function sum ( arg1 , arg2 , arg3 ) { switch ( typeof arg3 ) { case "undefined" : returner arg1 + arg2 ; case "nummer" : returner arg1 + arg2 + arg3 ; standard : returner arg1 + arg2 + " (" + arg3 + ")" ; } } alarm ( sum ( 3 , 4 )); // 7 alarm ( sum ( 3 , 4 , 5 )); // 12 alarm ( sum ( 3 , 4 , "!" )); // "7(!)"

3. Adgang til data om argumenter. I ECMAScript-funktioner kan du få adgang til argumentdata ved hjælp af arguments[Specifikation 22] -objektet . Især giver det dig mulighed for at bruge indeksering til at få adgang til specifikke argumenter, der er bestået [31] [35] og en egenskab length, der gemmer antallet af argumenter, der faktisk er bestået, hvilket kan være nyttigt, når du anvender det generiske programmeringsparadigme .

funktion sum () { var res = 0 ; for ( var i = 0 ; i < argumenter . længde ; i ++ ) { res += argumenter [ i ]; } returnere res ; } alarm ( sum ( 3 , 4 )); // 7 alarm ( sum ( 3 , 4 , 5 )); // 12 alarm ( sum ( 3 , 4 , 5 , 7 , 9 )); // 28 Rekursion

ECMAScript-funktioner kan kaldes rekursivt. Når du definerer en funktion ved hjælp af en sætning uden at angive en identifikator efter nøgleordet functioninde i funktionen, kan du henvise til den ved at bruge callee-egenskaben for arguments[Specifikation 22] -objektet .

Et eksempel på rekursiv faktorberegning:

var factorial = funktion ( trin , res ) { res = res || 1 ; if ( trin < 2 ) { return res ; } returner argumenter . kaldet ( trin - 1 , trin * res ); }; alarm ( faktoriel ( 5 )); // 120

I øjeblikket implementerer ECMAScript ikke hale-rekursion , som bruges til at optimere rekursive opkald [36] .

Tilbagekald

I ECMAScript er en funktion et førsteklasses objekt og kan overføres som et argument til en anden funktion. Hvis det samtidig kaldes i den funktion, som det sendes til, så kaldes det en tilbagekaldsfunktion (eller tilbagekaldsfunktion ). Hvis den beståede funktion ikke har et navn, er det en anonym tilbagekaldsfunktion ( anonym tilbagekaldsfunktion ) [37] . De vigtigste grunde til at bruge tilbagekaldsfunktioner er:

  • undgå funktionsnavngivning, når du arbejder med det (hjælper med at reducere antallet af globale variabler) [37] ,
  • uddelegering af et funktionskald til en anden funktion (hjælper med at øge kodens udtryksevne) [37] ,
  • præstationsforøgelse [37] ,
  • forenkling af håndteringen af ​​korte begivenheder [38] .

Et eksempel på en funktion, der returnerer summen af ​​resultaterne af udførelse af den beståede funktion på argumenterne:

function sumOfResults ( tilbagekald ) { var result = 0 ; for ( var i = 1 ; i < argumenter . længde ; i ++ ) { resultat += tilbagekald ( argumenter [ i ]); } returner resultat ; } var square = function ( x ) { return x * x ; }; advarsel ( sumOfResults ( firkantet , 3 , 4 )); // 25 Lukninger

Funktioner i ECMAScript er i sagens natur leksikalsk scoped. Det betyder, at omfanget er defineret på det tidspunkt, hvor funktionen er defineret (i modsætning til dynamisk omfang, hvor omfanget er defineret på det tidspunkt, hvor funktionen kaldes) [39] .

Når en funktion erklæres, gemmes sekvensen af ​​indlejrede funktionsomfang som en del af funktionens tilstand. Det vil sige, at under programafvikling bevarer funktioner, der har adgang til lokale variabler for omsluttende funktioner, sådan adgang under hele programmets afvikling [39] .

Lukkemekanismen kan bruges til at begrænse synligheden af ​​variabler i en selvstændig sektion af programmet, så der ikke er navnekonflikter, når de deles med anden kode. For at gøre dette placeres koden i en anonym funktion, forsynet med en funktionsopkaldsoperatør.

( funktion () { // Afsnit af programmet, hvis adgang til variabler skal isoleres udefra. })();

I dette tilfælde bliver funktionerne defineret i programafsnittet indlejret i forhold til den tilføjede anonyme funktion, og det er muligt at få adgang til de lokale variabler for den anonyme funktion (som var globale før dens introduktion). De kan dog ikke tilgås uden for den anonyme funktion: Resultatet af funktionsudførelsen ignoreres.

Lukninger bruges ikke kun til at forbyde adgang til en række variabler, men også til at ændre sådan adgang. Dette opnås med funktioner, der returnerer andre funktioner. Et eksempel på en serienummergeneratorfunktion:

var unikt id = funktion () { var id = 0 ; return funktion () { return id ++ ; }; }(); var aValue = unikt id (); var anotherValue = unikt id ();

Ved at bruge en lukning er det kun den funktion, der blev tildelt til variablen uniqueId , der har adgang til id -variablen .

Karry eksempel :

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

Et eksempel på oprettelse af et objekt, der giver dig adgang til ejendommen udelukkende ved hjælp af dets metoder [40] :

var mitObjekt = funktion () { var værdi = 0 ; return { increment : function ( inc ) { value += typeof inc === 'tal' ? ink : 1 ; }, getValue : function ( ) { return value ; } } }(); advarsel ( myObject . værdi === udefineret ); // true alert ( myObject . getValue ()); // 0 mitObjekt . forøg ( 9 ) mitObject . inkrement ( 7 ) advarsel ( myObject . getValue ()); // 16

Ved at bruge dette trick kan du bruge en lukning til at efterligne konstanter [41] .

var getConstant = function () { var constants = { UPPER_BOUND : 100 , LOWER_BOUND : - 100 }; returner funktion ( konstantnavn ) { returner konstanter [ konstantnavn ]; }; }(); advarsel ( getConstant ( "LOWER_BOUND" )); // -100

Regulære udtryk

Syntaksen og funktionaliteten af ​​regulære udtryk i ECMAScript blev påvirket af Perl 5 [Spec 23] og tillader to slags syntaks: literal og object .

var literalWay = /mønster/flag; var objectWay = new RegExp ( mønster , flag );

I det første tilfælde er skabelonen ( pattern) og flagene ( flags) specificeret eksplicit uden yderligere redundante syntaktiske tegn: skråstreger tjener som deres separatorer . I det andet tilfælde skal skabelonen og flagene være variable, der indeholder strengværdier, eller direkte strengværdier. Den bogstavelige notation foretrækkes, fordi den ikke kræver dobbelt [~ 2] escape af regulære udtryks metategn, i modsætning til objektformen [42] .

Følgende symboler kan bruges som flag i ECMAScript:

Flag for regulære udtryk [42] [Spec 23]
Flag Beskrivelse
g g global tilstand: mønsteret anvendes på alle matches i strengen, det regulære udtryk stopper ikke efter det første match af mønsteret er fundet
i og store og små bogstaver - ignorering : Når der matches, ignoreres store og små bogstaver i mønstertegnene og strengene
m multi -line mode: en linje, der indeholder nye linjetegn , behandles som flere linjer adskilt af linefeed-tegn; regex virker på alle linjer

Hvert regulært udtryk er et objekt med følgende egenskaber:

Egenskaber for ECMAScript regulære udtryksobjekter [42] [Specifikation 23]
Ejendom Type Beskrivelse
global logisk viser om flaget er satg
ignoreCase logisk viser om flaget er sati
multiline logisk viser om flaget er satm
lastIndex numerisk matcher positionsnummeret i strengen, hvor mønstermatchet blev fundet som et resultat af den tidligere anvendelse af det regulære udtryk, eller 0, hvis det regulære udtryk ikke tidligere blev anvendt
source snor streng, der matcher det regulære udtryksmønster

Derudover er følgende metoder defineret for regulære udtryk:

Regulære udtryksobjektmetoder i ECMAScript [42] [Specifikation 23]
Metode returtype Beskrivelse
exec(handledString) objekt (array) ellernull danner et array af understrenge, der matcher det angivne mønster , under hensyntagen til de indstillede flag . nullhvis ingen understreng matcher mønsteret
test(handledString) logisk truehvis der er en snor der matcher mønsteret og falseandet

Objekter

Implementering på sproget

ECMAScript-objekter er uordnede samlinger af egenskaber , som hver har en eller flere attributter , der bestemmer, hvordan egenskaben kan bruges - hvis værdien af ​​ReadOnly-attributten f.eks. er sat til sand , vil ethvert forsøg ved at udføre ECMAScript-kode ændre værdien af ​​den ejendom vil fejle. . Egenskaber er beholdere , der indkapsler andre objekter, værdier af primitive typer og metoder [Specifikation 24] .

ECMAScript-objektegenskabsattributter [Spec 25]
Navn Beskrivelse
Læs kun Ejendommen er en skrivebeskyttet ejendom. Et forsøg på at ændre værdien af ​​denne ejendom, lavet i programmet, vil forblive forgæves. I nogle tilfælde ændres værdien af ​​en egenskab med ReadOnly-attributsættet på grund af handlingerne i sprogudvidelsesmiljøet, så ReadOnly skal ikke forstås som uforanderlig.
DontEnum Egenskaben er ikke opregnet efter sløjfefor-in
Slet ikke Forsøg på at fjerne denne egenskab vil blive ignoreret.
Indre Ejendommen er intern. Den har intet navn og kan ikke tilgås med accessorer . Adgang til disse egenskaber bestemmes af sprogimplementeringen.

ECMAScript-objekter er opdelt i grundlæggende (native) og udvidelses- (værts) objekter. Med base mener vi alle objekter, der er uafhængige af miljøet relateret til udvidelsen af ​​sproget. Nogle af de grundlæggende objekter er indbygget : eksisterer lige fra starten af ​​programmets udførelse. Andre kan blive oprettet, når programmet kører. Udvidelsesobjekter leveres af ECMAScript-udvidelsen, og for ECMAScript betyder det, at de er en del af Document Object Model eller Browser Object Model [Specifikation 3] .

Syntaks

Objekt og bogstavelige former kan bruges til at specificere objekter. Objektformen til at specificere et objekt har en syntaks, der ligner Java, men i modsætning til den skal parenteser i ECMAScript kun bruges, når argumenter sendes til en konstruktør [43] . Følgende poster er syntaktisk ækvivalente:

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

Den anden mulighed anbefales dog ikke [43] . Douglas Crockford anbefaler også at undgå den første mulighed, idet han foretrækker den bogstavelige form, som han anser for at være en stor fordel ved sproget [44] .

Sprogspecifikationen opererer med begrebet et objekts egenskab , og kalder en metode for en funktion, der bruges som en egenskab for et objekt [Specifikation 3] .

Hvert objekt i sproget har følgende egenskaber:

Egenskaber for ECMAScript-objekter [43]
Navn Kort beskrivelse
constructor Funktionen, der bruges til at oprette objektet (i eksemplerne ovenfor er det Object())
hasOwnProperty(ejendomsnavn) Angiver om den givne egenskab findes i objektet (ikke i dets prototype )
erPrototypeOf(objekt) Bestemmer om et objekt er i argumentobjektets prototypekæde
propertyIsEnumerable(ejendomsnavn) Angiver om egenskaben med det angivne navn er talbar i løkkenfor-in
toString() Returnerer strengrepræsentationen af ​​objektet
Værdi af() Returnerer denne værdi . Hvis objektet er resultatet af et kald til et udvidelsesobjekts konstruktør , er værdien valueOf()implementeringsafhængig [Spec 26] . Ofte er returværdien en primitiv typeværdi, der svarer til et objekt. Som regel er resultatet af denne metode det samme som resultatet af toString(). Objekter oprettet med en konstruktør Date() er et godt eksempel, hvor resultaterne af toString()og valueOf()ikke matcher [43] .

Objektegenskaber tilgås ved hjælp af punkt- og parentesnotation :

var obj = nyt objekt (); advarsel ( obj . constructor === obj [ "constructor" ]); // sand - brug punkt- og parentesnotation for at få adgang til egenskaben var foo = obj [ "toString" ]; // bruger parentesnotation til at gemme funktionen i en variabel var result = obj [ "toString" ](); // gemmer resultatet af funktionskaldet til en variabel advarsel ( foo ()); // visning af resultatet af at kalde den lagrede funktion på skærmen advarsel ( resultat ); varboo = obj . _ toString ; // lignende med punktnotation var res = obj . toString (); advarsel ( bøh ()); alarm ( res );

Nye egenskaber kan indstilles dynamisk.

varcountry = nyt objekt ( ); country [ "name" ] = "Rusland" ; // brug parentes notation land . grundår = 862 ; // brug punktnotation var country2 = { "name" : "Rusland" , "foundationYear" : 862 }; // brug bogstavelig form

Fremgangsmåder til at skabe objekter

Oprettelse af objekter på den måde, der er beskrevet i det foregående afsnit, kan være upraktisk på grund af behovet for at duplikere kode [45] . Hvis programmet manipulerer et stort antal objekter af samme type, har udvikleren mulighed for at vælge en af ​​de teknikker, der bruges i sproget [45] :

genstandsfabrik en funktion, der skaber et objekt og returnerer det som dets værdi, konstruktør en funktion, der bruger nøgleordet thistil at danne egenskaberne for det objekt, det opretter ved hjælp af operatoren new, prototype tilgang bruge egenskaben prototypeaf ​​en funktion til at vise objekters generelle egenskaber, blandet tilgang konstruktør-prototype brug af en konstruktør til at indstille egenskaber for objekter, der ikke er metoder, og en prototypetilgang til sæt metoder, dynamisk prototype metode at konkludere koden relateret til funktionen med at skabe objekter baseret på den blandede konstruktør-prototype tilgang til én funktion, hvilket sikrer, at prototypeegenskaber tildeles én gang, parasitisk konstruktørmetode brug newmed objektfabriksfunktion.

Der er ingen klasser i sproget , men de kan emuleres ved hjælp af konstruktører. Et eksempel på klasseemulering i ECMAScript:

function MyClass () { this . minVærdi1 = 1 ; dette . minVærdi2 = 2 ; } Min klasse . prototype . myMethod = function () { returner dette . minVærdi1 * dette . minVærdi2 ; } var mc = new MyClass (); mc . minVærdi1 = mc . minVærdi2 * 2 ; var i = mc . minmetode ();

Egenskaber ved arv i ECMAScript

For hver af objektets komponenter kan arv overvejes. Når man arver grænsefladen til en forælder uden at barnet bruger forfaderens funktionalitet, taler man om nedarvning af grænsefladen. Når det nedarves tilstand, arver det underordnede objekt datastrukturen for det forfaderlige objekt. Når vi nedarver funktionalitet, taler vi om arv sammen med grænsefladen og metodekoden. Dette medfører som udgangspunkt behov for at organisere statsarv, hvilket gør det rimeligt at kombinere statsarv og funktionsarv til gennemførelsesarv [46] .

Med hensyn til ECMAScript gælder kun grænsefladearv ikke, da funktioner i sproget ikke har signaturer [45] .

De muligheder, sproget giver for organisering af arv, kan f.eks. bedømmes ud fra den liste, som Stoyan Stefanov [47] har givet over tolv forskellige måder at organisere arv på.

ECMAScript 6

Vedtagelsen af ​​ES6 har elimineret mange klasser af JavaScript-problemer [48] [49] [50] [51] .

Noter

  1. ↑ 1 2 3 4 5 _ Axel Rauschmayer. The Nature of JavaScript // At tale JavaScript . — Første udgave. - O'Reilly Media, 2014. - S. 41. - ISBN 978-1-449-36503-5 .
  2. ↑ Scripting Media Type - 2006.
  3. ↑ Zakas N. ECMAScript // Professionel JavaScript for webudviklere. — 2. udg. - USA, Canada: Wiley Publishing, Inc., 2009. - S. 3-7. - ISBN 978-0-470-22780-0 .
  4. ↑ Aiken A., Applegate M., Bailey D. og andre. 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. Datatyper og værdier // JavaScript. Detaljeret vejledning = JavaScript. Den bestemte guide / Oversat af A. Kiselev. - 5. udg. - Sankt Petersborg. : "Symbol-Plus" , 2008. - S.  39 -66. — ISBN 5-93286-103-7 .
  6. ↑ Jensen S., Møller A., ​​​​Thiemann P. Typeanalyse for JavaScript  //  Lecture Notes in Computer Science : Proceedings of Conf. / The 16th International Static Analysis Symposium (SAS 2009), Los Angeles, USA, 9. - 11. august 2009. - Springer Berlin / Heidelberg, 2009. - Vol. 5673 . - S. 238 - 255 . - ISBN 978-3-642-03236-3 .  (utilgængeligt link)
  7. ↑ Crockford D.A.3. Semikolonindsættelse // JavaScript: De gode dele. - 2008. - S. 102. - ISBN 978-0-596-51774-8 .
  8. ↑ Dr. Axel Rauschmayer. JavaScripts syntaks // Taler JavaScript . — Første udgave. - O'Reilly Media, 2014. - S. 378. - ISBN 978-1-449-36503-5 .
  9. ↑ Dr. Axel Rauschmayer. JavaScripts syntaks // Taler JavaScript . — Første udgave. - O'Reilly Media, 2014. - S. 41. - ISBN 978-1-449-36503-5 .
  10. ↑ 1 2 Crockford D. A.2. Omfang // JavaScript: De gode dele. - 2008. - S. 36. - ISBN 978-0-596-51774-8 .
  11. ↑ David Flanagan. 4.3.1. Intet blokeringsområde // JavaScript. Detaljeret vejledning = JavaScript. Den bestemte guide / Oversat af A. Kiselev. - 5. udg. - Sankt Petersborg. : "Symbol-Plus" , 2008. - S.  70 -71. — ISBN 5-93286-103-7 .
  12. ↑ 1 2 Soshnikov, Dmitry Subtiliteter ECMA-262-3. Del 2. Objekt af variable. (27. juni 2009). Hentet 6. november 2009. Arkiveret fra originalen 18. februar 2012.
  13. ↑ David Flanagan. 4.2. Erklæring af variabler // JavaScript. Detaljeret vejledning = JavaScript. Den bestemte guide / Oversat af A. Kiselev. - 5. udg. - Sankt Petersborg. : "Symbol-Plus" , 2008. - S.  68 . — ISBN 5-93286-103-7 .
  14. ↑ Peter-Paul Koch. Implicit variabel erklæring // ppk på JavaScript / Redaktør: Wendy Sharp. — 1. udg. - New Riders Press, 2006. - 528 s. - ISBN 978-0-321-42330-6 .
  15. ↑ Zakas N. Variables // Professionel JavaScript for webudviklere. — 2. udg. - USA, Canada: Wiley Publishing, Inc., 2009. - S. 26, 27. - ISBN 978-0-470-22780-0 .
  16. ↑ Souders S. Brug lokale variabler // Even Faster Web Sites: Performance Best Practices for webudviklere. — 1. udg. - USA: O'Reilly Media, 2009. - S. 81-83. — ISBN 0596522304 .
  17. ↑ Easttom C. Variable Declaration // Advanced Javascript. — 3. udg. - USA: Wordware Publishing, Inc., 2008. - 81 - 83 s. — ISBN 1-59822-033-0 .
  18. ↑ Keith J. Variables // DOM Scripting: Webdesign med JavaScript og Document Object Model. — 1. udg. - USA: Wordware Publishing, Inc., 2005. - 18 - 20 s. — ISBN 1590595335 .
  19. ↑ Peter-Paul Koch. Kapitel 5 Kerne. Sektion D. Variabler // ppk om JavaScript / Redaktør: Wendy Sharp. — 1. udg. - New Riders Press, 2006. - 528 s. - ISBN 978-0-321-42330-6 .
  20. ↑ Crockford D.A.4. Reserverede ord // JavaScript: De gode dele. - 2008. - 170 s. - ISBN 978-0-596-51774-8 .
  21. ↑ David Flanagan. 5.2. Operatøroversigt // JavaScript. Detaljeret vejledning = JavaScript. Den bestemte guide / Oversat af A. Kiselev. - 5. udg. - Sankt Petersborg. : "Symbol-Plus" , 2008. - S.  78 -79. — ISBN 5-93286-103-7 .
  22. ↑ David Flanagan. 5.2.4 Operatørassociativitet // JavaScript. Detaljeret vejledning = JavaScript. Den bestemte guide / Oversat af A. Kiselev. - 5. udg. - Sankt Petersborg. : "Symbol-Plus" , 2008. - S.  81 . — ISBN 5-93286-103-7 .
  23. ↑ David Flanagan. 5.2.1 Antal operander // JavaScript. Detaljeret vejledning = JavaScript. Den bestemte guide / Oversat af A. Kiselev. - 5. udg. - Sankt Petersborg. : "Symbol-Plus" , 2008. - S.  79 . — ISBN 5-93286-103-7 .
  24. ↑ David Flanagan. 5.10.8 Funktionsopkaldsoperatør // JavaScript. Detaljeret vejledning = JavaScript. Den bestemte guide / Oversat af A. Kiselev. - 5. udg. - Sankt Petersborg. : "Symbol-Plus" , 2008. - S.  98 . — ISBN 5-93286-103-7 .
  25. ↑ David Flanagan. 5.2.2 Type operander // JavaScript. Detaljeret vejledning = JavaScript. Den bestemte guide / Oversat af A. Kiselev. - 5. udg. - Sankt Petersborg. : "Symbol-Plus" , 2008. - S.  80 . — ISBN 5-93286-103-7 .
  26. ↑ Crockford D.A.13. hasOwnProperty // JavaScript: De gode dele. - 2008. - S. 107. - ISBN 978-0-596-51774-8 .
  27. ↑ Crockford D.A.8. + // JavaScript: De gode dele. - 2008. - 170 s. - ISBN 978-0-596-51774-8 .
  28. ↑ Crockford D.B.12. void // JavaScript: De gode dele. - 2008. - 170 s. - ISBN 978-0-596-51774-8 .
  29. ↑ Crockford D.B.1. == // JavaScript: De gode dele. - 2008. - 170 s. - ISBN 978-0-596-51774-8 .
  30. ↑ 1 2 Crockford D. 4.1. Funktionsobjekter // JavaScript: De gode dele. - 2008. - S. 26. - ISBN 978-0-596-51774-8 .
  31. ↑ 1 2 3 4 Zakas N. Funktionstypen // Professionel JavaScript for webudviklere. — 2. udg. - USA, Canada: Wiley Publishing, Inc., 2009. - S. 122-130. - ISBN 978-0-470-22780-0 .
  32. ↑ Soshnikov, Dmitry Subtiliteter ECMA-262-3. Del 1. Udførelsessammenhænge. (26. juni 2009). Hentet 12. oktober 2010. Arkiveret fra originalen 16. oktober 2010.
  33. ↑ Juriy "kangax" Zaytsev. Navngivne funktionsudtryk afmystificeret  (engelsk)  (linket er nede) . — En artikel, der beskriver forskellen mellem at definere en funktion med en erklæring og at definere en funktion med et udtryk. Hentet 19. oktober 2009. Arkiveret fra originalen 19. juni 2009.
  34. ↑ Maian et al. Betinget definition af en funktion  (engelsk)  (link ikke tilgængeligt) . Funktioner og funktionsomfang . — Beskrivelse af implementeringsdetaljerne for funktioner som udtryk i forbindelse med erklæringer inden for betingelser. Hentet 19. oktober 2009. Arkiveret fra originalen 14. oktober 2008.
  35. ↑ Crockford D. 4.4. Argumenter // JavaScript: De gode dele. - 2008. - S. 31. - ISBN 978-0-596-51774-8 .
  36. ↑ Crockford D. 4.8. Rekursion // JavaScript: De gode dele. - 2008. - S. 35. - ISBN 978-0-596-51774-8 .
  37. ↑ 1 2 3 4 Stefanov S. Tilbagekaldsfunktioner // Objektorienteret JavaScript: Skab skalerbare, genanvendelige JavaScript-applikationer og -biblioteker af høj kvalitet. — 1. udg. - Packt Publishing, 2008. - S. 73, 74. - ISBN 184719414.
  38. ↑ Crockford D. 4.11. Tilbagekald // JavaScript: De gode dele. - 2008. - S. 40. - ISBN 978-0-596-51774-8 .
  39. ↑ 1 2 David Flanagan. 8.8. Funktionsomfang og lukninger // JavaScript. Detaljeret vejledning = JavaScript. Den bestemte guide / Oversat af A. Kiselev. - 5. udg. - Sankt Petersborg. : "Symbol-Plus" , 2008. - S.  156 -163. — ISBN 5-93286-103-7 .
  40. ↑ Crockford D. 4.10. Lukning // JavaScript: De gode dele. - 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. RegExp Type // Professionel JavaScript for webudviklere. — 2. udg. - USA, Canada: Wiley Publishing, Inc., 2009. - S. 115-122. - ISBN 978-0-470-22780-0 .
  43. ↑ 1 2 3 4 Zakas N. Objekttypen // Professionel JavaScript for webudviklere. — 2. udg. - USA, Canada: Wiley Publishing, Inc., 2009. - S. 40-41. - ISBN 978-0-470-22780-0 .
  44. ↑ Crockford D. JSON // JavaScript: De gode dele. - 2008. - S. 136. - ISBN 978-0-596-51774-8 .
  45. ↑ 1 2 3 Zakas N. 6. Objektorienteret programmering // Professionel JavaScript for webudviklere. — 2. udg. - USA, Canada: Wiley Publishing, Inc., 2009. - S. 151-182. - ISBN 978-0-470-22780-0 .
  46. ↑ Kuznetsov, Mikhail Implementation Inheritance in Distributed Object Systems . Forlaget "Åbne Systemer" (11. december 2002). Hentet 1. november 2009. Arkiveret fra originalen 17. februar 2010.
  47. ↑ Stefanov S. Kapitel 6. Arv. Resumé // Objektorienteret JavaScript: Skab skalerbare, genanvendelige JavaScript-applikationer og -biblioteker af høj kvalitet. — 1. udg. - Packt Publishing, 2008. - S. 194-198. — ISBN 184719414.
  48. ↑ ECMAScript 6 . Hentet 17. marts 2017. Arkiveret fra originalen 20. december 2016.
  49. ↑ En introduktion til JS iteratorer i ES6 . Hentet 17. marts 2017. Arkiveret fra originalen 10. juni 2017.
  50. ↑ ES6 Introduktion . Hentet 17. marts 2017. Arkiveret fra originalen 20. december 2016.
  51. ↑ ES6 pilefunktioner . Hentet 17. marts 2017. Arkiveret fra originalen 20. december 2016.

ECMAScript-standarder

ECMAScript-specifikationer

  1. ↑ Standard ECMA-262. 13. udgave . ecma-international.org (juni 2022).
  2. ↑ TC39. Kort historie // ECMAScript-sprogspecifikation . — 5. udg. - 2009. Arkiveret kopi (utilgængeligt link) . Hentet 8. december 2009. Arkiveret fra originalen 12. april 2015. 
  3. ↑ 123 TC39 . _ 4.3. Definitioner // ECMAScript-sprogspecifikation . — 5. udg. - 2009. - S. 4. Arkiveret kopi (utilgængeligt link) . Hentet 11. november 2009. Arkiveret fra originalen 12. april 2015.  
  4. ↑ TC39. 8.5. Nummertype // ECMAScript-sprogspecifikation . — 5. udg. - 2009. - S. 29. Arkiveret kopi (utilgængeligt link) . Hentet 11. november 2009. Arkiveret fra originalen 12. april 2015. 
  5. ↑ 1 2 3 4 TC39. 8. Typer // ECMAScript-sprogspecifikation . — 3. udg. - 1999. - S. 24.
  6. ↑ 1 2 3 4 TC39. 8. Typer // 3. udgave, december 1999.pdf ECMAScript-sprogspecifikation . — 5. udg. - 2009. - S. 28.  (utilgængeligt link)
  7. ↑ TC39. 12. Udsagn // ECMAScript-sprogspecifikation . — 5. udg. - 2009. - S. 86-97. Arkiveret kopi (ikke tilgængeligt link) . Hentet 11. november 2009. Arkiveret fra originalen 12. april 2015. 
  8. ↑ 1 2 3 4 TC39. 7.9. Automatisk semikolonindsættelse // ECMAScript-sprogspecifikation . — 5. udg. - 2009. - S. 25-28. Arkiveret kopi (ikke tilgængeligt link) . Hentet 11. november 2009. Arkiveret fra originalen 12. april 2015. 
  9. ↑ TC39. 12. Udsagn // ECMAScript-sprogspecifikation . — 3. udg. - 1999. - S. 61-71. Arkiveret kopi (ikke tilgængeligt link) . Hentet 11. november 2009. Arkiveret fra originalen 12. april 2015. 
  10. ↑ 123 TC39 . _ 12.2. Variable Statement // ECMAScript-sprogspecifikation . — 5. udg. - 2009. - S. 87, 88. Arkiveret kopi (utilgængeligt link) . Hentet 11. november 2009. Arkiveret fra originalen 12. april 2015.  
  11. ↑ TC39. 10.2.2. Eval Code // 3. udgave, december 1999.pdf ECMAScript-sprogspecifikation . — 3. udg. - 1999. - S. 39.  (utilgængeligt link)
  12. ↑ TC39. 7.6.1.1. Nøgleord // ECMAScript-sprogspecifikation . — 5. udg. - 2009. - S. 18. Arkiveret kopi (utilgængeligt link) . Hentet 11. november 2009. Arkiveret fra originalen 12. april 2015. 
  13. ↑ TC39. 7.5.2. Nøgleord // 3. udgave, december 1999.pdf ECMAScript-sprogspecifikation . — 3. udg. - 1999. - S. 13-14.  (utilgængeligt link)
  14. ↑ 12 TC39 . 7.6.1. Reserverede ord // ECMAScript-sprogspecifikation . — 5. udg. - 2009. - S. 18, 19. Arkiveret kopi (utilgængeligt link) . Hentet 11. november 2009. Arkiveret fra originalen 12. april 2015. 
  15. ↑ TC39. 7.5.3. Future Reserved Words // 3. udgave, december 1999.pdf ECMAScript-sprogspecifikation . — 3. udg. - 1999. - S. 15.  (utilgængeligt link)
  16. ↑ TC39. 11.4. Unary Operators // ECMAScript-sprogspecifikation . — 5. udg. - 2009. - S. 70-72. Arkiveret kopi (ikke tilgængeligt link) . Hentet 11. november 2009. Arkiveret fra originalen 12. april 2015. 
  17. ↑ TC39. 11.6.1 Tilføjelsesoperatoren (+) // ECMAScript-sprogspecifikation . — 5. udg. - 2009. - S. 74, 75. Arkiveret kopi (utilgængeligt link) . Hentet 11. november 2009. Arkiveret fra originalen 12. april 2015. 
  18. ↑ TC39. 11.9.3. Den abstrakte lighedssammenligningsalgoritme // ECMAScript-sprogspecifikation . — 5. udg. - 2009. - S. 80, 81. Arkiveret kopi (utilgængeligt link) . Hentet 11. november 2009. Arkiveret fra originalen 12. april 2015. 
  19. ↑ TC39. 4.3. Definitioner // ECMAScript-sprogspecifikation . — 5. udg. - 2009. - S. 4-7. Arkiveret kopi (ikke tilgængeligt link) . Hentet 11. november 2009. Arkiveret fra originalen 12. april 2015. 
  20. ↑ TC39. 13 Funktionsdefinition // ECMAScript-sprogspecifikation . — 5. udg. - 2009. - S. 97, 98. Arkiveret kopi (utilgængeligt link) . Hentet 11. november 2009. Arkiveret fra originalen 12. april 2015. 
  21. ↑ TC39. 12.2 Variabel erklæring // ECMAScript-sprogspecifikation . — 5. udg. - 2009. - S. 87, 88. Arkiveret kopi (utilgængeligt link) . Hentet 11. november 2009. Arkiveret fra originalen 12. april 2015. 
  22. ↑ 12 TC39 . 10.6. Argumenter Objekt // ECMAScript-sprogspecifikation . — 5. udg. - 2009. - S. 60-62. Arkiveret kopi (ikke tilgængeligt link) . Hentet 11. november 2009. Arkiveret fra originalen 12. april 2015. 
  23. ↑ 1 2 3 4 TC39. 15.10. RegExp (regulært udtryk)-objekter // ECMAScript-sprogspecifikation . — 5. udg. - 2009. - S. 179-196. Arkiveret kopi (ikke tilgængeligt link) . Hentet 11. november 2009. Arkiveret fra originalen 12. april 2015. 
  24. ↑ TC39. 4.2. Sprogoversigt // ECMAScript-sprogspecifikation . — 5. udg. - 2009. - S. 2-4. Arkiveret kopi (ikke tilgængeligt link) . Hentet 11. november 2009. Arkiveret fra originalen 12. april 2015. 
  25. ↑ TC39. 8.6.1. Egenskabsattributter // ECMAScript-sprogspecifikation . — 3. udg. - 1999. - S. 25, 26. Arkiveret kopi (utilgængeligt link) . Hentet 11. november 2009. Arkiveret fra originalen 12. april 2015. 
  26. ↑ TC39. Egenskaber for objektprototypeobjektet // ECMAScript-sprogspecifikation . — 5. udg. - 2009. - S. 114-116. Arkiveret kopi (ikke tilgængeligt link) . Hentet 11. november 2009. Arkiveret fra originalen 12. april 2015. 

Kommentarer

  1. ↑ Kun til gøre-mens
  2. ↑ En enkelt omvendt skråstreg undslipper strengmetategn (f.eks. \t). En dobbelt omvendt skråstreg bruges til at undslippe regulære udtryks metategn (f.eks. \\s)

JavaScript-kodningsstandarder

  1. ↑ 1 2 3 Crockford, Douglas Kodekonventioner for JavaScript-programmeringssproget  . Douglas Crockfords JavaScript . Douglas Crockfords JavaScript-kodeformateringsstandard. Hentet 5. oktober 2009. Arkiveret fra originalen 18. februar 2012.
  2. ↑ 1 2 JavaScript -kodekonventioner  . echo web framework . Næste App, Inc. — En JavaScript-kodningsstandard, der er vedtaget til Echo Web Framework. Hentet 5. oktober 2009. Arkiveret fra originalen 18. februar 2012.
  3. ↑ Amaram, Rahul Javascript -navnekonventioner, retningslinjer for kodning og bedste praksis  . echo web framework . — Raoul Amarams JavaScript-kodeformateringsstandard. Hentet 5. oktober 2009. Arkiveret fra originalen 18. februar 2012.
  4. ↑ 1 2 3 Komenda, Klaus JavaScript-kodningsretningslinjer og  -standarder . Siden for den østrigske webudvikler Klaus Komend . — JavaScript-kodeformateringsstandard af Klaus Komend. Hentet 5. oktober 2009. Arkiveret fra originalen 18. februar 2012.
  5. ↑ JavaScript - kodningsstil  . nisse. — GNOME JavaScript-kodningsstandarden. Dato for adgang: 24. december 2009. Arkiveret fra originalen 18. februar 2012.

Links

 ECMAScript
Dialekter
Motorer
( sammenligning )
Rammer ,
biblioteker
JavaScript
( sammenlign )
klientsiden
server-side
Biblioteker
( liste )
  • SWFObject
  • SWFA-adresse
ActionScriptPureMVC
Flere
implementeringer
Mennesker
Andet
 Ecma internationale standarder