Comment afficher les indicateurs d'ère av. J.-C./apr. J.-C. ou autres ?

Introduction

La plupart des dates avec lesquelles vous travaillez se situent dans l'ère actuelle du calendrier grégorien, ce qui rend les indicateurs d'ère inutiles. Une date comme « 15 octobre 2024 » est claire sans ajouter « apr. J.-C. » à la fin. Cependant, les dates historiques remontant à plus de deux mille ans nécessitent des indicateurs d'ère pour clarifier si l'année se situe avant ou après l'an 1.

Différentes cultures utilisent également différents systèmes de calendrier avec leurs propres ères. Le calendrier japonais divise le temps en ères impériales nommées comme Reiwa et Heisei. Le calendrier bouddhiste compte les années depuis la mort de Bouddha. Le calendrier islamique possède sa propre ère commençant avec l'Hégire.

Le Intl.DateTimeFormat de JavaScript fournit une option era qui affiche ces indicateurs. L'option fonctionne à la fois avec le calendrier grégorien et d'autres systèmes de calendrier, en formatant automatiquement l'ère selon les conventions locales.

Comprendre les ères dans les systèmes de calendrier

Une ère représente une période de temps comptée à partir d'un événement significatif ou d'un point de départ. Le calendrier grégorien utilise deux ères : apr. J.-C. (Anno Domini, signifiant « en l'an de notre Seigneur ») pour les dates après l'an 1, et av. J.-C. (avant Jésus-Christ) pour les dates avant l'an 1.

L'ère devient importante lors de l'affichage de dates historiques. L'année 500 pourrait faire référence à 500 apr. J.-C. ou 500 av. J.-C., deux dates séparées de mille ans. L'ajout de l'indicateur d'ère supprime cette ambiguïté.

D'autres systèmes de calendrier définissent les ères différemment. Le calendrier japonais change d'ère à chaque règne d'empereur. Le calendrier bouddhiste utilise une seule ère commençant en 543 av. J.-C. Chaque système de calendrier possède ses propres conventions pour afficher les noms d'ère.

Afficher les indicateurs d'ère dans les dates grégoriennes

L'option era accepte trois valeurs qui contrôlent l'affichage de l'ère. La valeur long affiche le nom complet de l'ère. La valeur short affiche une forme abrégée. La valeur narrow affiche la représentation la plus compacte.

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

const long = new Intl.DateTimeFormat('en-US', {
  year: 'numeric',
  month: 'long',
  day: 'numeric',
  era: 'long'
});
console.log(long.format(date)); // "October 15, 2024 Anno Domini"

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

const narrow = new Intl.DateTimeFormat('en-US', {
  year: 'numeric',
  month: 'long',
  day: 'numeric',
  era: 'narrow'
});
console.log(narrow.format(date)); // "October 15, 2024 A"

La valeur long produit « Anno Domini » pour les dates après J.-C. La valeur short produit « AD ». La valeur narrow produit simplement « A ».

Pour les dates modernes, l'indicateur d'ère est redondant car les dates de l'ère actuelle sont supposées par défaut. Vous n'incluez généralement l'ère que lors de l'affichage de dates historiques où la distinction est importante.

Formater les dates avant J.-C. avec des indicateurs d'ère

JavaScript représente les dates avant J.-C. en utilisant des numéros d'année négatifs ou en passant des valeurs négatives au constructeur Date. L'année -500 représente 501 avant J.-C., l'année -1 représente 2 avant J.-C., et l'année 0 représente 1 avant J.-C.

const bcDate = new Date(-500, 0, 1); // January 1, 501 BC

const long = new Intl.DateTimeFormat('en-US', {
  year: 'numeric',
  month: 'long',
  day: 'numeric',
  era: 'long'
});
console.log(long.format(bcDate)); // "January 1, 501 Before Christ"

const short = new Intl.DateTimeFormat('en-US', {
  year: 'numeric',
  month: 'long',
  day: 'numeric',
  era: 'short'
});
console.log(short.format(bcDate)); // "January 1, 501 BC"

La valeur long produit « Before Christ » pour les dates avant J.-C. La valeur short produit « BC ». L'année s'affiche sous forme de nombre positif avec l'indicateur d'ère indiquant si elle se situe avant ou après l'année 1.

Les dates avant J.-C. nécessitent une manipulation prudente car l'objet Date de JavaScript présente des limitations lors du travail avec des dates très anciennes. Les dates historiques antérieures à la standardisation du calendrier grégorien en 1582 sont des approximations, et les dates antérieures à l'année 1 utilisent un système de calendrier qui n'existait pas à cette époque.

Afficher les ères dans le calendrier japonais

Le calendrier japonais utilise des ères nommées qui changent à chaque règne d'empereur. L'ère actuelle est Reiwa, qui a commencé en 2019. L'ère précédente était Heisei, qui s'est déroulée de 1989 à 2019.

Vous spécifiez le calendrier japonais en utilisant l'extension Unicode -u-ca-japanese dans l'identifiant de locale.

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

const long = new Intl.DateTimeFormat('ja-JP-u-ca-japanese', {
  year: 'numeric',
  month: 'long',
  day: 'numeric',
  era: 'long'
});
console.log(long.format(date)); // "令和6年10月15日"

const short = new Intl.DateTimeFormat('ja-JP-u-ca-japanese', {
  year: 'numeric',
  month: 'long',
  day: 'numeric',
  era: 'short'
});
console.log(short.format(date)); // "令和6年10月15日"

const narrow = new Intl.DateTimeFormat('ja-JP-u-ca-japanese', {
  year: 'numeric',
  month: 'long',
  day: 'numeric',
  era: 'narrow'
});
console.log(narrow.format(date)); // "R6年10月15日"

Les valeurs long et short affichent toutes deux "令和" (Reiwa) suivi de l'année au sein de cette ère. L'année 2024 est l'année 6 de l'ère Reiwa. La valeur narrow affiche "R" comme abréviation compacte.

L'année affichée n'est pas l'année grégorienne mais l'année au sein de l'ère impériale actuelle. Chaque ère recommence le décompte à partir de 1.

Afficher les ères dans le calendrier bouddhiste

Le calendrier bouddhiste compte les années depuis la mort de Bouddha en 543 av. J.-C. L'année bouddhiste 2567 correspond à l'année grégorienne 2024.

Vous spécifiez le calendrier bouddhiste en utilisant l'extension Unicode -u-ca-buddhist dans l'identifiant de locale.

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

const long = new Intl.DateTimeFormat('th-TH-u-ca-buddhist', {
  year: 'numeric',
  month: 'long',
  day: 'numeric',
  era: 'long'
});
console.log(long.format(date)); // "15 ตุลาคม พุทธศักราช 2567"

const short = new Intl.DateTimeFormat('th-TH-u-ca-buddhist', {
  year: 'numeric',
  month: 'long',
  day: 'numeric',
  era: 'short'
});
console.log(short.format(date)); // "15 ตุลาคม พ.ศ. 2567"

La valeur long affiche "พุทธศักราช" (ère bouddhiste) comme nom complet de l'ère. La valeur short affiche "พ.ศ." comme forme abrégée. L'année 2567 représente l'année du calendrier bouddhiste correspondant à 2024 dans le calendrier grégorien.

Le calendrier bouddhiste est couramment utilisé en Thaïlande, au Cambodge, au Laos, au Myanmar et au Sri Lanka.

Comment le formatage des ères varie selon les locales

Différentes locales utilisent différents termes et abréviations pour la même ère. Les ères du calendrier grégorien apparaissent dans la langue et le style appropriés à chaque locale.

const date = new Date('2024-10-15');
const options = {
  year: 'numeric',
  month: 'long',
  day: 'numeric',
  era: 'short'
};

const en = new Intl.DateTimeFormat('en-US', options);
console.log(en.format(date)); // "October 15, 2024 AD"

const fr = new Intl.DateTimeFormat('fr-FR', options);
console.log(fr.format(date)); // "15 octobre 2024 ap. J.-C."

const de = new Intl.DateTimeFormat('de-DE', options);
console.log(de.format(date)); // "15. Oktober 2024 n. Chr."

L'anglais utilise "AD" (Anno Domini). Le français utilise "ap. J.-C." (après Jésus-Christ). L'allemand utilise "n. Chr." (nach Christus, signifiant "après le Christ").

Le positionnement de l'indicateur d'ère suit également les conventions locales. L'anglais le place généralement après l'année, tandis que d'autres langues peuvent le positionner différemment.

const bcDate = new Date(-500, 0, 1);
const options = {
  year: 'numeric',
  month: 'long',
  day: 'numeric',
  era: 'short'
};

const en = new Intl.DateTimeFormat('en-US', options);
console.log(en.format(bcDate)); // "January 1, 501 BC"

const fr = new Intl.DateTimeFormat('fr-FR', options);
console.log(fr.format(bcDate)); // "1 janvier 501 av. J.-C."

const de = new Intl.DateTimeFormat('de-DE', options);
console.log(de.format(bcDate)); // "1. Januar 501 v. Chr."

Le français utilise "av. J.-C." (avant Jésus-Christ) pour les dates avant notre ère. L'allemand utilise "v. Chr." (vor Christus, signifiant "avant le Christ").

Cas d'usage courants

L'affichage de dates historiques nécessite des indicateurs d'ère pour éviter toute confusion.

const battleOfMarathon = new Date(-490, 8, 12); // September 12, 490 BC

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

console.log(`Battle of Marathon: ${formatter.format(battleOfMarathon)}`);
// "Battle of Marathon: September 12, 490 BC"

L'affichage de dates dans des contextes culturels utilisant différents systèmes calendaires nécessite un formatage approprié du calendrier et de l'ère.

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

const japaneseFormatter = new Intl.DateTimeFormat('ja-JP-u-ca-japanese', {
  year: 'numeric',
  month: 'long',
  day: 'numeric',
  era: 'long'
});

console.log(`Japanese date: ${japaneseFormatter.format(date)}`);
// "Japanese date: 令和6年10月15日"

Les écrits académiques ou historiques affichent souvent à la fois av. J.-C. et ap. J.-C. de manière explicite pour maintenir la cohérence à travers les périodes temporelles.

const dates = [
  new Date(-2500, 0, 1), // 2501 BC
  new Date(-500, 0, 1),  // 501 BC
  new Date(500, 0, 1),   // 500 AD
  new Date(1500, 0, 1)   // 1500 AD
];

const formatter = new Intl.DateTimeFormat('en-US', {
  year: 'numeric',
  era: 'short'
});

dates.forEach(date => {
  console.log(formatter.format(date));
});
// "2501 BC"
// "501 BC"
// "500 AD"
// "1500 AD"

Résumé

L'option era dans Intl.DateTimeFormat affiche les indicateurs d'ère comme AD, BC ou les noms d'ère d'autres systèmes calendaires. L'option accepte trois valeurs : long pour les noms d'ère complets comme "Anno Domini", short pour les abréviations comme "AD", et narrow pour la forme la plus compacte comme "A".

Les dates av. J.-C. nécessitent des nombres d'année négatifs dans le constructeur JavaScript Date. La sortie formatée affiche l'année comme un nombre positif avec l'indicateur d'ère montrant si elle se situe avant ou après l'an 1.

D'autres systèmes calendaires ont leurs propres ères. Le calendrier japonais utilise des ères impériales nommées comme Reiwa. Le calendrier bouddhiste utilise une seule ère commençant en 543 av. J.-C. Vous spécifiez le système calendaire en utilisant les extensions Unicode dans l'identifiant de langue.

Les différentes langues utilisent des termes différents pour la même ère. L'anglais utilise "AD" et "BC", le français utilise "ap. J.-C." et "av. J.-C.", et l'allemand utilise "n. Chr." et "v. Chr.". Le formateur applique automatiquement les termes et le positionnement appropriés pour chaque langue.