ES2024 e ES2025: le nuove funzionalità JavaScript che devi conoscere - Guida Operativa

Ti è mai capitato di scrivere 15 righe di codice solo per raggruppare un array per chiave? O di dover incapsulare una Promise in una struttura che non avevi? Se sei uno sviluppatore JavaScript che lavora su progetti reali, sai bene che il linguaggio evolve in fretta, ma non sempre hai tempo di leggere le specifiche. Noi, di Meteora Web, gestiamo stack JavaScript ogni giorno – da Vue a Laravel con Livewire – e queste novità le abbiamo già integrate nei nostri progetti. In questa guida vediamo le funzionalità di ES2024 (già stabile) e ES2025 (appena finalizzato), con esempi pratici che puoi copiare e incollare. Niente teoria astratta: solo codice che ti fa risparmiare tempo e righe.

Perché ti interessano queste versioni

ECMAScript si aggiorna ogni anno con proposte che diventano standard. Se usi Node.js 20+ o un browser recente (Chrome 120+, Firefox 122+, Edge 120+), gran parte di ES2024 è già disponibile. ES2025 arriva con il 2026 su Node 22+ e browser aggiornati. Ignorarle significa continuare a scrivere codice più lungo, meno leggibile, e potenzialmente più lento. Non ha senso lavorare di più quando il linguaggio ti offre la soluzione.

ES2024 (ECMAScript 2024) : le feature già pronte

Object.groupBy e Map.groupBy – raggruppare array senza fatica

Prima di ES2024, per raggruppare un array di ordini per cliente dovevi usare reduce o un ciclo con oggetto accumulatore. Ora esiste Object.groupBy che fa tutto in una riga.

const ordini = [
  { cliente: 'Rossi', totale: 120 },
  { cliente: 'Bianchi', totale: 80 },
  { cliente: 'Rossi', totale: 45 }
];

const raggruppati = Object.groupBy(ordini, ordine => ordine.cliente);
console.log(raggruppati);
// { Rossi: [{ cliente: 'Rossi', totale: 120 }, { cliente: 'Rossi', totale: 45 }],
//   Bianchi: [{ cliente: 'Bianchi', totale: 80 }] }

Attenzione: Object.groupBy restituisce un oggetto senza prototipo (per evitare collisioni con proprietà ereditate). Se vuoi usare una Map (per chiavi non stringa), usa Map.groupBy.

const perId = Map.groupBy(ordini, o => o.cliente);
// Map(2) { 'Rossi' => [...], 'Bianchi' => [...] }

Quando usarlo: in qualsiasi dashboard, report, o aggregazione dati. Noi lo usiamo nelle nostre piattaforme per raggruppare transazioni per mese o per utente.

Promise.withResolvers – creare una Promise dall’esterno

Quante volte hai dovuto creare una Promise e poi esporre manualmente resolve e reject fuori dal costruttore? Con ES2024 arriva Promise.withResolvers che restituisce un oggetto con promise, resolve, reject.

const { promise, resolve, reject } = Promise.withResolvers();
setTimeout(() => resolve('Fatto!'), 1000);
const risultato = await promise;
console.log(risultato); // 'Fatto!'

Prima dovevi dichiarare variabili esterne o usare pattern più complessi. Ora tutto in una destrutturazione pulita.

Esempio reale: gestire una coda di operazioni asincrone in un contesto di eventi o callback.

String.prototype.isWellFormed e toWellFormed – stringhe Unicode pulite

Le stringhe JavaScript possono contenere surrogati isolati (sequenze Unicode malformate). isWellFormed controlla se una stringa è ben formata; toWellFormed la sostituisce con U+FFFD (carattere di sostituzione) nei punti malformati.

const male = '\uD800';
console.log(male.isWellFormed()); // false
console.log(male.toWellFormed()); // '\uFFFD'

Utile quando ricevi dati esterni (API, form) che potrebbero contenere caratteri corrotti. Non lasciare che un surrogato isolato ti rompa una query SQL o una risposta JSON.

Atomics.waitAsync – attesa non bloccante nei worker

