Wie zeige ich Jahr und Ära in nicht-gregorianischen Kalendern an?

Einführung

Der gregorianische Kalender zählt Jahre von einem einzigen Startpunkt aus, wodurch das Jahr 2024 eine einfache Zahl ist. Andere Kalendersysteme zählen Jahre unterschiedlich. Der islamische Kalender zählt ab dem Jahr 622 n. Chr. Der hebräische Kalender zählt von einem traditionellen Schöpfungsdatum vor Tausenden von Jahren. Der chinesische Kalender verwendet einen 60-jährigen Zyklus benannter Jahre anstelle von fortlaufenden Zahlen.

Diese unterschiedlichen Zählsysteme bedeuten, dass derselbe Zeitpunkt in verschiedenen Kalendern unterschiedliche Jahresdarstellungen hat. Der 15. Oktober 2024 im gregorianischen Kalender ist das Jahr 1446 im islamischen Kalender, das Jahr 5785 im hebräischen Kalender und das Jahr 2024 (甲辰, jiǎ-chén) im chinesischen Kalender.

JavaScripts Intl.DateTimeFormat bietet Optionen zur Anzeige von Jahren und Epochen aus jedem Kalendersystem. Die Option calendar wählt aus, welcher Kalender verwendet werden soll. Die Optionen year und era steuern, wie das Jahr und die Epoche angezeigt werden. Für Kalender, die benannte Jahre anstelle von Zahlen verwenden, bietet die Methode formatToParts() Zugriff sowohl auf den Jahresnamen als auch auf das entsprechende gregorianische Jahr.

Wie sich Jahre in verschiedenen Kalendersystemen unterscheiden

Kalendersysteme unterscheiden sich in drei grundlegenden Aspekten: wo sie zu zählen beginnen, wie sie Jahre nummerieren und ob sie Epochen verwenden.

Der gregorianische Kalender beginnt mit dem Jahr 1 n. Chr. und zählt sequentiell weiter. Der islamische Kalender beginnt mit dem Jahr 1 AH (After Hijra) im Jahr 622 n. Chr. Der hebräische Kalender beginnt mit dem Jahr 1 im Jahr 3761 v. Chr. Jeder Kalender hat seinen eigenen Epochenbeginn, den Punkt, an dem die Jahreszählung beginnt.

Einige Kalender verwenden sequentielle Jahreszahlen, die immer weiter steigen. Der gregorianische, islamische, hebräische und persische Kalender funktionieren auf diese Weise. Andere Kalender verwenden Zyklen, bei denen sich Jahresnamen wiederholen. Der chinesische Kalender verwendet einen 60-jährigen Zyklus benannter Jahre. Nach 60 Jahren wiederholt sich der Zyklus.

Epochen teilen die Zeit in benannte Perioden ein. Der gregorianische Kalender verwendet v. Chr. und n. Chr. Der japanische Kalender verwendet kaiserliche Epochennamen. Der islamische und hebräische Kalender verwenden typischerweise eine einzige Epoche, die mit ihrem Epochenbeginn begann. Der chinesische Kalender verwendet Epochen nicht auf die gleiche Weise und verlässt sich stattdessen auf benannte Jahre innerhalb von Zyklen.

Jahre im islamischen Kalender anzeigen

Der islamische Kalender zählt die Jahre ab der Hidschra, Mohammeds Migration von Mekka nach Medina im Jahr 622 n. Chr. Das islamische Jahr 1 entspricht dem gregorianischen Jahr 622. Der islamische Kalender verwendet Mondmonate, wodurch seine Jahre kürzer als gregorianische Jahre sind. Dies bedeutet, dass das islamische Jahr schneller voranschreitet und aktuell das Jahr 1446 erreicht, während das gregorianische Jahr 2024 ist.

Sie können den islamischen Kalender mit der Option calendar und dem Wert islamic angeben oder indem Sie die Unicode-Erweiterung -u-ca-islamic zur Gebietsschema-Kennung hinzufügen.

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"

Das Jahr wird als 1446 angezeigt, was dem islamischen Jahr entspricht, das dem 15. Oktober 2024 entspricht. Die Ära "AH" (After Hijra) erscheint automatisch bei der Anzeige islamischer Daten auf Englisch.

Verschiedene Gebietsschemas formatieren islamische Daten gemäß ihren Konventionen.

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));
// "١٢ ربيع الآخر ١٤٤٦ هـ"

Das arabische Gebietsschema verwendet arabisch-indische Ziffern und zeigt den Monatsnamen auf Arabisch an. Die Ära-Angabe ändert sich zu "هـ" (die arabische Abkürzung für Hidschri).

Steuerung der Ära-Anzeige im islamischen Kalender

Die Option era steuert, ob und wie die Ära-Angabe angezeigt wird. Die Option akzeptiert drei Werte: long für den vollständigen Ära-Namen, short für eine Abkürzung und narrow für die kompakteste Form.

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"

