Guida ECMAScript 2026-27

Guida ECMAScript 2026-27

Cosa cambia davvero per chi scrive JavaScript ogni giorno

Oggi il motore che fa girare miliardi di pagine web e migliaia di backend Node.js sta cambiando ancora una volta, ma stavolta con qualche colpo di scena in più del solito. ECMAScript 2026 è ormai la diciassettesima edizione dello standard, ed è già affiancata dai primi cantieri aperti per la 2027. In questa guida vediamo cosa è arrivato davvero nella specifica ufficiale (tc39.es/ecma262), due esempi di codice pronti da copiare, le best practice per adottare le novità senza sorprese in produzione e un’anteprima di ciò che TC39 sta discutendo per il prossimo anno.

Indice dei contenuti – Guida ECMAScript 2026-27

1. Cos’è ECMAScript 2026 e perché conta ora

2. A cosa serve nella pratica: casi d’uso reali (e quando non conviene correre)

3. Le novità principali di ECMAScript 2026

4. Esempio pratico: cache e configurazioni con Map.getOrInsert (Upsert)

5. Esempio pratico: unire flussi di dati con Iterator.concat e Array.fromAsync

6. Best practice per adottare ECMAScript 2026 senza sorprese

7. ECMAScript 2027: cosa bolle in pentola in TC39

8. Conclusioni: la formazione continua come vantaggio competitivo

1. Cos’è ECMAScript 2026 e perché conta ora

iniziamo subito la nostra Guida ECMAScript 2026-27. ECMAScript è il nome ufficiale dello standard dietro JavaScript, mantenuto dal comitato tecnico TC39 di Ecma International, lo stesso gruppo che riunisce i rappresentanti di Google, Mozilla, Apple, Microsoft e molte altre aziende che sviluppano motori JavaScript. Dal 2015 (ES2015, la sesta edizione) lo standard esce con cadenza annuale: ogni proposta di nuova funzionalità attraversa cinque stadi, da 0 (idea informale) a 4 (finita, pronta per essere inclusa nello standard). ECMAScript 2026 è la diciassettesima edizione e rappresenta il punto in cui tutte le proposte arrivate a stadio 4 entro marzo 2026 sono state congelate nella bozza definitiva.

Una cosa che pochi sanno, e che vale la pena chiarire subito: la pagina https://tc39.es/ecma262/ non è un documento statico pubblicato una volta l’anno, ma un documento vivo che riflette in ogni momento l’ultima istantanea annuale più tutte le proposte che nel frattempo hanno raggiunto lo stadio 4. La versione bloccata e numerata per il 2026, che potete consultare su https://tc39.es/ecma262/2026/, è quella che verrà sottoposta all’assemblea generale Ecma per l’approvazione formale a luglio. Per chi scrive codice per mestiere, questo significa una cosa pratica: potete sapere con certezza, mese per mese, cosa sta per diventare standard, senza aspettare comunicati stampa.

Perché conta ora, nel luglio 2026? Perché i motori JavaScript (V8 di Chrome, SpiderMonkey di Firefox, JavaScriptCore di Safari) implementano le funzionalità appena raggiungono lo stadio 4, spesso mesi prima che l’edizione annuale venga pubblicata ufficialmente. Chi resta fermo alla sintassi che usava tre anni fa non perde solo qualche comodità: perde codice più leggibile, meno dipendenze da librerie esterne e, in alcuni casi, prestazioni migliori a parità di sforzo.

2. A cosa serve nella pratica: casi d’uso reali (e quando non conviene correre)

Immaginate il classico backend Node.js che gestisce una cache in memoria per le sessioni utente, oppure un frontend che deve normalizzare dati provenienti da tre API diverse, alcune sincrone e alcune asincrone. Sono esattamente gli scenari in cui le novità di ECMAScript 2026 tolgono righe di codice boilerplate e sostituiscono pattern scritti a mano con metodi nativi, testati e ottimizzati direttamente nel motore.

Casi d’uso in cui conviene aggiornare subito:

• Applicazioni Node.js o Deno moderne, dove il runtime è sotto il vostro controllo e potete scegliere la versione del motore.
• Librerie interne aziendali, dove non dovete garantire compatibilità con browser vecchi di anni.
• Progetti che già usano un transpiler (Babel, SWC) o un bundler moderno (Vite, esbuild), che possono applicare polyfill mirati senza sforzo.