Se lavori con SharedArrayBuffer e thread worker, Atomics.wait era sincrono (bloccante). Atomics.waitAsync restituisce una Promise, permettendo di attendere senza bloccare il thread principale.

const buffer = new SharedArrayBuffer(4);
const int32 = new Int32Array(buffer);

// in un worker
Atomics.store(int32, 0, 1);
Atomics.notify(int32, 0);

// nel thread principale
const result = await Atomics.waitAsync(int32, 0, 0).value;
console.log(result); // 'ok'

Quando ti serve: in applicazioni web multi-thread (es. elaborazione immagini, simulazioni).

RegExp v flag – set notation e intersection

Il flag v (unicode sets) permette di usare notazioni di insieme nelle regex, come unione e intersezione.

// Caratteri che sono lettere greche MA non vocali
const regex = /^[\p{Script=Greek}--[\p{Greek}&&[αεηιουω]]]+$/v;
console.log(regex.test('β')); // true
console.log(regex.test('α')); // false

Rivoluzionario per validazioni complesse su Unicode. Niente più espressioni chilometriche.

ArrayBuffer.transfer – spostare buffer senza copia

ArrayBuffer.prototype.transfer trasferisce la memoria da un buffer a un altro, invalidando il buffer originale.

const buf1 = new ArrayBuffer(8);
const buf2 = buf1.transfer(16);
buf1.byteLength; // 0 (detached)
buf2.byteLength; // 16

Perfetto per librerie di basso livello o WebCodecs.

ES2025 (ECMAScript 2025) : le novità da usare subito

Promise.try – gestire fallimenti sincroni e asincroni in modo uniforme

Promise.try avvolge una funzione (sincrona o asincrona) in una Promise, gestendo eccezioni lanciate in entrambi i casi.

const risultato = await Promise.try(() => {
  if (Math.random() > 0.5) throw new Error('Sincrono');
  return 'OK';
});
console.log(risultato); // 'OK' oppure catch

Prima dovevi fare new Promise(resolve => resolve(fn())) o un try-catch manuale. Ora tutto in una riga.

RegExp modifiers – modificatori inline con scope

Il nuovo flag (?ims-ims:) permette di attivare/disattivare modificatori (case-insensitive, multiline, dotall) solo in una parte della regex.

/^test(?i:Esempio)Fine$/v.test('testesempiofine'); // true
// Solo 'Esempio' è case-insensitive

Evita di dover spezzare regex o usare flag globali che si applicano a tutta l'espressione.

JSON.parse con source text access

Ora puoi accedere al testo originale di una stringa durante il parsing usando il secondo parametro (reviver) con una nuova proprietà source.

const obj = JSON.parse('{"chiave": "valore"}', (key, value, context) => {
  if (key === 'chiave') {
    console.log(context.source); // '"valore"'
  }
  return value;
});

Utile quando devi preservare formati particolari (es. date, numeri grandi) senza perderli.

Cosa fare adesso

1. Aggiorna il tuo runtime: assicurati di usare Node.js 22+ o un browser moderno per ES2025. Per ES2024 bastano Node 20+.
2. Sostituisci i pattern vecchi: cerca nel tuo codice i reduce che raggruppano array e rimpiazzali con Object.groupBy. Cerca le Promise create manualmente e usa Promise.withResolvers.
3. Testa le regex con flag v: se lavori con Unicode, il v flag ti semplifica la vita. Aggiorna i pattern.
4. Usa Promise.try per uniformare la gestione di funzioni che possono lanciare sincronamente o restituire Promise.
5. Rivedi la gestione delle stringhe: implementa isWellFormed e toWellFormed nei punti di ingresso dei dati.

Noi di Meteora Web abbiamo già aggiornato i nostri progetti con queste funzionalità: ci hanno fatto risparmiare ore di debug e centinaia di righe di codice. Se vuoi approfondire, leggi la documentazione ufficiale su MDN. E se stai pianificando una migrazione o un nuovo progetto, ricordati: un codice moderno è un codice che si mantiene meglio. Non restare indietro.