ES2026, la 17ᵉ édition de la spécification ECMAScript, a été officiellement ratifiée par Ecma International le 30 juin 2026. Le gros titre, c'est bien sûr Temporal, l'API qui remplace enfin Date — on en a déjà parlé en détail sur ce blog. Mais Temporal cache une demi-douzaine d'autres ajouts, plus discrets, que tu vas croiser dans du code de production bien avant d'écrire ta première ligne de Temporal.PlainDate.

Ces fonctionnalités ont un point commun : elles remplacent des patterns que tu écris probablement à la main depuis des années — un try/finally pour fermer une ressource, un if (map.has(key)) avant d'insérer, une somme flottante qui dérape après la virgule. Rien d'aussi spectaculaire qu'un nouveau framework, mais du code en moins et des bugs en moins.

On fait le tour de six ajouts concrets, avec leur support actuel dans Node.js et les navigateurs, pour savoir lesquels tu peux utiliser dès aujourd'hui.

using et await using : la fin des try/finally pour libérer une ressource

La proposition Explicit Resource Management introduit deux nouveaux mots-clés, using et await using, pour garantir qu'une ressource (fichier, connexion réseau, verrou) est libérée automatiquement à la sortie du bloc où elle est déclarée — même en cas d'exception.

Le mécanisme repose sur deux symboles bien connus maintenant : Symbol.dispose pour le nettoyage synchrone, Symbol.asyncDispose pour l'asynchrone. Tout objet qui les implémente devient « disposable ».

function ouvrirFichier(chemin) {
  const handle = fs.openSync(chemin, 'r');
  return {
    handle,
    // Appelé automatiquement à la sortie du bloc `using`
    [Symbol.dispose]() {
      fs.closeSync(handle);
    }
  };
}

function lireConfig() {
  using fichier = ouvrirFichier('./config.json');
  const texte = fs.readFileSync(fichier.handle, 'utf8');
  return JSON.parse(texte);
} // fichier.handle est fermé ici, que la fonction se termine normalement ou plante

Pour les ressources asynchrones (une connexion à une base de données, un verrou distant), await using fait la même chose mais attend la fin du nettoyage :

async function requeteUtilisateur(id) {
  await using lien = await ouvrirConnexionBDD();
  return lien.query('SELECT * FROM users WHERE id = ?', [id]);
  // lien.[Symbol.asyncDispose]() est attendu automatiquement ici
}

Quand plusieurs déclarations using coexistent dans le même bloc, les nettoyages s'exécutent dans l'ordre inverse de la déclaration — comme une pile. Côté support, Chrome, Firefox et Node.js proposent déjà cette syntaxe nativement depuis début 2026 ; TypeScript la supporte aussi depuis sa version 5.2. C'est probablement la fonctionnalité d'ES2026 avec le plus d'impact immédiat sur du code serveur.

Map.getOrInsert() : enfin un vrai upsert sans race condition

Le pattern « je vérifie si la clé existe, sinon je l'insère » revient sans arrêt pour implémenter un cache ou un compteur. Jusqu'ici, il fallait deux accès à la map (un has, un set), avec le risque d'écraser une valeur insérée entre-temps dans du code concurrent. Map.prototype.getOrInsert() et getOrInsertComputed() font l'opération en une seule fois.

const compteurs = new Map();

// getOrInsert(clé, valeur) : insère la valeur seulement si la clé est absente
function incrementer(cle) {
  const valeur = compteurs.getOrInsert(cle, 0);
  compteurs.set(cle, valeur + 1);
}

// getOrInsertComputed(clé, callback) : le callback n'est appelé
// que si la clé n'existe pas encore (utile si le calcul est coûteux)
const cacheUtilisateurs = new Map();
function getUtilisateur(id) {
  return cacheUtilisateurs.getOrInsertComputed(id, () => chargerUtilisateurDepuisDB(id));
}

La différence entre les deux méthodes est simple à retenir : getOrInsert prend une valeur directe, getOrInsertComputed prend une fonction qui n'est exécutée qu'en cas d'absence de la clé — pratique pour éviter un calcul ou un appel réseau inutile. Cette méthode nécessite Node.js 24 ou une version plus récente.

Math.sumPrecise() : additionner des flottants sans perdre en précision

Tout le monde a déjà été surpris par 0.1 + 0.2 === 0.30000000000000004. Le problème s'aggrave quand tu sommes une longue liste de nombres dans une boucle ou un reduce : les erreurs d'arrondi s'accumulent à chaque addition intermédiaire.

const valeurs = [1e20, 0.1, -1e20];