Casi in cui conviene aspettare o verificare bene prima:

• Applicazioni pubbliche con un’utenza che include browser datati o dispositivi aziendali con policy di aggiornamento rigide.
• Codice distribuito come libreria pubblica su npm, dove ogni nuova sintassi alza la versione minima richiesta a chi vi usa.
• Ambienti embedded o IoT con motori JavaScript proprietari che seguono lo standard con anni di ritardo.

La regola pratica che consigliamo ai team con cui lavoriamo: controllate sempre la tabella di compatibilità (caniuse.com o il repository test262 di TC39, che è la suite di test ufficiale) prima di usare una funzionalità appena arrivata a stadio 4 in un prodotto rivolto al pubblico, e riservate le funzionalità più recenti al codice server-side dove controllate voi la versione del runtime.

3. Le novità principali di ECMAScript 2026

Entriamo nel vivo della nostra Guida ECMAScript 2026-27. Secondo l’elenco ufficiale delle proposte finite tenuto da TC39 (finished-proposals.md nel repository tc39/proposals), le funzionalità che risultano incluse nell’edizione 2026 sono queste sette. Le vediamo una per una, in ordine di impatto pratico quotidiano.

Upsert: Map.prototype.getOrInsert e getOrInsertComputed

Fino a oggi, il pattern “se la chiave esiste usa il valore, altrimenti creane uno e salvalo” richiedeva sempre tre passaggi: has(), get() o creazione, set(). Ora Map e WeakMap hanno due metodi nativi che fanno tutto in un colpo solo, atomicamente.

JSON.parse source text access

Quando il reviver di JSON.parse riceve una chiamata, ora può accedere anche al testo sorgente originale della porzione JSON appena analizzata, non solo al valore già convertito in oggetto JavaScript. Utile per librerie che devono preservare la precisione di numeri molto grandi o generare error report puntuali.

Iterator Sequencing: Iterator.concat

Un nuovo metodo statico che unisce più iterabili in sequenza, restituendo un iteratore unico e pigro (lazy), senza dover prima trasformare tutto in array con lo spread operator. Si integra con gli iterator helper già arrivati con ES2025 (map, filter, take, drop).

Array.fromAsync

L’equivalente asincrono di Array.from: converte un async iterable (o un iterable di promise) in un array, gestendo l’attesa internamente. Chiude un buco che chi lavora con stream e API paginate conosceva bene.

Error.isError

Un modo affidabile per verificare se un valore è davvero un’istanza di Error, anche quando arriva da un altro realm (un’altra finestra, un altro worker, un altro contesto di iframe), caso in cui instanceof Error può fallire silenziosamente.

Math.sumPrecise

Somma un array di numeri in virgola mobile riducendo al minimo gli errori di arrotondamento tipici di un ciclo con reduce. Pensato per calcoli scientifici e finanziari dove la precisione conta.

Uint8Array.fromBase64 / toBase64 / fromHex / toHex

Conversioni native tra byte array e stringhe Base64 o esadecimali, senza passare per btoa/atob (che hanno sempre avuto problemi con Unicode) o per librerie esterne.

Una nota che vale la pena di condividere perché racconta bene come funziona davvero il processo TC39: Temporal, la nuova API immutabile per data e ora destinata a sostituire il vecchio oggetto Date, ha raggiunto lo stadio 4 nella riunione di marzo 2026, insieme a Explicit Resource Management (le dichiarazioni using e await using), Atomics.pause e Joint Iteration. Al momento in cui scriviamo, il tracciamento ufficiale di TC39 le colloca nell’edizione attesa per il 2027 piuttosto che nel 2026, anche se, essendo già a stadio 4, i motori possono implementarle e molti lo stanno già facendo in anteprima. È un buon promemoria: “stadio 4” e “anno di pubblicazione formale” sono due concetti distinti, e chi segue solo i titoli dei blog rischia di confondersi.

4. Esempio pratico: cache e configurazioni con Map.getOrInsert (Upsert)

Scenario: un piccolo servizio interno che tiene in memoria le impostazioni di ciascun cliente, calcolandole al volo solo la prima volta che servono e poi riusandole. Prima di ECMAScript 2026, il codice tipico era così:

