Node.js 26 : API Temporal, mises à jour de tableau et Undici 8 expliqués

Chaque version majeure de Node.js est accompagnée d’une longue liste de modifications, d’augmentations de version et de notes de publication enthousiastes. La plupart des équipes jettent un coup d’œil au changelog, haussent les épaules et reportent la mise à jour d’un an ou deux.

Node.js 26 brise cette tendance.

Cette version va au-delà des améliorations internes ; elle redéfinit la manière dont le code backend est écrit au quotidien. Elle élimine les dépendances tierces sur lesquelles les équipes comptaient depuis des années, supprime les patterns obsolètes qui ralentissaient discrètement les systèmes de production, et pousse le runtime vers une adéquation plus stricte avec les normes web modernes.

Si vous gérez des services Node.js en production, voici ce qui compte réellement, pourquoi cela affecte votre flux de travail quotidien, et quels pièges il convient d’éviter avant de mettre à jour.

1. La fin de l’objet Date : une API temporelle stable

Pendant près de trois décennies, les développeurs JavaScript ont dû faire face à l’objet Date intégré. Il est modifiable, les mois sont indexés à partir de zéro, l’analyse des chaînes de caractères se comporte de manière incohérente selon les plateformes, et gérer les fuseaux horaires sans une bibliothèque puissante telle que Moment, Luxon ou Day.js est véritablement difficile.

Node.js 26 active par défaut la Temporal API à l’échelle globale, sans nécessiter de flag expérimental.

Pourquoi est-ce important ?

Temporal vous offre des objets de valeur immuables et sensibles aux fuseaux horaires. Il sépare clairement un instant précis dans le temps d’une date calendaire, d’une heure indiquée sur une horloge murale et d’une durée.

Un bug bien connu lié à la planification en backend concerne l’arithmétique des mois. Dans les versions antérieures de Node, ajouter un mois au 31 janvier pouvait faire passer la date en mars, car février ne compte pas autant de jours :

// Legacy JavaScript Date (Before Node.js 26)
const oldDate = new Date('2026-01-31T00:00:00Z');
oldDate.setMonth(oldDate.getMonth() + 1);

console.log(oldDate.toISOString());
// Output: 2026-03-03T00:00:00.000Z (Silently overflows into March!)

Temporal respecte correctement les limites du calendrier :

// Node.js 26: Clean and predictable
const today = Temporal.PlainDate.from('2026-01-31');
const nextMonth = today.add({ months: 1 });

console.log(nextMonth.toString());
// Output: 2026-02-28 (Clamps correctly to the last day of February)

Heures exactes entre fuseaux horaires

Lorsque vous travaillez avec la facturation, les abonnements ou les journaux d’audit couvrant plusieurs régions, vous avez besoin d’un instant précis (Instant) qui puisse être converti en heure locale affichée sur un cadran (ZonedDateTime) :

// Current exact point in time (UTC)
const exactInstant = Temporal.Now.instant();

// Convert to a specific time zone seamlessly
const tokyoTime = exactInstant.toZonedDateTimeISO('Asia/Tokyo');
const londonTime = exactInstant.toZonedDateTimeISO('Europe/London');console.log(`Tokyo: ${tokyoTime.toString()}`);
console.log(`London: ${londonTime.toString()}`);

Il n’est plus nécessaire d’augmenter la taille du bundle ou de recourir à des packages tiers simplement pour calculer les cycles de facturation ou afficher des dates selon différents fuseaux horaires.

2. Insertion/lecture natives dans un Map : getOrInsert et getOrInsertComputed

Les caches en mémoire et les compteurs de limitation de fréquence sont essentiels en ingénierie backend. Auparavant, insérer une clé dans un Map uniquement lorsqu’elle manquait signifiait devoir écrire du code générique répétitif :

// The old, redundant lookup pattern
if (!cache.has(userId)) {
  cache.set(userId, fetchUserProfile(userId));
}
const profile = cache.get(userId);

Cette approche force deux ou trois recherches de clé distinctes pour ce qui, conceptuellement, constitue une seule opération.

