JavaScript : Pourquoi l’API Temporal va (enfin) enterrer l’objet Date

Si vous développez en JavaScript, vous avez forcément déjà vécu ce moment de frustration intense face à l’objet Date. Entre l’indexation des mois qui commence à zéro, l’absence de support natif pour les fuseaux horaires, sa mutabilité imprévisible et une gestion du formatage approximatif, la gestion du temps a toujours été le point noir de l’écosystème.

Pendant des années, nous avons délégué cette tâche à des bibliothèques externes comme Moment.js, Day.js ou encore date-fns. Mais les choses sont sur le point de radicalement changer avec l’arrivée de Temporal

Actuellement au Stade 3 de la TC39, cette nouvelle API native promet de résoudre une bonne fois pour toutes les limitations historiques de JavaScript.

Le problème avec l’objet Date

L’objet Date actuel est une copie presque conforme de l’implémentation Java de 1995. Ses défauts sont structurels :

• Mutabilité : Modifier une date peut impacter d’autres parties de votre code par référence.
• Complexité des fuseaux horaires : Un cauchemar à gérer sans librairie tierce.
• Parsing peu fiable : Des comportements qui varient d’un navigateur à l’autre.
• Et bien d’autres complexités, qui j’en suis sûr, vous ont souvent fait grincer des dents

1. Des opérations simplifiées

Plus besoin de calculs savants pour comparer deux dates ou ajouter une durée. L’API est expressive et intuitive :

const dt1 = Temporal.PlainDate.from({ year: 2026, month: 2, day: 6 });
const dt2 = Temporal.PlainDate.from({ year: 2026, month: 2, day: 6 });
// Egalité
dt1.equals(dt2); // output: true
// Opérations
dt1.subtract({ days: 1 }).toString(); // output: "2026-02-05"
dt1.until(dt2.add({ months: 1 })).days; // output: 28
// Ordonner
[ dt1.add({ days: 1 }), dt2 ]
  .sort(Temporal.PlainDate.compare)
  .map((dt) => dt.toString()); // output: [ "2026-02-06", "2026-02-07" ]

2. Immutabilité

Contrairement à son prédécesseur, Temporal est immutable. Chaque opération retourne un nouvel objet, rendant votre code plus prédictible et moins prompt aux erreurs incongrues.

const dt1 = Temporal.PlainTime.from({ hour: 10, minute: 10, second: 10 });
dt1.add({ minutes: 10 }).toString(); // output: "10:20:10"
dt1.toString(); // output: "10:10:10"

3. Une gestion native des fuseaux horaires

Autre argument en faveur de la nouvelle API, elle permet de manipuler des dates dans des fuseaux spécifiques sans s’arracher les cheveux.

Temporal.ZonedDateTime.from('2024-09-01T10:00[Asia/Tokyo]')
  .withTimeZone(Temporal.Now.timeZoneId())
  .toLocaleString() // output: "01/09/2024 3:00:00 UTC+2"

4. Adieu le .format(‘DD/MM/YYYY’)

Si vous avez l’habitude des librairies type Moment.js ou Day.js, vous chercherez en vain une méthode de formatage par “tokens” (comme YYYY-MM-DD). Temporal fait un choix radical : séparer les données de leur présentation.

L’API ne propose pas de moteur de formatage interne. Elle délègue cette responsabilité à Intl.DateTimeFormat. Pourquoi ce choix ? Pour forcer les développeurs à utiliser des standards d’internationalisation plutôt que de construire manuellement des chaînes de caractères qui ne respectent pas toujours les spécificités locales.

Voici comment afficher une date au format français :

const date = Temporal.PlainDate.from('2026-02-06');
// Utilisation directe avec toLocaleString
console.log(date.toLocaleString('fr-FR')); // "06/02/2026"
// Utilisation plus poussée avec Intl.DateTimeFormat
const formatter = new Intl.DateTimeFormat('fr-FR', {
  year: 'numeric',
  month: 'long',
  day: 'numeric',
});
console.log(formatter.format(date)); // "6 février 2026"

Quand pourrons-nous l’utiliser ?

L’API est en phase finale de spécification à la TC39 (Stage 3). Elle est déjà disponible via des polyfills pour les projets en production qui souhaitent anticiper le futur. Son adoption par les navigateurs majeurs est la prochaine étape cruciale. Certains comme Chrome et Firefox ont même déjà commencés à l’intégrer (c.f Can I Use)

Temporal ne se contente pas de corriger Date ; elle redéfinit la manière dont nous concevons le temps dans nos applications web. C’est une avancée majeure pour la robustesse et la maintenabilité de nos codebases.