// Prima di ES2026: pattern manuale, tre operazioni separate const cacheImpostazioni = new Map();  function getImpostazioniCliente(idCliente) {   if (!cacheImpostazioni.has(idCliente)) {     const impostazioni = calcolaImpostazioniPesanti(idCliente); // operazione costosa     cacheImpostazioni.set(idCliente, impostazioni);   }   return cacheImpostazioni.get(idCliente); }

Con Upsert lo stesso comportamento si scrive in una riga, ed è anche più sicuro in scenari concorrenti perché l’operazione è atomica dal punto di vista del motore:

// Con ES2026: Map.prototype.getOrInsertComputed const cacheImpostazioni = new Map();  function getImpostazioniCliente(idCliente) {   // Se la chiave non esiste, calcola il valore con la callback e lo inserisce   return cacheImpostazioni.getOrInsertComputed(     idCliente,     () => calcolaImpostazioniPesanti(idCliente)   ); }  // Esiste anche la variante semplice per valori già pronti (non callback): // cacheImpostazioni.getOrInsert(idCliente, valoreDiDefault);

Il vantaggio non è solo estetico: getOrInsertComputed calcola il valore di default una sola volta, esattamente quando serve, ed evita la doppia interrogazione has/get che nel codice precedente eseguiva due lookup nella struttura dati invece di uno. Su una cache consultata migliaia di volte al secondo, la differenza si vede anche nei numeri di profiling.

5. Esempio pratico: unire flussi di dati con Iterator.concat e Array.fromAsync

Scenario: un’applicazione di e-commerce deve mostrare in un’unica lista i prodotti che arrivano da due fonti diverse: un catalogo locale (array sincrono già in memoria) e un catalogo di un fornitore esterno raggiungibile solo tramite chiamate API paginate (asincrono). Prima di ES2026 il codice per unire le due fonti in un array richiedeva spesso una funzione asincrona scritta a mano con push manuale dentro un ciclo.

// Con ES2026: Iterator.concat unisce le fonti, Array.fromAsync raccoglie il risultato  async function* prodottiFornitoreEsterno() {   let pagina = 1;   let prodotti;   do {     const risposta = await fetch(`https://api.fornitore.it/prodotti?pagina=${pagina}`);     const dati = await risposta.json();     prodotti = dati.prodotti;     yield* prodotti; // restituisce i prodotti uno alla volta     pagina++;   } while (prodotti.length > 0); }  async function catalogoCompleto(catalogoLocale) {   // Iterator.concat unisce un iterabile sincrono e uno asincrono in sequenza   const flussoUnito = Iterator.concat(catalogoLocale, prodottiFornitoreEsterno());    // Array.fromAsync attende e raccoglie tutto in un array, gestendo l'asincronia   const tutti = await Array.fromAsync(flussoUnito);   return tutti; }

Il punto chiave è la pigrizia (laziness): Iterator.concat non scorre subito tutti gli elementi, li concatena solo quando qualcuno li richiede. Questo significa che se più avanti nel codice si applica un filter o un take(20) prima di materializzare l’array, il fornitore esterno viene interrogato solo per le pagine effettivamente necessarie, risparmiando chiamate di rete inutili.

6. Best practice per adottare ECMAScript 2026 senza sorprese

• Verificate sempre la matrice di compatibilità reale (test262 o caniuse) prima di spedire in produzione codice che usa sintassi arrivata da poco a stadio 4: “nello standard” non equivale automaticamente a “supportato ovunque”.
• Isolate le funzionalità più recenti dietro un livello di astrazione (un piccolo modulo utility) nelle prime settimane di adozione, così se un motore ha un bug di implementazione dovete correggere in un solo punto.
• Preferite i metodi nativi (getOrInsertComputed, Iterator.concat, Array.fromAsync) alle librerie di terze parti che replicano lo stesso comportamento: meno dipendenze, meno peso nel bundle, aggiornamenti gestiti direttamente dal motore.
• Aggiornate gli strumenti di build (ESLint, TypeScript, Babel/SWC) insieme al codice: una sintassi nuova senza il parser aggiornato genera falsi errori che confondono il team.
• Non confondete “stadio 4” con “già disponibile ovunque”: una proposta finita può comparire nei motori con tempistiche diverse da browser a browser, quindi testate su più target prima di considerarla sicura per il pubblico generale.
• Documentate nel README del progetto la versione minima di Node.js o del motore richiesta, aggiornandola ogni volta che introducete una funzionalità recente: eviterete segnalazioni di bug che in realtà sono problemi di ambiente.
• Formate il team prima di generalizzare l’uso di una nuova API: una sintassi elegante usata male (per esempio Iterator.concat su flussi infiniti senza un limite) può introdurre bug più subdoli del vecchio codice imperativo che sostituisce.

