L'API Temporal est le nouveau standard JavaScript conçu pour remplacer l'objet Date. Elle offre une gestion des dates et heures plus rigoureuse grâce à des classes dédiées, une immutabilité par défaut, un support natif des fuseaux horaires et des calendriers non grégoriens. Disponible nativement dans Chrome et Firefox, elle représente l'avenir de la manipulation temporelle en JavaScript.
Dans ce guide complet, nous allons explorer chaque aspect de l'API Temporal : ses classes fondamentales, leurs cas d'usage concrets, l'arithmétique sur les dates, la gestion des durées, et les bonnes pratiques pour l'intégrer dès maintenant dans vos projets.
Si vous souhaitez en savoir plus sur JavaScript, jetez un oeil à notre formation JavaScript que vous pouvez commencer gratuitement !
Pourquoi l'objet Date pose problème
Avant de plonger dans Temporal, il est essentiel de comprendre pourquoi l'objet Date actuel ne suffit plus. Ce n'est pas simplement une question de préférence : c'est un problème de conception fondamental qui engendre des bugs dans la quasi-totalité des applications manipulant des dates.
Un héritage de Java mal conçu
L'objet Date de JavaScript est directement inspiré de la classe java.util.Date de Java, elle-même considérée comme si problématique qu'elle a été remplacée dès le début des années 2010. Mais JavaScript, fidèle à son principe de rétrocompatibilité, a conservé cet objet tel quel.
Voici quelques-uns des pièges les plus courants :
// Les mois commencent à 0 : ici on obtient le 1er FÉVRIER, pas janvier
const date = new Date(2025, 1, 1);
console.log(date.toISOString()); // 2025-02-01T00:00:00.000Z
// Les dates invalides sont silencieusement corrigées
const invalide = new Date(2025, 1, 30); // 30 février n'existe pas
console.log(invalide.toISOString()); // 2025-03-02T00:00:00.000Z (2 mars !)
// getYear() retourne l'année depuis 1900, pas l'année réelle
const now = new Date();
console.log(now.getYear()); // 125 (en 2025)
console.log(now.getFullYear()); // 2025
L'absence de fuseau horaire explicite
Internement, un objet Date stocke uniquement un timestamp en millisecondes depuis le 1er janvier 1970 UTC. Lorsque vous affichez cette date, le navigateur applique automatiquement le fuseau horaire local de l'appareil. Vous ne pouvez pas créer une date dans un fuseau horaire arbitraire comme Asia/Tokyo ou America/New_York sans recourir à des contournements avec Intl.DateTimeFormat.
Ce comportement est la source d'innombrables bugs, notamment dans les applications internationales où un même événement doit être affiché correctement selon le fuseau de chaque utilisateur.
La mutabilité problématique
Tous les setters de Date modifient l'objet en place, ce qui provoque des effets de bord difficiles à traquer :
const date = new Date(2025, 0, 15);
const copie = date; // Ce n'est PAS une copie, c'est une référence
copie.setMonth(5);
console.log(date.getMonth()); // 5 — la date originale est modifiée !
Présentation de l'API Temporal
Temporal est un espace de noms global (namespace), similaire à Math ou Intl. Il n'est pas un constructeur : vous ne pouvez pas écrire new Temporal(). Toutes ses propriétés et méthodes sont statiques, et il expose plus de 200 méthodes utilitaires réparties dans plusieurs classes spécialisées.
La philosophie centrale de Temporal repose sur un principe : un type par cas d'usage. Au lieu d'un objet unique qui tente de tout faire (comme Date), Temporal propose des classes distinctes, chacune adaptée à un besoin précis.
Les classes principales de Temporal
| Classe | Description | Exemple d'usage |
|---|---|---|
Temporal.PlainDate | Date sans heure ni fuseau | Date de naissance, jour férié |
Temporal.PlainTime | Heure sans date ni fuseau | Alarme quotidienne, horaire d'ouverture |
Temporal.PlainDateTime | Date + heure, sans fuseau | Rendez-vous local |
Temporal.ZonedDateTime | Date + heure + fuseau horaire | Événement international, vol aérien |
Temporal.Instant | Point précis sur la timeline (timestamp) | Log serveur, horodatage technique |
Temporal.Duration | Durée entre deux points | Temps restant, durée d'un trajet |
Temporal.PlainYearMonth | Année + mois uniquement | Facturation mensuelle |
Temporal.PlainMonthDay | Mois + jour uniquement | Anniversaire récurrent |
Support navigateur et polyfills
À l'heure actuelle (mi-2025), Temporal est supporté nativement par Chrome et Firefox. Safari est en cours d'implémentation. Pour Node.js, vous pouvez l'activer via le drapeau --harmony-temporal. Bun travaille également sur son intégration.
Pour une utilisation en production dès maintenant, deux polyfills sont recommandés :
# Polyfill officiel des champions de la proposition
npm install @js-temporal/polyfill
# Polyfill alternatif par FullCalendar
npm install @fullcalendar/temporal-polyfill// Utilisation du polyfill
import { Temporal } from '@js-temporal/polyfill';
const today = Temporal.Now.plainDateISO();
console.log(today.toString()); // 2025-07-11
Créer des objets Temporal
L'API Temporal propose trois méthodes de création cohérentes, disponibles sur chaque classe. Cette uniformité est l'un de ses grands atouts par rapport à Date.
Via Temporal.Now
L'espace de noms Temporal.Now fournit des méthodes pour obtenir l'instant présent dans différents formats :
// Instant précis (timestamp avec fuseau UTC)
const instant = Temporal.Now.instant();
console.log(instant.toString()); // 2025-07-11T14:30:00.123456789Z
// Date et heure locales (sans fuseau)
const dateTime = Temporal.Now.plainDateTimeISO();
console.log(dateTime.toString()); // 2025-07-11T16:30:00.123456789
// Date du jour uniquement
const today = Temporal.Now.plainDateISO();
console.log(today.toString()); // 2025-07-11
// Heure actuelle uniquement
const time = Temporal.Now.plainTimeISO();
console.log(time.toString()); // 16:30:00.123456789
// Date et heure avec fuseau horaire
const zoned = Temporal.Now.zonedDateTimeISO();
console.log(zoned.toString()); // 2025-07-11T16:30:00.123456789+02:00[Europe/Paris]
// Identifiant du fuseau horaire système
const tz = Temporal.Now.timeZoneId();
console.log(tz); // Europe/Paris
Via le constructeur
Chaque classe expose un constructeur qui accepte des valeurs numériques. Contrairement à Date, les mois sont indexés à partir de 1 :
// PlainDate : année, mois, jour
const date = new Temporal.PlainDate(2025, 1, 1);
console.log(date.toString()); // 2025-01-01 (bien le 1er janvier)
// PlainDateTime : année, mois, jour, heure, minute, seconde
const dateTime = new Temporal.PlainDateTime(2025, 12, 25, 18, 30, 0);
console.log(dateTime.toString()); // 2025-12-25T18:30:00
// PlainTime : heure, minute, seconde
const time = new Temporal.PlainTime(8, 0, 0);
console.log(time.toString()); // 08:00:00Contrairement à Date qui corrige silencieusement les valeurs invalides, Temporal lève une exception RangeError si vous passez des valeurs impossibles comme le 30 février.
Via la méthode from()
La méthode statique from() est la plus polyvalente. Elle accepte une chaîne ISO 8601 ou un objet de propriétés :
// À partir d'une chaîne ISO
const date = Temporal.PlainDate.from('2025-08-15');
const dateTime = Temporal.PlainDateTime.from('2025-08-15T09:00:00');
// À partir d'un objet de propriétés
const dateObj = Temporal.PlainDate.from({ year: 2025, month: 8, day: 15 });
// ZonedDateTime avec fuseau horaire complet
const zoned = Temporal.ZonedDateTime.from(
'2025-08-15T09:00:00+02:00[Europe/Paris]'
);
console.log(zoned.toString());
// 2025-08-15T09:00:00+02:00[Europe/Paris]
// ZonedDateTime à partir d'un objet
const zonedObj = Temporal.ZonedDateTime.from({
timeZone: 'America/New_York',
year: 2025,
month: 8,
day: 15,
hour: 9,
minute: 0
});
console.log(zonedObj.toString());
// 2025-08-15T09:00:00-04:00[America/New_York]
Lire les propriétés d'un objet Temporal
Chaque classe Temporal expose des propriétés en lecture seule qui vous permettent d'extraire précisément l'information dont vous avez besoin. Exit les getMonth() et getFullYear() : vous accédez directement aux propriétés.
const date = Temporal.PlainDate.from('2025-07-14');
console.log(date.year); // 2025
console.log(date.month); // 7
console.log(date.day); // 14
console.log(date.dayOfWeek); // 1 (lundi)
console.log(date.dayOfYear); // 195
console.log(date.daysInMonth); // 31
console.log(date.daysInYear); // 365
console.log(date.monthsInYear);// 12
console.log(date.inLeapYear); // false
console.log(date.weekOfYear); // 29
console.log(date.yearOfWeek); // 2025Pour un ZonedDateTime, vous avez accès à des propriétés supplémentaires liées au fuseau horaire :
const zdt = Temporal.ZonedDateTime.from(
'2025-07-14T15:30:00+02:00[Europe/Paris]'
);
console.log(zdt.timeZoneId); // Europe/Paris
console.log(zdt.offset); // +02:00
console.log(zdt.hoursInDay); // 24
console.log(zdt.epochMilliseconds); // timestamp en millisecondes
console.log(zdt.epochNanoseconds); // timestamp en nanosecondes (BigInt)
Manipuler et modifier des dates
L'une des caractéristiques fondamentales de Temporal est l'immutabilité. Toute opération de modification retourne un nouvel objet, laissant l'original intact. Cela élimine une catégorie entière de bugs liés aux effets de bord.
Modifier avec with()
La méthode with() crée une copie de l'objet en remplaçant uniquement les champs spécifiés :
const date = Temporal.PlainDateTime.from('2025-01-01T12:00:00');
// Changer uniquement l'année
const date2030 = date.with({ year: 2030 });
console.log(date2030.toString()); // 2030-01-01T12:00:00
// L'original est préservé
console.log(date.toString()); // 2025-01-01T12:00:00
// Changer plusieurs champs à la fois
const modified = date.with({ month: 6, day: 15, hour: 18 });
console.log(modified.toString()); // 2025-06-15T18:00:00
Changer de fuseau horaire avec withTimeZone()
Pour les objets ZonedDateTime, vous pouvez convertir vers un autre fuseau horaire. L'instant absolu reste le même, seule la représentation locale change :
const paris = Temporal.ZonedDateTime.from(
'2025-07-14T12:00:00+02:00[Europe/Paris]'
);
const tokyo = paris.withTimeZone('Asia/Tokyo');
console.log(tokyo.toString());
// 2025-07-14T19:00:00+09:00[Asia/Tokyo]
const newYork = paris.withTimeZone('America/New_York');
console.log(newYork.toString());
// 2025-07-14T06:00:00-04:00[America/New_York]
Méthodes supplémentaires de ZonedDateTime
ZonedDateTime propose aussi withCalendar() pour changer de système de calendrier et withPlainTime() pour remplacer la partie horaire :
const zdt = Temporal.ZonedDateTime.from(
'2025-07-14T15:30:00+02:00[Europe/Paris]'
);
// Revenir à minuit
const midnight = zdt.startOfDay();
console.log(midnight.toString());
// 2025-07-14T00:00:00+02:00[Europe/Paris]
// Remplacer l'heure par une valeur spécifique
const at9am = zdt.withPlainTime('09:00:00');
console.log(at9am.toString());
// 2025-07-14T09:00:00+02:00[Europe/Paris]
Arithmétique sur les dates
L'arithmétique temporelle est l'un des domaines où Temporal surpasse le plus clairement l'objet Date. Les méthodes add() et subtract() acceptent un objet décrivant la durée à ajouter ou soustraire.
Ajouter et soustraire du temps
const date = Temporal.PlainDate.from('2025-01-01');
// Ajouter 4 jours
const plus4 = date.add({ days: 4 });
console.log(plus4.toString()); // 2025-01-05
// Ajouter 40 jours (gère automatiquement le changement de mois)
const plus40 = date.add({ days: 40 });
console.log(plus40.toString()); // 2025-02-10
// Soustraire 2 mois et 15 jours
const minus = date.subtract({ months: 2, days: 15 });
console.log(minus.toString()); // 2024-10-17
// Ajouter une durée complexe
const future = date.add({ years: 1, months: 6, days: 10 });
console.log(future.toString()); // 2026-07-11
Arithmétique avec gestion du DST
Lorsque vous utilisez ZonedDateTime, l'arithmétique prend automatiquement en compte les changements d'heure d'été (DST). C'est un avantage considérable par rapport à Date :
// Le changement d'heure en France a lieu le dernier dimanche de mars
const avantDST = Temporal.ZonedDateTime.from(
'2025-03-29T12:00:00+01:00[Europe/Paris]'
);
const apresDST = avantDST.add({ days: 1 });
console.log(apresDST.toString());
// 2025-03-30T12:00:00+02:00[Europe/Paris]
// L'offset est passé de +01:00 à +02:00 automatiquement
Calculer la différence entre deux dates
Les méthodes until() et since() retournent un objet Temporal.Duration représentant la différence entre deux dates :
const debut = Temporal.PlainDate.from('2025-01-01');
const fin = Temporal.PlainDate.from('2025-07-21');
// Par défaut, la durée est en jours
const duree = debut.until(fin);
console.log(duree.toString()); // P201D (201 jours)
// Pour obtenir des mois et jours, spécifiez largestUnit
const dureeDetaille = debut.until(fin, { largestUnit: 'months' });
console.log(dureeDetaille.toString()); // P6M20D (6 mois et 20 jours)
// since() est l'inverse de until()
const depuis = fin.since(debut, { largestUnit: 'months' });
console.log(depuis.toString()); // P6M20D
Comparer deux dates
La comparaison se fait via les méthodes statiques compare() et la méthode d'instance equals() :
const date1 = Temporal.PlainDate.from('2025-01-01');
const date2 = Temporal.PlainDate.from('2025-07-14');
// compare() retourne -1, 0 ou 1
console.log(Temporal.PlainDate.compare(date1, date2)); // -1 (date1 avant date2)
console.log(Temporal.PlainDate.compare(date2, date1)); // 1
console.log(Temporal.PlainDate.compare(date1, date1)); // 0
// equals() pour tester l'égalité
console.log(date1.equals(Temporal.PlainDate.from('2025-01-01'))); // true
// Tri d'un tableau de dates
const dates = [
Temporal.PlainDate.from('2025-12-25'),
Temporal.PlainDate.from('2025-01-01'),
Temporal.PlainDate.from('2025-07-14')
];
dates.sort(Temporal.PlainDate.compare);
console.log(dates.map(d => d.toString()));
// ['2025-01-01', '2025-07-14', '2025-12-25']N'utilisez jamais === pour comparer deux objets Temporal. Comme tout objet JavaScript, cela comparerait les références mémoire, pas les valeurs. Utilisez toujours equals() ou compare().
Gestion des durées avec Temporal.Duration
Temporal.Duration représente une durée de manière explicite. Contrairement au calcul en millisecondes qu'impose Date, vous travaillez directement avec des unités lisibles.
Créer et manipuler des durées
// Créer une durée depuis un objet
const duree = Temporal.Duration.from({
hours: 130,
minutes: 20
});
// Obtenir le total en secondes
const totalSeconds = duree.total({ unit: 'second' });
console.log(totalSeconds); // 469200
// Créer une durée depuis une chaîne ISO 8601
const d2 = Temporal.Duration.from('P1Y6M15DT12H30M');
console.log(d2.years); // 1
console.log(d2.months); // 6
console.log(d2.days); // 15
console.log(d2.hours); // 12
console.log(d2.minutes); // 30
Arrondir une durée
La méthode round() permet d'arrondir une durée. Attention : les conversions impliquant des mois ou des années nécessitent un relativeTo, car un mois n'a pas toujours le même nombre de jours :
const duree = Temporal.Duration.from({ months: 6, days: 20 });
// Arrondir en jours (nécessite relativeTo pour les mois)
const enJours = duree.round({
largestUnit: 'days',
relativeTo: Temporal.PlainDate.from('2025-01-01')
});
console.log(enJours.toString()); // P201D
// Pour les unités sous le jour, pas besoin de relativeTo
const heures = Temporal.Duration.from({ minutes: 150 });
const arrondi = heures.round({ largestUnit: 'hours' });
console.log(arrondi.toString()); // PT2H30M
Formater une durée avec Intl.DurationFormat
L'API Intl.DurationFormat permet d'afficher les durées de manière localisée :
const duree = Temporal.Duration.from({ months: 6, days: 20, hours: 3 });
const formatter = new Intl.DurationFormat('fr', { style: 'long' });
console.log(formatter.format(duree));
// "6 mois, 20 jours et 3 heures"
const shortFormatter = new Intl.DurationFormat('fr', { style: 'short' });
console.log(shortFormatter.format(duree));
// "6 mois, 20 j, 3 h"
Conversions entre classes Temporal
Un atout majeur de l'API Temporal est la facilité avec laquelle vous pouvez convertir un type en un autre. Chaque classe expose des méthodes toPlainDate(), toPlainTime(), toZonedDateTime(), etc.
// De ZonedDateTime vers les types "Plain"
const zdt = Temporal.ZonedDateTime.from(
'2025-07-14T15:30:00+02:00[Europe/Paris]'
);
const plainDate = zdt.toPlainDate();
console.log(plainDate.toString()); // 2025-07-14
const plainTime = zdt.toPlainTime();
console.log(plainTime.toString()); // 15:30:00
const plainDateTime = zdt.toPlainDateTime();
console.log(plainDateTime.toString()); // 2025-07-14T15:30:00
const instant = zdt.toInstant();
console.log(instant.toString()); // 2025-07-14T13:30:00Z
// De PlainDate vers ZonedDateTime (nécessite un fuseau et une heure)
const date = Temporal.PlainDate.from('2025-07-14');
const zoned = date.toZonedDateTime({
timeZone: 'Europe/Paris',
plainTime: Temporal.PlainTime.from('09:00:00')
});
console.log(zoned.toString());
// 2025-07-14T09:00:00+02:00[Europe/Paris]
// De PlainDate vers PlainYearMonth ou PlainMonthDay
const ym = date.toPlainYearMonth();
console.log(ym.toString()); // 2025-07
const md = date.toPlainMonthDay();
console.log(md.toString()); // 07-14
Gestion des calendriers non grégoriens
Temporal supporte nativement plusieurs systèmes de calendrier, ce qui est essentiel pour les applications internationales. Par défaut, tous les objets utilisent le calendrier ISO 8601 (basé sur le grégorien), mais vous pouvez travailler avec d'autres calendriers.
// Convertir une date grégorienne vers le calendrier hébraïque
const isoDate = Temporal.PlainDate.from('2025-07-14');
const hebrewDate = isoDate.withCalendar('hebrew');
console.log(hebrewDate.toString()); // date au format hébraïque
console.log(hebrewDate.year); // année dans le calendrier hébraïque
console.log(hebrewDate.month); // mois dans le calendrier hébraïque
// Calendrier japonais (ères impériales)
const jpDate = isoDate.withCalendar('japanese');
console.log(jpDate.era); // "reiwa"
console.log(jpDate.eraYear); // 7 (Reiwa 7)
// Affichage localisé avec Intl
console.log(hebrewDate.toLocaleString('fr-FR', {
calendar: 'hebrew',
dateStyle: 'full'
}));La liste des calendriers supportés peut être obtenue via Intl.supportedValuesOf('calendar'). Parmi les plus courants : islamic, hebrew, chinese, japanese, persian, buddhist.
Intégration avec les inputs HTML
L'API Temporal s'intègre naturellement avec les éléments <input> HTML de type date, time et datetime-local. Ces champs retournent des valeurs au format ISO que from() accepte directement.
// Input de type "date"
const dateInput = document.querySelector('#date-input');
dateInput.addEventListener('change', () => {
const date = Temporal.PlainDate.from(dateInput.value);
console.log(date.toString());
console.log(date.dayOfWeek); // Jour de la semaine
});
// Input de type "time"
const timeInput = document.querySelector('#time-input');
timeInput.addEventListener('change', () => {
const time = Temporal.PlainTime.from(timeInput.value);
const in3Hours = time.add({ hours: 3 });
console.log(in3Hours.toString()); // ex: "18:24:00"
});
// Input de type "datetime-local" converti en ZonedDateTime
const dtInput = document.querySelector('#datetime-input');
dtInput.addEventListener('change', () => {
const plain = Temporal.PlainDateTime.from(dtInput.value);
const zoned = plain.toZonedDateTime('Europe/Paris');
console.log(zoned.toString());
});
Le format RFC 9557
Toutes les classes Temporal utilisent le format RFC 9557 pour la sérialisation et la désérialisation. Ce format est une extension de ISO 8601 / RFC 3339 et ajoute la possibilité de spécifier le fuseau horaire et le système de calendrier :
YYYY-MM-DD T HH:mm:ss.sssssssss Z/±HH:mm [time_zone_id] [u-ca=calendar_id]Quelques exemples concrets :
// Instant (toujours en UTC)
'2025-07-14T13:30:00Z'
// ZonedDateTime avec fuseau et calendrier
'2025-07-14T15:30:00+02:00[Europe/Paris][u-ca=iso8601]'
// PlainDate simple
'2025-07-14'
// PlainTime simple
'15:30:00'
// PlainDateTime
'2025-07-14T15:30:00'Ce format permet une précision jusqu'à la nanoseconde (9 décimales), contre la milliseconde pour Date. C'est particulièrement utile pour les applications scientifiques ou les systèmes nécessitant une grande précision temporelle.
Bonnes pratiques pour utiliser Temporal
Voici les recommandations essentielles pour tirer le meilleur parti de l'API Temporal dans vos projets :
1. Choisissez le bon type pour chaque cas d'usage. N'utilisez pas ZonedDateTime partout par défaut. Une date de naissance est un PlainDate, une alarme quotidienne est un PlainTime, un événement international est un ZonedDateTime.
2. Ne mélangez pas year et era/eraYear. Si vous utilisez des calendriers avec des ères, choisissez une seule représentation et restez cohérent.
3. Utilisez toujours compare() ou equals() pour les comparaisons. L'opérateur === compare les références, pas les valeurs.
4. Spécifiez relativeTo pour les conversions de durées impliquant des mois ou des années. Un mois ne fait pas toujours le même nombre de jours.
5. Ne supposez jamais qu'une semaine fait 7 jours. Utilisez daysInWeek pour un code robuste avec les calendriers non grégoriens.
6. Préférez monthCode à month pour stocker des données récurrentes (comme les anniversaires), car monthCode correspond au nom du mois indépendamment des mois intercalaires.
7. Utilisez un polyfill en production tant que le support n'est pas universel, et testez sur tous vos environnements cibles.
Migration depuis Date vers Temporal
Voici un récapitulatif des équivalences entre l'ancien Date et la nouvelle API Temporal :
| Opération | Avec Date | Avec Temporal |
|---|---|---|
| Date actuelle | new Date() | Temporal.Now.plainDateISO() |
| Timestamp actuel | Date.now() | Temporal.Now.instant() |
| Créer une date | new Date(2025, 0, 1) | new Temporal.PlainDate(2025, 1, 1) |
| Parser une chaîne | new Date('2025-01-01') | Temporal.PlainDate.from('2025-01-01') |
| Ajouter des jours | date.setDate(date.getDate() + 7) | date.add({ days: 7 }) |
| Différence | (date2 - date1) / 86400000 | date1.until(date2) |
| Formater | date.toLocaleDateString() | date.toLocaleString() |
| Comparer | date1.getTime() === date2.getTime() | date1.equals(date2) |
Questions fréquentes
L'API Temporal est-elle prête pour la production ?
Temporal est supporté nativement par Chrome et Firefox depuis 2025. Pour les autres navigateurs et environnements, des polyfills matures comme @js-temporal/polyfill vous permettent de l'utiliser dès maintenant. Pour les nouveaux projets, c'est un choix judicieux. Pour les projets existants, une migration progressive est recommandée.
Temporal remplace-t-il des bibliothèques comme Moment.js ou date-fns ?
Oui, dans la grande majorité des cas. Temporal couvre nativement les cas d'usage principaux de ces bibliothèques : parsing, formatage, arithmétique, fuseaux horaires et calendriers. L'avantage est qu'étant intégré au langage, il ne nécessite aucune dépendance externe et sera toujours maintenu avec le moteur JavaScript.
Quelle est la différence entre Temporal.Instant et Temporal.ZonedDateTime ?
Temporal.Instant représente un point absolu sur la ligne du temps (un timestamp en nanosecondes depuis l'époque Unix), sans aucune notion de fuseau ni de calendrier. Temporal.ZonedDateTime combine un instant avec un fuseau horaire et un calendrier, ce qui permet d'obtenir une date et heure lisibles par un humain dans une région donnée.
Comment Temporal gère-t-il les changements d'heure d'été (DST) ?
ZonedDateTime gère automatiquement les transitions DST. Quand vous effectuez des opérations arithmétiques, l'offset est ajusté. Pour les moments ambigus (lors du passage à l'heure d'hiver où une heure existe deux fois), Temporal fournit des options de résolution d'ambiguïté via le paramètre disambiguation dans les méthodes de conversion.