Node.js 26 inclut V8 14.6, qui intègre les méthodes standardisées TC39 Map upsert :

• map.getOrInsert(key, defaultValue)
• map.getOrInsertComputed(key, computeFunction)

Exemple pratique : Agrégateur de requêtes en mémoire

const requestBuckets = new Map();

function trackUserRequest(userId, payload) {
  // If userId is missing, execute the callback and insert the array atomically
  const userQueue = requestBuckets.getOrInsertComputed(userId, () => []);

  userQueue.push(payload);
  return userQueue.length;
}

La fonction passée à getOrInsertComputed s’exécute de manière différée — elle n’est déclenchée que lorsque la clé n’existe pas encore. Cela évite des allocations d’objets inutiles et simplifie la logique de mise en cache dans les services API.

3. HTTP à fort débit avec Undici 8

La fonction globale fetch() de Node s’exécute sur Undici, et Node.js 26 met à jour le moteur HTTP sous-jacent vers Undici 8.

Qu’as-t-il changé en coulisses ?

Les configurations anciennes de clients HTTP avaient tendance à rencontrer des goulets d’étranglement sous une charge continue, principalement en raison de la surcharge liée aux pools de connexions et d’une analyse inefficace des en-têtes. Undici 8 remédie à cela grâce à :

• Une utilisation moindre de la mémoire pour les réponses en flux continu : les gros fichiers JSON ou les téléchargements de fichiers sont désormais transmis en flux continu avec beaucoup moins d’interruptions liées au nettoyage de la mémoire.
• Une meilleure réutilisation des pipelines HTTP/1.1 et des pools de connexions HTTP/2 : les connexions keep-alive sont conservées de manière plus stricte par défaut, réduisant ainsi le temps d’attente pour communiquer avec les services intermédiaires.

// Native fetch in Node.js 26 automatically inherits Undici 8 optimizations
const response = await fetch('https://api.internal.service/stream-data', {
  headers: { 'Connection': 'keep-alive' }
});

for await (const chunk of response.body) {
  processDataChunk(chunk); // Efficient backpressure and zero intermediate buffering
}

Si votre service fonctionne comme une passerelle API ou distribue les requêtes à plusieurs microservices intermédiaires, cette mise à niveau au niveau du moteur réduit la latence aux percentiles p95/p99 sans nécessiter de modifications dans le code de votre application.

4. Exécuter TypeScript sans surcoût de transpilation

Node.js a progressivement modifié la manière dont il charge les modules. À partir de Node.js 26, le retrait des types est une fonctionnalité pleinement supportée et stable, et les flags expérimentaux utilisés précédemment pour activer la transformation ont été complètement supprimés.

Vous pouvez maintenant exécuter un fichier .ts directement depuis la ligne de commande :

node src/server.ts

Ce que couvre réellement cette fonctionnalité

Il est essentiel de faire la distinction claire entre le retrait des types et vérification des types :

Your TypeScript File
       │
       ▼
[ Node.js Type Stripper ]  ──> Removes interfaces, types, & generics in memory
       │
       ▼
[ Pure V8 Engine Execution ] ──> Runs the resulting JavaScript instantly

• Aucune vérification de type n’est effectuée. Si votre code attribue une valeur numérique à une variable déclarée comme chaîne de caractères, Node.js l’exécutera sans problème. Vous avez néanmoins besoin de tsc --noEmit dans votre pipeline CI/CD pour détecter ce type d’erreurs avant leur déploiement.

Il ne gère pas les syntaxes nécessitant une véritable génération de code. Des constructions telles que des décorateurs de style ancien ou des propriétés de paramètres (par exemple, constructor(public name: string)) ne sont pas prises en charge par l’outil de suppression et provoqueront une erreur.

Pour les services, les outils en ligne de commande et les processus en arrière-plan construits avec la syntaxe standard de TypeScript, cela signifie que vous pouvez supprimer tsx, ts-node ou un processus dédié à la surveillance de la compilation de votre environnement de développement local.

5. Changements majeurs à vérifier