7. ECMAScript 2027: cosa bolle in pentola in TC39

Mentre ECMAScript 2026 viene finalizzato, TC39 lavora già sulle proposte che punteranno all’edizione successiva. Ecco una panoramica di ciò che, con diversi gradi di maturità, è nel radar per ECMAScript 2027 e oltre. Vediamo quindi le prospettive future da nostra Guida ECMAScript 2026-27.

Già a stadio 4, in attesa della prossima edizione formale

• Temporal: la nuova API immutabile per data, ora e fusi orari, pensata per sostituire l’oggetto Date, storicamente instabile e privo di vero supporto ai fusi orari.
• Explicit Resource Management (using e await using): dichiarazioni per il rilascio deterministico di risorse (file, connessioni, lock), simile al “using” di C# o al “with” di Python.
• Atomics.pause: un’istruzione a basso livello per cicli di attesa attiva più efficienti in scenari di programmazione concorrente con memoria condivisa.
• Joint Iteration: itera più iterabili in parallelo passo dopo passo, come uno zip nativo, senza dover scrivere un generatore custom.

In discussione, a stadi più preliminari (2-3)

• Decorators: annotazioni per classi e metodi (@nomeDecoratore) già ampiamente usate tramite TypeScript e Babel, in attesa di una semantica nativa definitiva nel motore.
• Decorator Metadata: un meccanismo complementare ai decoratori per associare metadati leggibili a runtime alle classi decorate.

Idee più lontane (stadio 1 o discusse ma non ancora accettate)

• Pattern Matching: un’estensione dello switch con una sintassi dichiarativa per testare la forma di un valore, ispirata a linguaggi come Rust e Scala.
• Pipeline Operator: un operatore per concatenare trasformazioni di dati in modo lineare (valore |> funzione), proposto più volte ma finora respinto o rimasto a uno stadio iniziale per il dissenso di alcuni membri del comitato.

Il messaggio per chi pianifica lo stack tecnologico a medio termine è chiaro: Temporal ed Explicit Resource Management sono ormai stabili nella sostanza (stadio 4, semantica congelata), quindi conviene iniziare a studiarle già oggi anche se la loro pubblicazione formale slitta di un’edizione. Decoratori e pattern matching, invece, meritano attenzione ma non ancora piani di adozione concreti.

8. Conclusioni: la formazione continua come vantaggio competitivo

Se c’è una costante in questi diciassette anni di ECMAScript, è che lo standard non si ferma mai davvero: mentre un’edizione viene finalizzata, la successiva è già in cantiere nelle riunioni bimestrali di TC39. Lo stesso vale per l’intero ecosistema dello sviluppo web: framework, strumenti di build, runtime e best practice cambiano a una velocità che nessun singolo aggiornamento occasionale può inseguire davvero.

Per un’azienda, questo significa una cosa sola: la competitività tecnica non si compra una volta sola, si costruisce con una formazione continua e specialistica del team di sviluppo. Un sviluppatore che conosce a fondo le novità dello standard scrive codice più semplice da mantenere, individua prima le criticità di compatibilità e riduce le dipendenze da librerie esterne diventate superflue.

Innovaformazione organizza percorsi formativi su misura per team di sviluppo e IT manager di aziende italiane. Su richiesta possiamo erogare un Corso ECMAScript 2026 e 2027 in modalità online, in aula virtuale, con calendario da concordare in base alle esigenze del team. È inoltre possibile essere seguiti nella costruzione del piano formativo finanziato tramite Fondimpresa o altri fondi interprofessionali, per rendere la formazione un investimento a costo ridotto per l’azienda.

Per informazioni sul Corso ECMAScript 2026-27 o su altri percorsi formativi IT (vedi catalogo corsi QUI), scrivete a:

• info@innovaformazione.net oppure chiamate il 3471012275 (Dario Carrassi).

Saremo felici di costruire insieme il percorso più adatto al vostro team

Se volete leggere altri articoli tecnici potete navigare sul nostro blog QUI.

(fonte) (fonte) (fonte) (fonte)