ECMAScript: differenze tra le versioni
Contenuto cancellato Contenuto aggiunto
m corretto rilasciato |
|||
| (99 versioni intermedie di 38 utenti non mostrate) | |||
Riga 1:
{{Linguaggio di programmazione
|autore =
|data =
|utilizzo =
|paradigmi =
|tipizzazione =
}}
'''ECMAScript''' (o '''ES''') è la [[specifica tecnica]] di un [[linguaggio di scripting]], standardizzata e mantenuta da [[ECMA International]] nell''''ECMA-262''' ed ISO/IEC 16262. Le implementazioni più conosciute di questo linguaggio (spesso definite come dialetti) sono [[JavaScript]], [[JScript]] e [[ActionScript]] che sono entrati largamente in uso, inizialmente, come linguaggi [[lato client]] nello [[programmazione web|sviluppo web]].
== Storia ==
Le specifiche definite da ECMAScript sono delle specifiche standardizzate di un linguaggio sviluppato da [[Brendan Eich]] di [[Netscape]]. Inizialmente era chiamato "Mocha", più tardi LiveScript e solo in ultimo JavaScript.<ref>{{Cita web|cognome= Krill|nome= Paul|url= http://www.infoworld.com/article/2653798/application-development/javascript-creator-ponders-past--future.html|titolo= JavaScript creator ponders past, future | Developer World|editore= InfoWorld|data= 23 giugno 2008|accesso= 31 ottobre 2013}}</ref> Nel
Grazie all'enorme successo di JavaScript come linguaggio client-side, [[Microsoft]] sviluppò una versione differente ma compatibile del linguaggio chiamandolo [[JScript]] per evitare problemi di copyright. JScript implementava nuovi metodi per il calcolo della data per risolvere in parte i problemi dovuti all'anno 2000 che affliggevano JavaScript in quanto la classe Date era basata sull'omonima classe di Java.<ref>{{Cita web|url= http://weblogs.mozillazine.org/roadmap/archives/2008/04/popularity.html|urlarchivio= https://
Netscape consegnò JavaScript ad [[ECMA
Mentre sia JavaScript che JScript mirano ad essere compatibili con le specifiche ECMAScript, provvedono a fornire allo stesso tempo funzioni aggiuntive non descritte dallo standard ECMA.<ref>{{Cita web|url= http://javascript.about.com/od/reference/a/jscript.htm|titolo= JScript VS JavaScript|editore= About.com|data= 25 novembre 2015|accesso= 1 marzo 2016|dataarchivio= 26 novembre 2015|urlarchivio= https://web.archive.org/web/20151126040655/http://javascript.about.com/od/reference/a/jscript.htm|urlmorto= sì}}</ref>
=== Versioni ===
Sono state pubblicate finora 15 edizioni dell'ECMA-262. Dal 2015 la pubblicazione avviene con una cadenza annuale, per questo le edizioni hanno nel nome anche il riferimento all'anno di distribuzione sul mercato.
{| class="wikitable"
!Edizione
!Data di pubblicazione
!Nome
!Cambiamenti rispetto all'edizione precedente
!Redattore
|-
|1
|Giugno 1997<ref>{{Cita web|titolo=ECMA-262, 2nd edition|
ECMAScript® 1999 Language Specification|sito=ecma-international.org |url=https://www.ecma-international.org/wp-content/uploads/ECMA-262_1st_edition_june_1997.pdf|accesso=15 giugno 2022}}</ref>
|
|Prima edizione
|[[Guy L. Steele, Jr.]]
|-
|2
|Giugno 1998<ref>{{Cita web|titolo=ECMA-262, 2nd edition|
ECMAScript® 1999 Language Specification|sito=ecma-international.org |url=https://www.ecma-international.org/wp-content/uploads/ECMA-262_2nd_edition_august_1998.pdf|accesso=15 giugno 2022}}</ref>
|
|Cambi editoriali per mantenere le specifiche concordanti con l'ISO/IEC 16262
|[[Mike Cowlishaw]]
|-
|3
|Dicembre 1999<ref>{{Cita web|titolo=ECMA-262, 3th edition
ECMAScript® 1999 Language Specification|sito=ecma-international.org |url=https://www.ecma-international.org/wp-content/uploads/ECMA-262_3rd_edition_december_1999.pdf|accesso=15 giugno 2022}}</ref>
|
|Aggiunte le [[Espressione regolare|espressioni regolari]], miglior gestione delle stringhe, nuovi comandi di controllo, gestione del try/catch, formattazione per output numerici ed altri miglioramenti.
|Mike Cowlishaw
|-
|4
|Abbandonato
|
|La quarta edizione è stata abbandonata per delle diversità di idee a riguardo della complessità del linguaggio. Molte delle feature che furono proposte per la quarta versione sono state del tutto scartate mentre altre sono state riproposte nella versione 6.
|
Line 40 ⟶ 55:
|5
|Dicembre 2009
|
|Aggiunge lo "strict mode" inteso a provvedere un più completo controllo di errori e a scoraggiare gli sviluppatori ad incappare in errori. Chiarifica molte ambiguità introdotte nella terza versione. Aggiunge anche alcune feature come i getters e i setters, la libreria per il supporto a JSON e la reflection sulle proprietà degli oggetti.<ref>{{Cita web|url= https://www.youtube.com/watch?v=Kq4FpMe6cRs|titolo= Changes to JavaScript, Part 1: EcmaScript 5|editore= YouTube|data= 18 maggio 2009|accesso= 31 ottobre 2013}}</ref>
|[[Pratap Lakshman]], [[Allen Wirfs-Brock]]
|-
|5.1
|Giugno 2011
|
|Questa edizione è stata creata per allineare la precedente allo standard internazionale ISO/IEC 16262:2011.
|Pratap Lakshman, Allen Wirfs-Brock
|-
|6
|Giugno 2015<ref>[http://www.infoworld.com/article/2937716/javascript/its-official-ecmascript-6-is-approved.html It's official: ECMAScript 6 is approved | InfoWorld]</ref>
|ECMAScript 2015 (ES2015)
|La sesta edizione, conosciuta come ECMAScript 2015<ref>[https://www.ecma-international.org/ecma-262/6.0/ ECMAScript 2015 Language Specification – ECMA-262 6th Edition]</ref> ma anche come "Harmony", apporta modifiche sintattiche significative che aprono la porta ad applicazioni più complesse, includendo classi e moduli definendoli semanticamente come lo "strict mode" in ECMAScript 5. Altre nuove features sono diversi iteratori, for/of loop, Python-style generators e generator expression, arrow functions, binary data, typed arrays, collections (maps, sets e weak maps), promises, miglioramenti delle funzioni matematiche, reflection e proxies (metaprogrammazione per virtual objects).
|Allen Wirfs-Brock
|-
|7
|Giugno 2016
|ECMAScript 2016 (ES2016)
|La settima edizione, nota anche con il nome di ECMAScript 2016, è di fatto un assestamento dei cambiamenti introdotti nella precedente edizione. Introduce comunque due novità: l'operatore esponente (**) e Array.prototype.includes.
|Brian Terlson
|-
|8
|Giugno 2017
|ECMAScript 2017 (ES2017)
| vedi [[#ottava edizione|Ottava Edizione - ECMAScript 2017]]
|Brian Terlson
|-
|9
|Giugno 2018
|ECMAScript 2018 (ES2018)
| vedi [[#nona edizione|Nona Edizione - ECMAScript 2018]]
|Brian Terlson
|-
|10
|Giugno 2019
|ECMAScript 2019 (ES2019)
| vedi [[#decima edizione|Decima Edizione - ECMAScript 2019]]
|Brian Terlson, Bradley Farias, Jordan Harband
|-
|11
|Giugno 2020
|ECMAScript 2020 (ES2020)
|vedi [[#undicesima edizione|Undicesima Edizione - ECMAScript 2020]]
|Jordan Harband, Kevin Smith
|-
|12
| Giugno 2021
|ECMAScript 2021 (ES2021)
| vedi [[#dodicesima edizione|Dodicesima edizione - ECMAScript 2021]]
| Jordan Harband, Shu-yu Guo, Michael Ficarra, Kevin Gibbons
|-
|13
|Giugno 2022
|ECMAScript 2022 (ES2022)
|
|Shu-yu Guo, Michael Ficarra, Kevin Gibbons
|-
|14
|Giugno 2023
|ECMAScript 2023 (ES2023)
|
|Shu-yu Guo, Michael Ficarra, Kevin Gibbons
|-
|15
|Giugno 2024
|ECMAScript 2024 (ES2024)
|
|Shu-yu Guo, Michael Ficarra, Kevin Gibbons
|-
|16
|(in attesa)
|ECMAScript 2025 (ES2025)
|(in attesa)
|(in attesa)
|}
Nel
=== Quarta Edizione (abbandonata) ===
La quarta edizione proposta di ECMA-262 (ECMAScript 4 o ES4) sarebbe stata la prima major update di ECMAScript dalla terza edizione pubblicata nel 1999. L'uscita delle specifiche (insieme alle referenze per l'implementazione) era inizialmente prevista per ottobre 2009 ed infatti un'introduzione al linguaggio fu
Ad agosto 2008, fu presa la decisione di ridimensionare la quarta edizione di ECMAScript e accorparla al progetto ECMAScript Harmony. Le novità in discussione per Harmony erano:
* [[Classe (informatica)|classi]]
* un sistema di [[Programmazione modulare|modularizzazione]]
* annotazione di tipi opzionale e [[Sistema dei tipi|tipizzazione statica]], probabilmente usando un [[structural type system|sistema di tipi strutturale]]
* [[Generatore (programmazione)|generatori]] e [[Iteratore|iteratori]]
* [[assegnamento destrutturato]]
* [[Tipo di dato|tipi di dati]] algebrici
L'intento di queste caratteristiche era in parte quello di facilitare lo sviluppo di software complessi con grandi gruppi di lavoro alle spalle e di permettere di eliminare alcune caratteristiche dinamiche del linguaggio per migliorare le prestazioni. Per esempio, Tamarin (la macchina virtuale per [[ActionScript]] sviluppata e distribuita open source da Adobe) è dotata di compilazione JIT ([[Compilatore just-in-time|just-in-time]]).
Oltre all'introduzione di nuove features, nella quarta edizione fu proposto di correggere diversi bug dell'edizione precedente<ref>{{Cita web|autore= John Resig|url= http://ejohn.org/blog/bug-fixes-in-javascript-2/|titolo= John Resig – Bug Fixes in JavaScript 2|editore= Ejohn.org|data=|accesso= 31 ottobre 2013}}</ref><ref>{{Cita web|url= http://www.ecmascript.org/es4/spec/incompatibilities.pdf|titolo= Compatibility Between ES3 and Proposed ES4|editore= Ecmascript.org|accesso= 31 ottobre 2013|urlmorto= sì|urlarchivio= https://web.archive.org/web/20140724055116/http://www.ecmascript.org/es4/spec/incompatibilities.pdf|dataarchivio= 24 luglio 2014}}</ref>. Queste correzioni trovarono quindi posto nella quinta edizione
I lavori per quest'edizione iniziarono dopo aver completato le specifiche dell'edizione Compact Profile e continuarono approssimativamente per 18 mesi
Wilson asseriva che i cambiamenti proposti per il nuovo standard che non erano completamente retrocompatibili con le versioni precedenti del linguaggio avrebbero "rotto il web"<ref>{{Cita web|url=http://blogs.msdn.com/ie/archive/2007/10/30/ecmascript-3-and-beyond.aspx#5788577 |titolo=ECMAScript 3 and Beyond – IEBlog – Site Home – MSDN Blogs |editore=Blogs.msdn.com |data=30 ottobre 2007 |accesso=31 ottobre 2013}}</ref> e che chi si era opposto era stato messo in secondo piano<ref>{{Cita web|url=http://blogs.msdn.com/cwilso/archive/2007/10/31/what-i-think-about-es4.aspx |titolo=What I think about ES4. - Albatross! - Site Home – MSDN Blogs |editore=Blogs.msdn.com |data=31 ottobre 2007 |accesso=31 ottobre 2013}}</ref>. Eich rispose dando del bugiardo al suo detrattore e lo sfidò chiedendo pubblicamente di dimostrargli specifici esempi di incompatibilità<ref>{{Cita web |url=http://brendaneich.com/2007/10/open-letter-to-chris-wilson/ |titolo=Open letter to Chris Wilson |editore=Brendan Eich |data=31 ottobre 2007 |accesso=31 ottobre 2013 |urlarchivio=https://web.archive.org/web/20110916125711/http://brendaneich.com/2007/10/open-letter-to-chris-wilson/ |dataarchivio=16 settembre 2011 |urlmorto=sì }}</ref>.
=== Quinta Edizione ===
[[Yahoo!]], [[Microsoft]], [[Google]] e altri dissidenti della quarta edizione di ECMAScript formarono il loro "sottocomitato" per progettare un update di ECMAScript 3 un
Dopo il dibattito sopra descritto, entrambi i team di ES 3.1 ed ES 4 si accordarono con un compromesso: si sarebbe lavorato sulle due edizioni in parallelo e con i due team coordinati per essere sicuri che ES 3.1 sarebbe rimasto strettamente un sottoinsieme di ES 4 (sia nella semantica che nella sintassi).
Tuttavia, le differenti filosofie di sviluppo crearono ripetutamente incompatibilità tra i lavori dei due team e sembrava chiaro che i team che non erano d'accordo con l'ECMAscript 4 non l'avrebbero mai implementato. Dopo circa un anno dalla frattura sulla visione del futuro di ECMAScript, all'Ecma Technical Committee 39<ref>{{Cita web|url=https://www.ecma-international.org/technical-committees/tc39/?tab=general|titolo= Ecma Technical committee 39|||accesso=7 giugno 2022}}</ref>, nel luglio 2008, [[Brendan Eich]] annunciò che i due team riuscirono ad accordarsi in un percorso comune, essenzialmente allineato sullo sviluppo della 3.1, successivamente rinominato Quinta Edizione.
Nell'aprile 2009 venne pubblicato la bozza finale della quinta edizione e fu finalizzata la versione definitiva nel mese di dicembre<ref>{{Cita web|titolo=ECMA-262, 5th edition
ECMAScript® 2009 Language Specification|sito=ecma-international.org |url=https://www.ecma-international.org/wp-content/uploads/ECMA-262_5th_edition_december_2009.pdf|accesso=14 giugno 2022}}</ref>.
Nel giugno 2011 venne pubblicata la revisione 5.1<ref>{{Cita web|titolo=ECMA-262, 5.1 edition
ECMAScript® 2009 Language Specification|sito=ecma-international.org |url=https://www.ecma-international.org/wp-content/uploads/ECMA-262_5th_edition_december_2009.pdf|accesso=14 giugno 2022}}</ref>.
=== Sesta Edizione - ECMAScript 2015 ===
La sesta edizione, conosciuta inizialmente come ECMAScript (ES6) ma rinominata successivamente ECMAScript 2015 fu pronta nel 2015<ref>{{Cita web|titolo=ECMA-262, 6th edition, June 2015
ECMAScript® 2015 Language Specification|sito=ecma-international.org |url=https://262.ecma-international.org/6.0/|accesso=4 giugno 2022}}</ref>. Questa edizione portò importanti ampliamenti alla sintassi, pensati per rendere più agevole la scrittura di applicazioni complesse, tra cui le nuove dichiarazioni delle classi (<syntaxhighlight inline="" lang="javascript">class Foo { ... } </syntaxhighlight>) e i moduli attraverso le istruzioni <syntaxhighlight inline="" lang="javascript">import</syntaxhighlight> e <syntaxhighlight inline="" lang="javascript">export</syntaxhighlight>. Alcune altre novità sintattiche furono il nuovo iteratore <syntaxhighlight inline="" lang="javascript">for ... of</syntaxhighlight>, le [[Funzione a freccia|funzioni a freccia]] (<syntaxhighlight inline lang="javascript">() => {...} </syntaxhighlight>), i generatori in stile [[Python]], Le parole chiave <code>let</code> per dichiarare le variabili con [[Visibilità (programmazione)|visibilità]] locale e <code>const</code> dichiarare le costanti, dati binari, array tipizzati, nuove collections (maps, sets e WeakMap), [[Future (informatica)|promises]], miglioramenti a numeri e matematica, [[Riflessione (informatica)|reflection]], proxy e [[template string]].<ref>{{Cita news|url=http://www.wintellect.com/devcenter/nstieglitz/5-great-features-in-es6-harmony|titolo=5 Great Features in EcmaScript 6 (ES6 Harmony) - Wintellect|data=24 marzo 2014|opera=Wintellect|accesso=19 marzo 2018|lingua=en|pubblicazione=|urlarchivio=https://web.archive.org/web/20170722010519/http://www.wintellect.com/devcenter/nstieglitz/5-great-features-in-es6-harmony|dataarchivio=22 luglio 2017|urlmorto=sì}}</ref><ref>{{Cita news|url=https://www.smashingmagazine.com/2015/10/es6-whats-new-next-version-javascript/|titolo=ECMAScript 6 (ES6): What's New In The Next Version Of JavaScript|data=28 ottobre 2015|opera=Smashing Magazine|accesso=19 marzo 2018|lingua=en}}</ref>
=== Settima Edizione - ECMAScript 2016 ===
La settima edizione, ufficialmente ECMAScript 2016, fu pubblicata nel Giugno del 2016<ref name="ES2016">{{Cita web|titolo=ECMAScript 2016 Language Specification|url=http://www.ecma-international.org/ecma-262/7.0/index.html|data=June 2016|editore=[[ECMA International]]}}</ref>. Le maggiori novità includono il block-scoping per variabili e funzioni, gli assegnamenti destrutturati delle variabili, proper tail calls, operatore esponente (<code>**</code>) e le keyword <code>await</code>, <code>async</code> per la programmazione asincrona.
<ref name="ES2016"/><ref>{{Cita web|url=https://webkit.org/blog/6240/ecmascript-6-proper-tail-calls-in-webkit/|titolo=ECMAScript 6 Proper Tail Calls in WebKit|cognome=Saboff|nome=Michael|data=23 maggio 2016|sito=WebKit|accesso=11 aprile 2019}}</ref>
{{anchor|ottava edizione}}
=== Ottava Edizione - ECMAScript 2017 ===
L'ottava edizione, nota ufficialmente con il nome di ECMAScript 2017<ref>{{Cita web|titolo=ECMA-262, 8th edition, June 2017
ECMAScript® 2017 Language Specification|sito=ecma-international.org |url=https://262.ecma-international.org/8.0/|accesso=4 giugno 2022}}</ref>, è stata completata e pubblicata nel Giugno del 2017. Le nuove funzionalità proposte includono concurrency ed atomics, zero copy binary transfer, altri miglioramenti nell'ambito matematico, integrazione sintattica con le promise, observable streams, SIMD, migliore metaprogrammazione con le classi, overload degli operatori e molto altro.
{{anchor|nona edizione}}
=== Nona Edizione - ECMAScript 2018 ===
La nona edizione, nota come ECMAScript 2018 è stata pubblicata nel giugno del 2018<ref>{{Cita web|titolo=ECMA-262, 9th edition, June 2018
ECMAScript® 2018 Language Specification|sito=ecma-international.org |url=https://262.ecma-international.org/9.0/|accesso=2 giugno 2022}}</ref>. Vengono introdotte le iterazioni asincrone (<code>for await(i of var)</code>), le Promise ora hanno i metodi <code>then()</code>, <code>catch()</code> (se vanno in errore) e <code>finally()</code>, la [[spread syntax]] per i parametri delle funzioni (<code>function pippo(foo, ...bar)</code>). Corpose novità riguardano l'uso delle [[regular expression]]<ref>[https://www.sitepoint.com/es2018-whats-new/ What's New in ES2018 — SitePoint]</ref>.
{{anchor|decima edizione}}
=== Decima Edizione - ECMAScript 2019 ===
La decima edizione, chiamata ECMAScript 2019 è stata resa pubblica nel giugno 2019<ref>{{Cita web|titolo=ECMA-262, 10th edition, June 2019
ECMAScript® 2019 Language Specification|sito=ecma-international.org |url=https://262.ecma-international.org/10.0/|accesso=4 giugno 2022}}</ref>. Le maggiori novità riguardano i metodi <code>Array.flatMap()</code><ref>[https://2ality.com/2017/04/flatmap.html Functional pattern: flatMap]</ref> e <code>Object.fromEntries()</code><ref>[https://2ality.com/2019/01/object-from-entries.html ES proposal: `Object.fromEntries()`]</ref><ref>[http://www.ecma-international.org/ecma-262/10.0/index.html ECMAScript® 2019 Language Specification]</ref>.
{{anchor|undicesima edizione}}
=== Undicesima Edizione - ECMAScript 2020 ===
L'undicesima edizione, o ECMAScript 2020, è stata pubblicata nel giugno 2020<ref>{{Cita web|titolo=ECMA-262, 11th edition, June 2020
ECMAScript® 2020 Language Specification|sito=ecma-international.org |url=https://262.ecma-international.org/11.0/|accesso=4 giugno 2022}}</ref>. In aggiunta alle nuove funzioni, questa versione introduct un tipo primitivo <code>BigInt</code> per interi di dimensioni arbitrarie, [[Operatore di coalescenza nullo|l'operatore di coalescenza nullo]], e l'oggetto<code>this</code> globale .
I BigInt sono creati con il costruttore <code>BigInt</code>o con la sintassi <code>10n</code>, dove la "n" è posizionata dopo il letterale del numero. I BigInt consentono la rappresentazione e la manipolazione di interi che vanno oltre<code>Number.MAX_SAFE_INTEGER</code>, mentre i tipi Numbers sono rappresentati da un valore [[IEEE 754]] a precisione doppia da 64bit. Le funzioni incorporate in <code>Math</code> non sono compatibili con BigInts; per esempio l'esponenzianzione dei BigInt deve essere fatta con l'operatore <code>**</code> invece di <code>Math.pow</code>.
L'operatore di coalescenza nullo <code>??</code> restituisce l'operando di destra quando l'operando di sinistra è <code>null</code> o <code>undefined</code>. Questo è in contrasto con l'operatore <code>||</code> che restituirebbe <code>"string"</code> per tutti i valori <code>false</code> come quelli rappresentati di seguito:
undefined ?? "string" // -> "string"
null ?? "string" // "string"
false ?? "string" // -> false
NaN ?? "string" // -> NaN
La concatenazione opzionale rende possibile accedere alle proprietà annidate di un oggetto senza avere un controllo AND a ogni livello.
Un esempio è <code>const zipcode = person?.address?.zipcode</code>. Se una qualunque delle proprietà è non presente, <code>zipcode</code> sarà <code>undefined</code>.
{{anchor|dodicesima edizione}}
=== Dodicesima edizione – ECMAScript 2021 ===
La dodicesima edizione, o ECMAScript 2021, è stata pubblicata nel giugno 2021<ref>{{Cita web|titolo=ECMA-262, 12th edition, June 2021
ECMAScript® 2021 Language Specification|sito=ecma-international.org |url=https://262.ecma-international.org/12.0/|accesso=2 giugno 2022}}</ref>. Introduce il metodo <code>replaceAll</code> per le stringhe; la nuova combinazione di promise <code>Promise.any</code>, che esegue il codice non appena la prima delle ''promise'' restituisce un valore. Introdotto anche <code>AggregateError</code>, un nuovo tipo di errore che permette di rappresentare più errori in una volta.
Arrivano nuovi operatori logici di assegnazione: <code>??=</code>, <code>&&=</code>, <code>||=</code>; <code>WeakRef</code> crea una reference a un oggetto senza preservarlo dalla cancellazione del garbage collector e <code>FinalizationRegistry</code>, che permette l'esecuzione di una callback quando un oggetto target viene cancellato dal garbage collector; è ora possibile usare i separatori per i numeri: <code>1_000</code>.
== Conformità ==
Nel 2010, [[ECMA International]] iniziò lo sviluppo di un test per verificare la conformità allo standard ECMA 262 ECMAScript.
Chiamato Test262, questo test viene utilizzato per capire quanto le varie implementazioni di JavaScript siano conformi alle specifiche. Il test contiene migliaia di verifiche individuali, una per ogni requisito dei vari standard.
Lo sviluppo di Test262 è affidato all'ECMA Technical Committee 39 (TC39).
Google e Microsoft hanno contribuito in modo importante allo sviluppo: entrambe hanno sviluppato migliaia dei test eseguiti dalla suite.
Test262 consiste in {{val|38014}} test. Il dato è aggiornato a Gennaio 2020.<ref name="GitHub 2020">{{Cita web|titolo=tc39/test262 |sito=GitHub |data=24 gennaio 2020 |url=https://github.com/tc39/test262 |accesso=29 gennaio 2020}}</ref>.
Le tabelle sottostanti mostrano la conformità degli engine JavaScript nelle applicazioni più diffuse.
=== Browser web ===
{| class="wikitable sortable"
|- style="background:#ccf;"
! rowspan="2" | Engine
! rowspan="2" | Browser
! colspan="4" | Conformità
|-
! ES5<ref name="kangax5">{{Cita web|url=https://kangax.github.io/compat-table/es5|titolo=ECMAScript 5 compatibility table|sito=kangax.github.io|lingua=en|accesso=8 novembre 2018|dataarchivio=19 novembre 2018|urlarchivio=https://web.archive.org/web/20181119145151/http://kangax.github.io/compat-table/es5/|urlmorto=sì}}</ref>
! ES6<ref name="kangax6">{{Cita web|url=https://kangax.github.io/compat-table/es6|titolo=ECMAScript 6 compatibility table|sito=kangax.github.io|lingua=en|accesso=8 novembre 2018|dataarchivio=17 novembre 2018|urlarchivio=https://web.archive.org/web/20181117194027/http://kangax.github.io/compat-table/es6/|urlmorto=sì}}</ref>
! 2016+<ref name="kangax2016plus">{{Cita web|url=https://kangax.github.io/compat-table/es2016plus|titolo=ECMAScript 2016+ compatibility table|sito=kangax.github.io|lingua=en|accesso=8 novembre 2018|dataarchivio=24 novembre 2018|urlarchivio=https://web.archive.org/web/20181124112954/http://kangax.github.io/compat-table/es2016plus/|urlmorto=sì}}</ref><ref name="punteggio">Punteggio che racchiude tutti i test di conformità dalla ES2016 alla ES2019</ref>
|-
| [[V8 (
| [[Microsoft Edge]] 80
| 100% || 98% || 100%
|-
| [[SpiderMonkey]]
| [[Firefox]] 73
| 100% || 98% || 82%
|-
| [[V8 (motore JavaScript)|V8]]
| [[
| 100% || 98% || 100%
|-
| [[JavaScriptCore]] (Nitro)
| [[
| 99% || 99% || 80%
|}
=== Implementazioni lato server ===
{| class="wikitable sortable"
|- style="background:#ccf;"
! rowspan="2" | Engine
! rowspan="2" | Server
! colspan="4" | Conformità
|-
! ES5<ref name="kangax5"/>
! ES6<ref name="kangax6"/>
! 2016+<ref name="kangax2016plus"/><ref name="punteggio" />
|-
| [[V8 (motore JavaScript)|V8]]
| [[Node.js]] 13.2
| 100% || 98% || 92%
|}
==
<references/>
==Voci correlate==
* [[ActionScript]]
* [[DART (linguaggio)]]
* [[Document Object Model]]
* [[JavaScript]]
* [[JScript]]
* [[QML (linguaggio di programmazione)]]
* [[TypeScript]]
== Collegamenti esterni ==
* {{FOLDOC}}
* {{cita web|1=http://www.ecmascript.org/|2=Sito ufficiale - ECMAScript|lingua=en|accesso=1º marzo 2016|urlarchivio=http://arquivo.pt/wayback/20160518084505/http://www.ecmascript.org/|dataarchivio=18 maggio 2016|urlmorto=sì}}
{{Standard ISO}}
{{Norme IEC}}
{{portale|informatica}}
[[Categoria:Linguaggi di scripting]]
[[Categoria:XML DOM]]
[[Categoria:Standard Internet]]
[[Categoria:Standard ISO/IEC|16262]]
| |||