Comment afficher l'année et l'ère dans les calendriers non grégoriens ?

Introduction

Le calendrier grégorien compte les années à partir d'un point de départ unique, ce qui fait de l'année 2024 un nombre simple. D'autres systèmes de calendrier comptent les années différemment. Le calendrier islamique compte à partir de l'année 622 de notre ère. Le calendrier hébraïque compte à partir d'une date de création traditionnelle remontant à des milliers d'années. Le calendrier chinois utilise un cycle de 60 ans d'années nommées au lieu de nombres séquentiels.

Ces différents systèmes de comptage signifient que le même moment dans le temps a différentes représentations d'année selon les calendriers. Le 15 octobre 2024 dans le calendrier grégorien correspond à l'année 1446 dans le calendrier islamique, à l'année 5785 dans le calendrier hébraïque et à l'année 2024 (甲辰, jiǎ-chén) dans le calendrier chinois.

L'objet Intl.DateTimeFormat de JavaScript fournit des options pour afficher les années et les ères de n'importe quel système de calendrier. L'option calendar sélectionne le calendrier à utiliser. Les options year et era contrôlent l'affichage de l'année et de l'ère. Pour les calendriers qui utilisent des années nommées au lieu de nombres, la méthode formatToParts() fournit un accès à la fois au nom de l'année et à l'année grégorienne correspondante.

Comment les années diffèrent selon les systèmes de calendrier

Les systèmes de calendrier diffèrent de trois manières fondamentales : le point de départ du comptage, la manière de numéroter les années et l'utilisation ou non d'ères.

Le calendrier grégorien commence à compter à partir de l'année 1 de notre ère et s'incrémente de manière séquentielle. Le calendrier islamique commence à partir de l'année 1 AH (après l'Hégire) en 622 de notre ère. Le calendrier hébraïque commence à partir de l'année 1 en 3761 avant notre ère. Chaque calendrier possède sa propre époque, le point où le comptage des années commence.

Certains calendriers utilisent des numéros d'année séquentiels qui augmentent indéfiniment. Les calendriers grégorien, islamique, hébraïque et persan fonctionnent de cette manière. D'autres calendriers utilisent des cycles où les noms d'années se répètent. Le calendrier chinois utilise un cycle de 60 ans d'années nommées. Après 60 ans, le cycle se répète.

Les ères divisent le temps en périodes nommées. Le calendrier grégorien utilise av. J.-C. et apr. J.-C. Le calendrier japonais utilise des noms d'ères impériales. Les calendriers islamique et hébraïque utilisent généralement une seule ère qui a commencé à leur époque. Le calendrier chinois n'utilise pas les ères de la même manière, s'appuyant plutôt sur des années nommées au sein de cycles.

Afficher les années dans le calendrier islamique

Le calendrier islamique compte les années à partir de l'Hégire, la migration de Mahomet de La Mecque à Médine en 622 apr. J.-C. L'année islamique 1 correspond à l'année grégorienne 622. Le calendrier islamique utilise des mois lunaires, ce qui rend ses années plus courtes que les années grégoriennes. Cela signifie que l'année islamique avance plus rapidement, atteignant actuellement l'année 1446 lorsque l'année grégorienne est 2024.

Vous spécifiez le calendrier islamique en utilisant l'option calendar avec la valeur islamic ou en ajoutant l'extension Unicode -u-ca-islamic à l'identifiant de locale.

const date = new Date('2024-10-15');

const formatter = new Intl.DateTimeFormat('en-US', {
  calendar: 'islamic',
  year: 'numeric',
  month: 'long',
  day: 'numeric'
});

console.log(formatter.format(date));
// "Rabi' II 12, 1446 AH"

L'année s'affiche comme 1446, qui est l'année islamique correspondant au 15 octobre 2024. L'ère "AH" (After Hijra) apparaît automatiquement lors de l'affichage de dates islamiques en anglais.

Différentes locales formatent les dates islamiques selon leurs conventions.