console.log(valeurs.reduce((somme, n) => somme + n, 0));
// 0 — l'addition intermédiaire de 1e20 a « avalé » 0.1

console.log(Math.sumPrecise(valeurs));
// 0.1 — la somme est calculée avec la valeur mathématique exacte,
// puis arrondie une seule fois à la fin

Attention, ce n'est pas une solution magique à tous les problèmes de flottants : Math.sumPrecise([0.1, 0.2, 0.3, 0.4]) continuera de renvoyer une valeur avec une imprécision résiduelle, parce que 0.1 et 0.2 ne sont déjà pas représentables exactement en binaire. Ce que la méthode élimine, c'est l'accumulation d'erreurs d'arrondi entre chaque étape d'une somme — utile pour des calculs financiers ou statistiques sur de gros tableaux.

Array.fromAsync() et Iterator.concat() : manipuler des flux sans boilerplate

Array.fromAsync() fait pour les itérables asynchrones ce que Array.from() fait pour les itérables synchrones : il collecte toutes les valeurs dans un tableau, sans que tu aies à écrire une boucle for await...of manuelle.

async function* recupererPages(url) {
  let page = 1;
  while (page <= 3) {
    yield await fetch(`${url}?page=${page++}`).then(r => r.json());
  }
}

const toutesLesPages = await Array.fromAsync(recupererPages('/api/articles'));

Cette méthode est déjà disponible depuis Node.js 22. Iterator.concat(), de son côté, permet d'enchaîner plusieurs itérables en un seul, sans passer par des tableaux intermédiaires ni du spread :

function* tachesUrgentes() {
  yield 'corriger le bug en prod';
  yield 'publier le correctif';
}
function* tachesRoutine() {
  yield 'répondre aux emails';
  yield 'mettre à jour la doc';
}

const planning = Iterator.concat(tachesUrgentes(), ['pause déjeuner'], tachesRoutine());
console.log([...planning]);
// ['corriger le bug en prod', 'publier le correctif', 'pause déjeuner', 'répondre aux emails', 'mettre à jour la doc']

Les deux méthodes s'inscrivent dans la continuité des Iterator Helpers (.map(), .filter(), .take()...), qui permettent désormais de traiter des flux de données sans les matérialiser entièrement en mémoire.

Error.isError() : détecter une erreur sans se faire piéger par instanceof

instanceof Error a un angle mort connu : il échoue quand l'erreur vient d'un autre realm (un iframe, un worker, un module chargé différemment), parce que chaque realm a sa propre classe Error. Error.isError() fait la vérification correctement, quelle que soit l'origine de l'objet.

try {
  JSON.parse('{ ceci n\'est pas du JSON valide');
} catch (erreur) {
  if (Error.isError(erreur)) {
    console.error('Erreur capturée :', erreur.message);
  } else {
    // Quelqu'un a fait "throw 'un string'" quelque part — ça arrive
    console.error('Exception non standard :', erreur);
  }
}

Error.isError(new TypeError('oups'));   // true
Error.isError({ message: 'erreur' });   // false, ce n'est pas une vraie instance d'Error

C'est un petit changement, mais si tu écris une librairie ou du code qui doit fonctionner de façon fiable dans des contextes variés (extensions navigateur, environnements avec plusieurs realms), c'est le genre de détail qui évite des bugs difficiles à reproduire.

Par où commencer ?

Toutes ces fonctionnalités ne sont pas au même niveau de maturité côté outillage. Avant de les intégrer dans une base de code existante :

Vérifie la version de Node.js ciblée en production — Array.fromAsync fonctionne dès Node 22, mais Map.getOrInsert demande Node 24.
Si tu compiles avec Babel ou que tu vises d'anciens navigateurs, ajoute les polyfills correspondants (core-js couvre déjà la plupart de ces méthodes) plutôt que d'attendre un support natif universel.
Commence par les gains sans risque : Math.sumPrecise() et Error.isError() sont des remplacements directs, sans changement de comportement ailleurs dans le code.
using/await using demandent plus d'attention : ils changent la façon dont tu structures la gestion des ressources, donc introduis-les progressivement sur du code neuf plutôt que de tout réécrire d'un coup.

Aucune de ces fonctionnalités n'est indispensable pour livrer une application demain matin. Mais chacune remplace un pattern que tu recopies probablement depuis des années — et c'est exactement le genre d'évolution qu'il vaut la peine d'adopter dès que ton environnement le permet.

ES2026 : 6 nouveautés JavaScript (au-delà de Temporal) à connaître