Puisque Node.js 26 représente une mise à jour majeure, les mainteneurs en ont profité pour éliminer des API obsolètes qui étaient utilisées depuis longtemps.

+------------------------------------+------------------------------------------+
| Removed API                        | Modern Replacement                      |
+------------------------------------+------------------------------------------+
| http.Server.prototype.writeHeader  | res.writeHead()                          |
| _stream_readable, _stream_writable | require('node:stream').Readable / Writable|
| --experimental-transform-types     | Native type-stripping (built-in)        |
+------------------------------------+------------------------------------------+

Le risque caché dans les mécanismes internes des flux

On peut considérer que le changement le plus risqué de cette version est la suppression des sous-modules privés liés aux flux — _stream_readable, _stream_writable, _stream_transform ainsi que d’autres fichiers internes similaires.

Un certain nombre de paquets anciens sur npm, en particulier ceux qui n’ont pas été modifiés depuis avant 2020, ignorent l’interface publique require('stream') et accèdent directement à ces éléments internes :

// BROKEN in Node.js 26: Throws ERR_MODULE_NOT_FOUND
const Readable = require('_stream_readable');

// CORRECT:
const { Readable } = require('node:stream');

Si ne serait-ce qu’une dépendance profondément enfouie dans votre arbre de dépendances fait encore référence aux modules _stream_*, votre application échouera immédiatement au démarrage. Avant d’essayer la mise à niveau, vérifiez votre fichier de verrouillage pour détecter ce type de référence :

npm ls _stream_readable

Si l’audit révèle des problèmes, vous devrez mettre à niveau ou remplacer cette dépendance avant de pouvoir continuer.

Faut-il mettre à niveau vos systèmes en production maintenant ?

Node.js suit un schéma de publication alterné entre les versions majeures paires et impaires :

• Versions à numéro impair (23, 25) : versions de courte durée destinées aux tests ; elles ne deviennent jamais LTS.
• Versions à numéro pair (22, 24, 26) : versions conçues pour une utilisation en production.

Node.js 26 est devenu la version « actuelle » en mai, et il est prévu qu’il entre dans le statut de support à long terme actif à la fin d’octobre.

[May 2026: Node 26 Current] ────> [October 2026: Node 26 LTS] ────> [Production Default]
          ▲                                    ▲
   Test in Staging/CI                 Migrate Production Workloads

Un plan de déploiement pratique

• Évitez pour l’instant de déployer sur des systèmes de production critiques. Laissez le temps à la version « actuelle » de mûrir avant qu’elle ne devienne officiellement LTS en octobre. Si vous devez mettre à jour un environnement de production immédiatement, Node.js 24 reste la meilleure option LTS actuelle.

Ajoutez Node.js 26 à votre matrice de tests CI immédiatement. Exécutez toute votre suite de tests — unitaires, d’intégration et end-to-end — dessus. Faites particulièrement attention aux importations de flux obsolètes ou aux modules C++ natifs compilés avec NODE_MODULE_VERSION 147 qui devront être reconstruits.

Commencez à utiliser Temporal dans tout nouveau code que vous écrivez. Faites en sorte que votre équipe s’habitue à Temporal.PlainDate et Temporal.Instant, et évitez d’intégrer des bibliothèques tierces de gestion des dates pour les nouveaux services.

Conclusion

L’objectif principal de Node.js 26 est simple : réduire les obstacles et rembourser des années de dettes liées au code ancien.

Grâce à l’arithmétique des dates natif et fiable via Temporal, à une gestion plus efficace des structures de données courantes grâce aux mises à jour Map, au débogage intégré de TypeScript, ainsi qu’à une plus grande vitesse d’envoi des requêtes HTTP grâce à Undici 8, cette mise à jour du runtime vous permet de développer des systèmes backend plus rapidement tout en utilisant moins de packages externes.

Node.js a considérablement mûri. L’époque où il fallait intégrer une douzaine de bibliothèques d’aide rien que pour manipuler une date ou correspondre à un schéma de route est désormais largement révolue.