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, faisant 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 traditionnelle de création 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'API 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 permet de sélectionner 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() donne 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 façons fondamentales : où ils commencent à compter, comment ils numérotent les années, et s'ils utilisent des ères.

Le calendrier grégorien commence à compter à partir de l'an 1 de notre ère et s'incrémente séquentiellement. Le calendrier islamique commence à partir de l'an 1 AH (Après l'Hégire) en 622 de notre ère. Le calendrier hébraïque commence à partir de l'an 1 en 3761 avant notre ère. Chaque calendrier a 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 des 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 recommence.

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 de notre ère. L'an 1 islamique correspond à l'an 622 du calendrier grégorien. 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 alors que 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 des 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 arabo-indiens 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 "dans 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 différents numéros de jour 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 traditionnelle de création 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 dans la locale hébraïque utilisent des chiffres et des noms de mois hébraïques.

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 dans le calendrier chinois

Le calendrier chinois utilise un cycle de 60 ans d'années nommées au lieu de numéros d'années séquentiels. Chaque année du cycle a 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.

Comme le calendrier chinois utilise des années nommées, son affichage nécessite une gestion différente des calendriers avec des numéros d'années 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)"

Le résultat formaté 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 cyclique de l'année et l'année grégorienne correspondante.

Les dates chinoises dans la 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 correspondante

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 des parties comprend deux entrées pertinentes :

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

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

Vous pouvez extraire ces parties pour créer des affichages de date 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 n'importe quel calendrier qui utilise des années nommées ou des cycles.

Afficher les années dans le calendrier persan

Le calendrier persan, également connu sous le nom de calendrier solaire hijri, compte les années à partir de l'Hégire en 622 EC, 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 et des noms de mois persans.

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 hijri.

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 mélanger les locales et les 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 à travers plusieurs calendriers

Les applications qui servent un public international doivent souvent afficher la même date dans plusieurs systèmes de calendrier. Vous pouvez créer plusieurs formateurs pour montrer 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'utilisation courants

Les applications internationales doivent afficher les dates dans les systèmes de calendrier que leurs utilisateurs attendent. 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 l'ancienne Perse 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 différents points de départ et utilisent différents systèmes de numérotation. Le calendrier islamique compte à partir de l'an 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 numéros séquentiels.

L'API Intl.DateTimeFormat de JavaScript prend en charge ces systèmes de calendrier grâce à 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 cyclique de l'année. 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 façons. Le calendrier islamique s'affiche en anglais avec des chiffres latins et en arabe avec des chiffres arabo-indiens. Le formatage s'adapte automatiquement aux conventions locales tout en maintenant le système de numérotation des années du calendrier.