Der Wert long erzeugt "Anno Hegirae" (Lateinisch für "im Jahr der Hidschra"). Der Wert short erzeugt "AH". Der Wert narrow erzeugt nur "A".

Varianten des islamischen Kalenders

Der islamische Kalender hat mehrere Varianten, die unterschiedliche Berechnungsmethoden verwenden. JavaScript unterstützt fünf Varianten: islamic, islamic-civil, islamic-tbla, islamic-umalqura und islamic-rgsa.

Die Variante islamic-umalqura verwendet den offiziellen Kalender von Saudi-Arabien, der auf astronomischen Beobachtungen basiert. Die Variante islamic-civil verwendet eine feste arithmetische Berechnung mit abwechselnd 29 und 30 Tagen pro Monat.

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"

Die Varianten können unterschiedliche Tageszahlen für dasselbe gregorianische Datum erzeugen, da sie verschiedene Berechnungsmethoden zur Bestimmung der Monatsgrenzen verwenden.

Jahre im hebräischen Kalender anzeigen

Der hebräische Kalender zählt die Jahre ab einem traditionellen Schöpfungsdatum im Jahr 3761 v. Chr. Dies macht hebräische Jahre viel größer als gregorianische Jahre. Das hebräische Jahr 5785 entspricht dem gregorianischen Jahr 2024.

Sie spezifizieren den hebräischen Kalender mit der Option calendar und dem Wert hebrew oder indem Sie die Unicode-Erweiterung -u-ca-hebrew zur Locale-Kennung hinzufügen.

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"

Das Jahr wird als 5785 angezeigt, was dem hebräischen Jahr entspricht, das dem 15. Oktober 2024 entspricht. Der hebräische Kalender ist lunisolar, was bedeutet, dass seine Monate dem Mond folgen, aber seine Jahre durch periodische Schaltmonate mit dem Sonnenjahr synchronisiert bleiben.

Hebräische Datumsangaben in hebräischer Sprache verwenden hebräische Ziffern und Monatsnamen.

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));
// "י״ג בתשרי ה׳תשפ״ה"

Die hebräische Locale zeigt das Datum vollständig auf Hebräisch an, einschließlich hebräischer Buchstaben, die als Ziffern verwendet werden.

Jahre im chinesischen Kalender anzeigen

Der chinesische Kalender verwendet einen 60-Jahres-Zyklus mit benannten Jahren anstelle von fortlaufenden Jahreszahlen. Jedes Jahr im Zyklus hat einen Namen, der aus zwei Zeichen besteht: einem himmlischen Stamm und einem irdischen Zweig. Das Jahr 2024 ist 甲辰 (jiǎ-chén), was in der traditionellen chinesischen Astrologie "Holzdrache" bedeutet.

Da der chinesische Kalender benannte Jahre verwendet, erfordert die Anzeige eine andere Handhabung als Kalender mit fortlaufenden Jahreszahlen.

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)"

Die formatierte Ausgabe enthält sowohl das gregorianische Jahr 2024 als auch den Jahresnamen "jiǎ-chén" in Klammern. Diese duale Darstellung hilft Benutzern, sowohl den zyklischen Jahresnamen als auch das entsprechende gregorianische Jahr zu verstehen.

Chinesische Datumsangaben in chinesischer Sprache werden mit chinesischen Schriftzeichen angezeigt.

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甲辰年九月十三"

Die chinesische Spracheinstellung zeigt den Jahresnamen mit chinesischen Schriftzeichen an. Das Format integriert den Jahresnamen auf natürliche Weise in die Datumszeichenfolge.

Jahresname und zugehöriges Jahr extrahieren

Kalender, die benannte Jahre verwenden, liefern zwei Informationen: den Jahresnamen innerhalb des Zyklus und das entsprechende gregorianische Jahr. Die Methode formatToParts() trennt diese in verschiedene Teile.

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);

Das parts-Array enthält zwei relevante Einträge:

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

Der Teil relatedYear enthält das vierstellige gregorianische Jahr. Der Teil yearName enthält den zyklischen Jahresnamen. Diese Trennung ermöglicht es Ihnen, einen oder beide Werte in benutzerdefinierten Formatierungen zu verwenden.

Sie können diese Teile extrahieren, um benutzerdefinierte Datumsanzeigen zu erstellen.

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"

Diese Technik funktioniert mit jedem Kalender, der benannte Jahre oder Zyklen verwendet.

Jahre im persischen Kalender anzeigen

Der persische Kalender, auch bekannt als Solar-Hijri-Kalender, zählt die Jahre ab der Hidschra im Jahr 622 n. Chr., dem gleichen Ausgangspunkt wie der islamische Kalender. Der persische Kalender verwendet jedoch Sonnenmonate anstelle von Mondmonaten, was ihn in seiner Struktur dem gregorianischen Kalender ähnlicher macht.