const date = new Date('2024-10-15');

const en = new Intl.DateTimeFormat('en-US', {
  calendar: 'islamic',
  year: 'numeric',
  month: 'long',
  day: 'numeric'
});
console.log(en.format(date));
// "Rabi' II 12, 1446 AH"

const ar = new Intl.DateTimeFormat('ar-SA', {
  calendar: 'islamic',
  year: 'numeric',
  month: 'long',
  day: 'numeric'
});
console.log(ar.format(date));
// "١٢ ربيع الآخر ١٤٤٦ هـ"

La locale arabe utilise des chiffres indo-arabes et affiche le nom du mois en arabe. L'indicateur d'ère change en "هـ" (l'abréviation arabe pour Hijri).

Contrôler l'affichage de l'ère dans le calendrier islamique

L'option era contrôle si et comment l'indicateur d'ère s'affiche. L'option accepte trois valeurs : long pour le nom complet de l'ère, short pour une abréviation, et narrow pour la forme la plus compacte.

const date = new Date('2024-10-15');

const long = new Intl.DateTimeFormat('en-US', {
  calendar: 'islamic',
  year: 'numeric',
  era: 'long'
});
console.log(long.format(date));
// "1446 Anno Hegirae"

const short = new Intl.DateTimeFormat('en-US', {
  calendar: 'islamic',
  year: 'numeric',
  era: 'short'
});
console.log(short.format(date));
// "1446 AH"

const narrow = new Intl.DateTimeFormat('en-US', {
  calendar: 'islamic',
  year: 'numeric',
  era: 'narrow'
});
console.log(narrow.format(date));
// "1446 A"

La valeur long produit « Anno Hegirae » (latin pour « l'année de l'Hégire »). La valeur short produit « AH ». La valeur narrow produit simplement « A ».

Variantes du calendrier islamique

Le calendrier islamique possède plusieurs variantes qui utilisent différentes méthodes de calcul. JavaScript prend en charge cinq variantes : islamic, islamic-civil, islamic-tbla, islamic-umalqura et islamic-rgsa.

La variante islamic-umalqura utilise le calendrier officiel de l'Arabie saoudite, qui est basé sur des observations astronomiques. La variante islamic-civil utilise un calcul arithmétique fixe avec des mois alternant entre 29 et 30 jours.

const date = new Date('2024-10-15');

const umalqura = new Intl.DateTimeFormat('en-US', {
  calendar: 'islamic-umalqura',
  year: 'numeric',
  month: 'long',
  day: 'numeric'
});
console.log(umalqura.format(date));
// "Rabi' II 12, 1446 AH"

const civil = new Intl.DateTimeFormat('en-US', {
  calendar: 'islamic-civil',
  year: 'numeric',
  month: 'long',
  day: 'numeric'
});
console.log(civil.format(date));
// "Rabi' II 11, 1446 AH"

Les variantes peuvent produire des numéros de jour différents pour la même date grégorienne car elles utilisent différentes méthodes de calcul pour déterminer les limites des mois.

Afficher les années dans le calendrier hébraïque

Le calendrier hébraïque compte les années à partir d'une date de création traditionnelle en 3761 avant notre ère. Cela rend les années hébraïques beaucoup plus grandes que les années grégoriennes. L'année hébraïque 5785 correspond à l'année grégorienne 2024.

Vous spécifiez le calendrier hébraïque en utilisant l'option calendar avec la valeur hebrew ou en ajoutant l'extension Unicode -u-ca-hebrew à l'identifiant de locale.

const date = new Date('2024-10-15');

const formatter = new Intl.DateTimeFormat('en-US', {
  calendar: 'hebrew',
  year: 'numeric',
  month: 'long',
  day: 'numeric'
});

console.log(formatter.format(date));
// "Tishrei 13, 5785"

L'année s'affiche comme 5785, qui est l'année hébraïque correspondant au 15 octobre 2024. Le calendrier hébraïque est luni-solaire, ce qui signifie que ses mois suivent la lune mais ses années restent synchronisées avec l'année solaire grâce à des mois intercalaires périodiques.

Les dates hébraïques en locale hébraïque utilisent des chiffres hébraïques et des noms de mois.

const date = new Date('2024-10-15');

const he = new Intl.DateTimeFormat('he-IL', {
  calendar: 'hebrew',
  year: 'numeric',
  month: 'long',
  day: 'numeric'
});
console.log(he.format(date));
// "י״ג בתשרי ה׳תשפ״ה"

La locale hébraïque affiche la date entièrement en hébreu, y compris les lettres hébraïques utilisées comme chiffres.

Afficher les années du calendrier chinois

Le calendrier chinois utilise un cycle de 60 ans d'années nommées au lieu de numéros d'année séquentiels. Chaque année du cycle porte un nom composé de deux caractères : une tige céleste et une branche terrestre. L'année 2024 est 甲辰 (jiǎ-chén), ce qui signifie « dragon de bois » dans l'astrologie chinoise traditionnelle.

Étant donné que le calendrier chinois utilise des années nommées, son affichage nécessite une gestion différente de celle des calendriers avec des numéros d'année séquentiels.

const date = new Date('2024-10-15');

const formatter = new Intl.DateTimeFormat('en-US', {
  calendar: 'chinese',
  year: 'numeric',
  month: 'long',
  day: 'numeric'
});

console.log(formatter.format(date));
// "Ninth Month 13, 2024(jiǎ-chén)"

La sortie formatée inclut à la fois l'année grégorienne 2024 et le nom de l'année « jiǎ-chén » entre parenthèses. Cette double représentation aide les utilisateurs à comprendre à la fois le nom de l'année cyclique et l'année grégorienne correspondante.

Les dates chinoises en locale chinoise s'affichent en utilisant des caractères chinois.

const date = new Date('2024-10-15');

const zh = new Intl.DateTimeFormat('zh-CN', {
  calendar: 'chinese',
  year: 'numeric',
  month: 'long',
  day: 'numeric'
});
console.log(zh.format(date));
// "2024甲辰年九月十三"

La locale chinoise affiche le nom de l'année en utilisant des caractères chinois. Le format intègre naturellement le nom de l'année dans la chaîne de date.

Extraire le nom de l'année et l'année associée

Les calendriers qui utilisent des années nommées fournissent deux informations : le nom de l'année dans le cycle et l'année grégorienne correspondante. La méthode formatToParts() sépare ces éléments en parties distinctes.

const date = new Date('2024-10-15');

const formatter = new Intl.DateTimeFormat('zh-CN', {
  calendar: 'chinese',
  year: 'numeric',
  month: 'long',
  day: 'numeric'
});

const parts = formatter.formatToParts(date);
console.log(parts);

Le tableau de parties inclut deux entrées pertinentes :

[
  { type: 'relatedYear', value: '2024' },
  { type: 'yearName', value: '甲辰' },
  // ... other parts
]

La partie relatedYear contient l'année grégorienne à quatre chiffres. La partie yearName contient le nom de l'année cyclique. Cette séparation vous permet d'utiliser l'une ou les deux valeurs dans un formatage personnalisé.

Vous pouvez extraire ces parties pour créer des affichages de dates personnalisés.

const date = new Date('2024-10-15');

const formatter = new Intl.DateTimeFormat('zh-CN', {
  calendar: 'chinese',
  year: 'numeric',
  month: 'long',
  day: 'numeric'
});

const parts = formatter.formatToParts(date);
const yearName = parts.find(p => p.type === 'yearName')?.value;
const relatedYear = parts.find(p => p.type === 'relatedYear')?.value;

console.log(`Year name: ${yearName}`);
// "Year name: 甲辰"

console.log(`Gregorian year: ${relatedYear}`);
// "Gregorian year: 2024"

Cette technique fonctionne avec tout calendrier utilisant des années ou des cycles nommés.

Afficher les années dans le calendrier persan

Le calendrier persan, également connu sous le nom de calendrier solaire hégirien, compte les années à partir de l'Hégire en 622 de notre ère, la même époque que le calendrier islamique. Cependant, le calendrier persan utilise des mois solaires au lieu de mois lunaires, ce qui le rend plus similaire au calendrier grégorien dans sa structure.

Vous spécifiez le calendrier persan en utilisant l'option calendar avec la valeur persian ou en ajoutant l'extension Unicode -u-ca-persian à l'identifiant de locale.

const date = new Date('2024-10-15');

const formatter = new Intl.DateTimeFormat('en-US', {
  calendar: 'persian',
  year: 'numeric',
  month: 'long',
  day: 'numeric'
});

console.log(formatter.format(date));
// "Mehr 24, 1403 AP"

L'année s'affiche comme 1403, qui est l'année persane correspondant au 15 octobre 2024. L'ère « AP » (Anno Persico) apparaît dans le format anglais.

Les dates persanes dans la locale persane utilisent des chiffres persans et des noms de mois.

const date = new Date('2024-10-15');

const fa = new Intl.DateTimeFormat('fa-IR', {
  calendar: 'persian',
  year: 'numeric',
  month: 'long',
  day: 'numeric'
});
console.log(fa.format(date));
// "۲۴ مهر ۱۴۰۳ ه‍.ش."

La locale persane affiche la date en utilisant des caractères et des chiffres persans (farsi). L'indicateur d'ère « ه‍.ش. » est l'abréviation persane pour l'ère solaire hégirienne.

Combiner les options de calendrier et d'ère

Vous pouvez combiner les options calendar et era pour contrôler exactement comment les années et les ères s'affichent dans différents systèmes de calendrier. Cette combinaison vous donne un contrôle précis sur le formatage des dates.

const date = new Date('2024-10-15');

const gregorian = new Intl.DateTimeFormat('en-US', {
  calendar: 'gregory',
  year: 'numeric',
  month: 'long',
  era: 'short'
});
console.log(gregorian.format(date));
// "October 2024 AD"

const islamic = new Intl.DateTimeFormat('en-US', {
  calendar: 'islamic',
  year: 'numeric',
  month: 'long',
  era: 'short'
});
console.log(islamic.format(date));
// "Rabi' II 1446 AH"

const hebrew = new Intl.DateTimeFormat('en-US', {
  calendar: 'hebrew',
  year: 'numeric',
  month: 'long',
  era: 'short'
});
console.log(hebrew.format(date));
// "Tishrei 5785"

Les dates grégorienne et islamique affichent leurs indicateurs d'ère car l'option era est définie. La date hébraïque n'affiche pas d'indicateur d'ère dans ce format, car le formatage du calendrier hébraïque l'omet généralement.

Vous pouvez également combiner des locales et des calendriers pour afficher des dates dans une langue en utilisant le calendrier d'une autre culture.

const date = new Date('2024-10-15');

const englishIslamic = new Intl.DateTimeFormat('en-US', {
  calendar: 'islamic',
  year: 'numeric',
  month: 'long',
  day: 'numeric'
});
console.log(englishIslamic.format(date));
// "Rabi' II 12, 1446 AH"

const arabicIslamic = new Intl.DateTimeFormat('ar-SA', {
  calendar: 'islamic',
  year: 'numeric',
  month: 'long',
  day: 'numeric'
});
console.log(arabicIslamic.format(date));
// "١٢ ربيع الآخر ١٤٤٦ هـ"

Les deux formateurs utilisent le calendrier islamique, mais la locale anglaise produit des noms de mois en anglais et des chiffres latins tandis que la locale arabe produit des noms de mois en arabe et des chiffres arabo-indiens.

Afficher les années dans plusieurs calendriers

Les applications destinées à un public international doivent souvent afficher la même date dans plusieurs systèmes de calendrier. Vous pouvez créer plusieurs formateurs pour afficher des représentations parallèles.

const date = new Date('2024-10-15');

const calendars = [
  { name: 'Gregorian', calendar: 'gregory' },
  { name: 'Islamic', calendar: 'islamic' },
  { name: 'Hebrew', calendar: 'hebrew' },
  { name: 'Persian', calendar: 'persian' }
];

calendars.forEach(cal => {
  const formatter = new Intl.DateTimeFormat('en-US', {
    calendar: cal.calendar,
    year: 'numeric',
    month: 'long',
    day: 'numeric'
  });
  console.log(`${cal.name}: ${formatter.format(date)}`);
});

Cela produit :

Gregorian: October 15, 2024
Islamic: Rabi' II 12, 1446 AH
Hebrew: Tishrei 13, 5785
Persian: Mehr 24, 1403 AP

Chaque calendrier représente le même moment dans le temps en utilisant son propre système de comptage des années et ses indicateurs d'ère.

Cas d'usage courants

Les applications internationales doivent afficher les dates dans les systèmes de calendrier attendus par leurs utilisateurs. Une application bancaire islamique affiche les dates de transaction en utilisant le calendrier islamique.

const transactionDate = new Date('2024-10-15');

const formatter = new Intl.DateTimeFormat('ar-SA', {
  calendar: 'islamic-umalqura',
  year: 'numeric',
  month: 'long',
  day: 'numeric',
  era: 'short'
});

console.log(`Transaction date: ${formatter.format(transactionDate)}`);
// "Transaction date: ١٢ ربيع الآخر ١٤٤٦ هـ"

Les calendriers religieux déterminent les dates des fêtes et des observances. Une application de calendrier juif affiche les dates hébraïques pour les fêtes.

const roshHashanah2024 = new Date('2024-10-03');

const formatter = new Intl.DateTimeFormat('he-IL', {
  calendar: 'hebrew',
  year: 'numeric',
  month: 'long',
  day: 'numeric'
});

console.log(`Rosh Hashanah: ${formatter.format(roshHashanah2024)}`);
// "Rosh Hashanah: א׳ בתשרי ה׳תשפ״ה"

Les applications historiques affichent les dates dans les systèmes de calendrier utilisés à l'époque. Une application sur la Perse antique affiche les dates en utilisant le calendrier persan.

const historicalDate = new Date('2024-03-20');

const formatter = new Intl.DateTimeFormat('en-US', {
  calendar: 'persian',
  year: 'numeric',
  month: 'long',
  day: 'numeric',
  era: 'long'
});

console.log(`Persian New Year: ${formatter.format(historicalDate)}`);
// "Persian New Year: Farvardin 1, 1403 Anno Persico"

Résumé

Les calendriers non grégoriens comptent les années à partir de points de départ différents et utilisent des systèmes de numérotation différents. Le calendrier islamique compte à partir de l'année 622 de notre ère et affiche actuellement des années autour de 1446. Le calendrier hébraïque compte à partir de 3761 avant notre ère et affiche des années autour de 5785. Le calendrier chinois utilise un cycle de 60 ans d'années nommées au lieu de nombres séquentiels.

Le Intl.DateTimeFormat de JavaScript prend en charge ces systèmes de calendrier via l'option calendar. Les valeurs incluent islamic, hebrew, chinese, persian, et d'autres. L'option year contrôle si l'année s'affiche, et l'option era contrôle si et comment l'indicateur d'ère s'affiche.

Les calendriers qui utilisent des années nommées fournissent deux informations via formatToParts(). La partie yearName contient le nom de l'année cyclique. La partie relatedYear contient l'année grégorienne correspondante. Cela permet aux applications d'afficher l'une ou l'autre valeur, ou les deux.

Différentes locales formatent le même calendrier de différentes manières. Le calendrier islamique s'affiche en anglais avec des chiffres latins et en arabe avec des chiffres arabes-indiens. Le formatage s'adapte automatiquement aux conventions locales tout en conservant le système de numérotation des années du calendrier.