Transformer une chaîne en une date en JavaScript

Les dates reçues d’une base de données ou d’une API restent des chaînes de caractères. Un sélecteur de date ou un calcul peut nécessiter un objet JavaScript Date. La méthode de conversion dépend du format d’entrée et de la présence d’un fuseau horaire explicite. Passez la chaîne à new Date(dateString) pour analyser une chaîne standard prise en charge ; l’appel sans argument new Date() crée une date correspondant à l’heure actuelle. Utilisez Date.parse() si vous avez besoin d’une valeur en millisecondes, ou analysez vous-même les composants lorsque le format personnalisé est connu.

Ce guide présente trois méthodes pratiques :

• Passez une chaîne de date prise en charge à new Date(dateString) pour créer un objet Date.
• Appelez Date.parse() lorsqu’une valeur numérique en millisecondes est utile.
• Séparez les composants d’un format personnalisé connu avant de construire une Date.

Dans les exemples, le code et les sorties sont conservés tels quels ; les libellés visibles restent donc en anglais.

Utiliser new Date() pour convertir une chaîne en date en JavaScript

Le constructeur new Date(dateString) accepte une chaîne de date prise en charge et renvoie un objet Date. Cet horodatage ISO 8601 contient Z, qui indique le temps universel coordonné (UTC). L’appel à toISOString() renvoie cette heure en UTC, quel que soit le fuseau horaire local de la machine.

const dateString = '2024-05-23T14:30:00Z';
const date = new Date(dateString);

console.log(date instanceof Date);
console.log(date.toISOString());

Une chaîne contenant uniquement une date, comme 2024-05-23, est interprétée en UTC, tandis qu’une chaîne contenant une date et une heure sans décalage est interprétée en heure locale. Si la source représente un instant précis, utilisez une chaîne standard avec un décalage explicite afin que son interprétation ne dépende pas du fuseau horaire de la machine.

L’analyse des formats qui ne respectent pas la forme standard de date et d’heure n’est pas définie de façon uniforme par les implémentations JavaScript. Une chaîne acceptée par un navigateur ou un environnement d’exécution peut être interprétée différemment ailleurs. Avant d’utiliser l’objet obtenu, vérifiez-le avec Number.isNaN(date.getTime()). Une analyse réussie ne garantit pas non plus que la chaîne respecte le format ou les règles calendaires exigés par votre application ; vérifiez ces exigences séparément.

Utiliser Date.parse() pour analyser une chaîne de date en JavaScript

Date.parse() renvoie le nombre de millisecondes écoulées depuis l’époque Unix pour une chaîne de date qu’il a pu analyser, ou NaN s’il ne peut pas analyser la valeur. Il renvoie un nombre, et non un objet Date. Pour une valeur provenant d’une API, analysez-la puis construisez une date à partir du résultat numérique si vous avez besoin d’un objet :

const apiValue = '2019-01-01T12:30:00.000Z';
const milliseconds = Date.parse(apiValue);

console.log(typeof milliseconds);
console.log(Number.isNaN(milliseconds) ? 'not parsed' : new Date(milliseconds).toISOString());

Number.isNaN() détecte le signal d’échec de l’analyse, mais ne valide pas entièrement un format propre à l’application. Un environnement d’exécution peut accepter une valeur que votre application devrait rejeter. Si l’entrée doit respecter un motif particulier, vérifiez ce motif ainsi que les valeurs calendaires avant d’utiliser le résultat de l’analyse.

Séparer une chaîne et la convertir en date en JavaScript

Lorsqu’une entrée suit un format personnalisé connu, séparez-la selon ce format et transmettez ses composants au constructeur Date à plusieurs arguments. Cet exemple attend le format DD-MM-YYYYTHH:mm:ss ; le constructeur interprète les composants en heure locale. Il renvoie null si les composants ne correspondent pas à une date calendaire valide.

function parseKnownDate(value) {
  if (typeof value !== 'string') {
    return null;
  }

  const dateTimeParts = value.split('T');
  if (dateTimeParts.length !== 2) {
    return null;
  }

  const [datePart, timePart] = dateTimeParts;
  if (
    !/^\d{2}-\d{2}-\d{4}$/.test(datePart) ||
    !/^\d{2}:\d{2}:\d{2}$/.test(timePart)
  ) {
    return null;
  }

  const dateParts = datePart.split('-');
  const timeParts = timePart.split(':');
  if (dateParts.length !== 3 || timeParts.length !== 3) {
    return null;
  }

  const [day, month, year] = dateParts.map(Number);
  const [hours, minutes, seconds] = timeParts.map(Number);

  if (![day, month, year, hours, minutes, seconds].every(Number.isInteger)) {
    return null;
  }

  // The multi-argument constructor treats years 0–99 as 1900–1999.
  // setFullYear preserves the supplied year, including values in that range.
  const date = new Date(0);
  date.setFullYear(year, month - 1, day);
  date.setHours(hours, minutes, seconds, 0);

  if (
    date.getFullYear() !== year ||
    date.getMonth() !== month - 1 ||
    date.getDate() !== day ||
    date.getHours() !== hours ||
    date.getMinutes() !== minutes ||
    date.getSeconds() !== seconds
  ) {
    return null;
  }

  return date;
}

const date = parseKnownDate('21-03-2020T11:20:30');
console.log(date === null ? 'not a valid date' : date.toString());

Les séparations reposent sur l’ordre des composants indiqué ; adaptez-les si la source utilise un autre ordre ou séparateur. L’argument du mois commence à zéro : le code soustrait donc un au mois exprimé de manière habituelle. Les méthodes de définition utilisent l’heure locale et peuvent normaliser les valeurs hors limites ; comparer les composants obtenus aux valeurs analysées permet de détecter cette normalisation. La date initiale dépend du fuseau horaire local : cette méthode crée donc une valeur en heure locale, et non un horodatage UTC. Si des années comprises entre 0 et 99 sont possibles, setFullYear() évite le traitement particulier que le constructeur à plusieurs arguments réserve à ces années. Cet exemple vérifie que les composants sont des entiers et détecte le report au-delà des limites calendaires ; si votre application impose des règles d’entrée plus strictes, vérifiez aussi le motif exact de la chaîne et les plages autorisées pour chaque champ.

Conclusion

Passez une chaîne de date prise en charge à new Date(dateString) pour créer un objet Date ; si elle représente un instant précis, privilégiez une chaîne contenant un décalage explicite. L’appel sans argument new Date() crée une date correspondant à l’heure actuelle ; il n’analyse pas de chaîne. Utilisez Date.parse() si vous avez besoin du nombre de millisecondes écoulées depuis l’époque Unix ou de son signal d’échec NaN ; transmettez à new Date(milliseconds) le nombre obtenu après une analyse réussie si vous avez besoin d’un objet Date. Pour un format personnalisé connu, analysez et validez ses composants avant de créer une date en heure locale. La présentation d’ISO 8601 décrit le format de date et d’heure utilisé par de nombreuses API.