Sie können den persischen Kalender mit der Option calendar und dem Wert persian oder durch Hinzufügen der Unicode-Erweiterung -u-ca-persian zur Gebietsschema-ID angeben.

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"

Das Jahr wird als 1403 angezeigt, was dem persischen Jahr entspricht, das dem 15. Oktober 2024 entspricht. Die Ära "AP" (Anno Persico) erscheint im englischen Format.

Persische Datumsangaben im persischen Gebietsschema verwenden persische Ziffern und Monatsnamen.

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));
// "۲۴ مهر ۱۴۰۳ ه‍.ش."

Das persische Gebietsschema zeigt das Datum mit persischen (Farsi) Zeichen und Ziffern an. Der Äraindikator "ه‍.ش." ist die persische Abkürzung für die Solar-Hidschra-Ära.

Kalender- und Äraoptionen kombinieren

Sie können die Optionen calendar und era kombinieren, um genau zu steuern, wie Jahre und Ären in verschiedenen Kalendersystemen angezeigt werden. Diese Kombination gibt Ihnen präzise Kontrolle über die Datumsformatierung.

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"

Die gregorianischen und islamischen Daten zeigen ihre Äraindikatoren an, da die Option era gesetzt ist. Das hebräische Datum zeigt in diesem Format keinen Äraindikator an, da die hebräische Kalenderformatierung diesen typischerweise weglässt.

Sie können auch Gebietsschemas und Kalender mischen, um Daten in einer Sprache mit dem Kalender einer anderen Kultur anzuzeigen.

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));
// "١٢ ربيع الآخر ١٤٤٦ هـ"

Beide Formatierer verwenden den islamischen Kalender, aber das englische Gebietsschema erzeugt englische Monatsnamen und lateinische Ziffern, während das arabische Gebietsschema arabische Monatsnamen und arabisch-indische Ziffern erzeugt.

Jahre in mehreren Kalendersystemen anzeigen

Anwendungen, die internationale Zielgruppen bedienen, müssen oft dasselbe Datum in mehreren Kalendersystemen anzeigen. Sie können mehrere Formatierer erstellen, um parallele Darstellungen zu zeigen.

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)}`);
});

Dies erzeugt:

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

Jeder Kalender stellt denselben Zeitpunkt mit seinem eigenen Jahreszählsystem und Zeitrechnungsindikatoren dar.

Häufige Anwendungsfälle

Internationale Anwendungen müssen Datumsangaben in den Kalendersystemen anzeigen, die ihre Benutzer erwarten. Eine islamische Banking-Anwendung zeigt Transaktionsdaten im islamischen Kalender an.

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: ١٢ ربيع الآخر ١٤٤٦ هـ"

Religiöse Kalender bestimmen die Daten von Feiertagen und Gedenktagen. Eine jüdische Kalenderanwendung zeigt hebräische Daten für Feiertage an.

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: א׳ בתשרי ה׳תשפ״ה"

Historische Anwendungen zeigen Daten in den Kalendersystemen an, die zu dieser Zeit verwendet wurden. Eine Anwendung über das antike Persien zeigt Daten im persischen Kalender an.

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"

Zusammenfassung

Nicht-gregorianische Kalender zählen Jahre von unterschiedlichen Ausgangspunkten und verwenden verschiedene Nummerierungssysteme. Der islamische Kalender zählt ab dem Jahr 622 n. Chr. und zeigt derzeit Jahre um 1446 an. Der hebräische Kalender zählt ab 3761 v. Chr. und zeigt Jahre um 5785 an. Der chinesische Kalender verwendet einen 60-jährigen Zyklus benannter Jahre anstelle von fortlaufenden Zahlen.

JavaScripts Intl.DateTimeFormat unterstützt diese Kalendersysteme durch die Option calendar. Werte umfassen islamic, hebrew, chinese, persian und andere. Die Option year steuert, ob das Jahr angezeigt wird, und die Option era steuert, ob und wie die Ära-Anzeige dargestellt wird.

Kalender, die benannte Jahre verwenden, liefern zwei Informationen durch formatToParts(). Der Teil yearName enthält den zyklischen Jahresnamen. Der Teil relatedYear enthält das entsprechende gregorianische Jahr. Dies ermöglicht Anwendungen, einen oder beide Werte anzuzeigen.

Verschiedene Sprachen formatieren denselben Kalender auf unterschiedliche Weise. Der islamische Kalender wird auf Englisch mit lateinischen Ziffern und auf Arabisch mit arabisch-indischen Ziffern angezeigt. Die Formatierung passt sich automatisch an die Konventionen der jeweiligen Sprache an, während das Nummerierungssystem des Kalenders beibehalten wird.