Temporal

Limited availability

This feature is not Baseline because it does not work in some of the most widely-used browsers.

Experimentell: Dies ist eine experimentelle Technologie
Überprüfen Sie die Browser-Kompatibilitätstabelle sorgfältig vor der Verwendung auf produktiven Webseiten.

Das Temporal Objekt ermöglicht die Verwaltung von Datum und Uhrzeit in verschiedenen Szenarien, einschließlich der integrierten Darstellung von Zeitzonen und Kalendern, Wandzeitumrechnungen, Arithmetik, Formatierung und mehr. Es ist als vollständiger Ersatz für das Date Objekt konzipiert.

Beschreibung

Im Gegensatz zu den meisten globalen Objekten ist Temporal kein Konstruktor. Sie können es nicht mit dem new Operator verwenden oder das Temporal Objekt als Funktion aufrufen. Alle Eigenschaften und Methoden von Temporal sind statisch (genauso wie das Math Objekt).

Temporal verfügt über eine komplexe und leistungsstarke API. Es stellt über 200 Hilfsmethoden über mehrere Klassen bereit, wodurch es sehr komplex erscheinen kann. Wir bieten eine Übersicht auf hoher Ebene, wie diese APIs miteinander in Beziehung stehen.

Hintergrund und Konzepte

JavaScript verfügt seit seinen frühen Tagen über das Date Objekt zur Handhabung von Datum und Uhrzeit. Die Date API basiert jedoch auf der schlecht gestalteten java.util.Date Klasse aus Java, die in den frühen 2010er Jahren ersetzt wurde; aber aufgrund von JavaScripts Ziel der Abwärtskompatibilität bleibt Date in der Sprache erhalten.

Die wichtige Lektion, die der gesamten Einführung vorausgeht, ist, dass die Handhabung von Daten komplex ist. Die meisten Probleme von Date können durch das Hinzufügen weiterer Methoden behoben werden, aber ein grundlegender Designfehler bleibt: Es werden so viele Methoden auf demselben Objekt offengelegt, dass Entwickler oft verwirrt sind, was zu unerwarteten Fallstricken führt. Eine gut gestaltete API muss nicht nur mehr tun, sondern auch weniger auf jeder Abstraktionsebene, weil die Vermeidung von Missbrauch genauso wichtig ist wie die Ermöglichung von Anwendungsfällen.

Date Objekte tragen gleichzeitig zwei Hüte:

Als ein Zeitstempel: die Anzahl der seit einem festen Zeitpunkt verstrichenen Millisekunden oder Nanosekunden (bekannt als die Epoche).
Als eine Kombination von Komponenten: Jahr, Monat, Tag, Stunde, Minute, Sekunde, Millisekunde und Nanosekunde. Die Jahr-, Monat- und Tag-Identifikatoren machen nur im Bezug auf ein Kalendersystem Sinn. Die ganze Kombination entspricht einem einzigartigen Zeitpunkt in der Geschichte, wenn sie mit einer Zeitzone verbunden ist. Date Objekte bieten Methoden zum Lesen und Ändern dieser Komponenten.

Zeitzonen sind der Grund für eine beträchtliche Anzahl datei-bezogener Fehler. Bei der Interaktion mit einem Date über das Modell der "Kombination von Komponenten" kann die Zeit nur in zwei Zeitzonen angegeben werden: UTC und lokal (Gerät), und es gibt keine Möglichkeit, eine beliebige Zeitzone anzugeben. Es fehlt auch das Konzept von "keine Zeitzone": Dies ist bekannt als ein Kalenderdatum (für Daten) oder Wandzeit (für Zeiten), was eine Zeit ist, die man "von einem Kalender oder einer Uhr abliest". Wenn Sie beispielsweise einen täglichen Wecker stellen, möchten Sie ihn auf "8:00 Uhr" einstellen, unabhängig davon, ob es sich um Sommerzeit handelt oder nicht, ob Sie in eine andere Zeitzone gereist sind usw.

Ein zweites Feature, das Date fehlt, ist ein Kalendersystem. Die meisten Menschen kennen den Gregorianischen Kalender, bei dem es zwei Epochen gibt, BC und AD; es gibt 12 Monate; jeder Monat hat eine unterschiedliche Anzahl von Tagen; es gibt alle vier Jahre ein Schaltjahr; und so weiter. Einige dieser Konzepte gelten jedoch möglicherweise nicht, wenn Sie mit einem anderen Kalendersystem arbeiten, wie dem Hebräischen Kalender, dem Chinesischen Kalender, dem Japanischen Kalender usw. Mit Date können Sie nur mit dem Modell des Gregorianischen Kalenders arbeiten.

Es gibt viele andere unerwünschte Überbleibsel des Date Objekts, wie dass alle Set-Methoden veränderlich sind (was oft unerwünschte Nebeneffekte verursacht), das Datums- und Uhrzeitzeichenfolgenformat nicht auf konsistente Weise analysiert werden kann usw. Letztendlich ist die beste Lösung, eine neue API von Grund auf zu erstellen, und das ist Temporal.

API-Übersicht

Temporal ist ein Namensraum, ähnlich wie Intl. Es enthält mehrere Klassen und Namensräume, von denen jeder auf einen bestimmten Aspekt der Verwaltung von Datum und Uhrzeit ausgelegt ist. Die Klassen können wie folgt gruppiert werden:

Darstellung einer Zeitdauer (ein Unterschied zwischen zwei Zeitpunkten): Temporal.Duration
Darstellung eines Zeitpunktes:
- Darstellung eines einzigartigen Punktes in der Geschichte:
  - Als Zeitstempel: Temporal.Instant
  - Als Kombination von Datums- und Zeitkomponenten mit einer Zeitzone: Temporal.ZonedDateTime
- Darstellung eines datums- und zeitunempfindlichen Datums/Zeit (die alle mit "Plain" beginnen):
  - Datum (Jahr, Monat, Tag) + Zeit (Stunde, Minute, Sekunde, Millisekunde, Mikrossekunde, Nanosekunde): Temporal.PlainDateTime (Hinweis: ZonedDateTime entspricht PlainDateTime plus einer Zeitzone)
    - Datum (Jahr, Monat, Tag): Temporal.PlainDate
      - Jahr, Monat: Temporal.PlainYearMonth
      - Monat, Tag: Temporal.PlainMonthDay
    - Zeit (Stunde, Minute, Sekunde, Millisekunde, Mikrosekunde, Nanosekunde): Temporal.PlainTime

Außerdem gibt es noch einen weiteren Hilfsnamensraum, Temporal.Now, der Methoden bereitstellt, um die aktuelle Zeit in verschiedenen Formaten zu erhalten.

Gemeinsame Schnittstelle der Klassen

Es gibt viele Klassen im Temporal Namensraum, aber sie teilen viele ähnliche Methoden. Die folgende Tabelle listet alle Methoden jeder Klasse auf (außer Umrechnungsmethoden):

	`Instant`	`ZonedDateTime`	`PlainDateTime`	`PlainDate`	`PlainTime`	`PlainYearMonth`	`PlainMonthDay`
Konstruktion	`Instant()` `Instant.from()` `Instant.fromEpochMilliseconds()` `Instant.fromEpochNanoseconds()`	`ZonedDateTime()` `ZonedDateTime.from()`	`PlainDateTime()` `PlainDateTime.from()`	`PlainDate()` `PlainDate.from()`	`PlainTime()` `PlainTime.from()`	`PlainYearMonth()` `PlainYearMonth.from()`	`PlainMonthDay()` `PlainMonthDay.from()`
Updater	N/A	`with()` `withCalendar()` `withTimeZone()` `withPlainTime()`	`with()` `withCalendar()` `withPlainTime()`	`with()` `withCalendar()`	`with()`	`with()`	`with()`
Arithmetik	`add()` `subtract()` `since()` `until()`	`add()` `subtract()` `since()` `until()`	`add()` `subtract()` `since()` `until()`	`add()` `subtract()` `since()` `until()`	`add()` `subtract()` `since()` `until()`	`add()` `subtract()` `since()` `until()`	N/A
Rundung	`round()`	`round()`	`round()`	N/A	`round()`	N/A	N/A
Vergleich	`equals()` `Instant.compare()`	`equals()` `ZonedDateTime.compare()`	`equals()` `PlainDateTime.compare()`	`equals()` `PlainDate.compare()`	`equals()` `PlainTime.compare()`	`equals()` `PlainYearMonth.compare()`	`equals()`
Serialisierung	`toJSON()` `toLocaleString()` `toString()` `valueOf()`	`toJSON()` `toLocaleString()` `toString()` `valueOf()`	`toJSON()` `toLocaleString()` `toString()` `valueOf()`	`toJSON()` `toLocaleString()` `toString()` `valueOf()`	`toJSON()` `toLocaleString()` `toString()` `valueOf()`	`toJSON()` `toLocaleString()` `toString()` `valueOf()`	`toJSON()` `toLocaleString()` `toString()` `valueOf()`

Die folgende Tabelle fasst zusammen, welche Eigenschaften auf jeder Klasse verfügbar sind und gibt Ihnen eine Vorstellung davon, welche Informationen jede Klasse darstellen kann.

	`Instant`	`ZonedDateTime`	`PlainDateTime`	`PlainDate`	`PlainTime`	`PlainYearMonth`	`PlainMonthDay`
Kalender	N/A	`calendarId`	`calendarId`	`calendarId`	N/A	`calendarId`	`calendarId`
Jahrbezogen	N/A	`era` `eraYear` `year` `inLeapYear` `monthsInYear` `daysInYear`	`era` `eraYear` `year` `inLeapYear` `monthsInYear` `daysInYear`	`era` `eraYear` `year` `inLeapYear` `monthsInYear` `daysInYear`	N/A	`era` `eraYear` `year` `inLeapYear` `monthsInYear` `daysInYear`	N/A
Monatsbezogen	N/A	`month` `monthCode` `daysInMonth`	`month` `monthCode` `daysInMonth`	`month` `monthCode` `daysInMonth`	N/A	`month` `monthCode` `daysInMonth`	`monthCode`
Wochenbezogen	N/A	`weekOfYear` `yearOfWeek` `daysInWeek`	`weekOfYear` `yearOfWeek` `daysInWeek`	`weekOfYear` `yearOfWeek` `daysInWeek`	N/A	N/A	N/A
Tagbezogen	N/A	`day` `dayOfWeek` `dayOfYear`	`day` `dayOfWeek` `dayOfYear`	`day` `dayOfWeek` `dayOfYear`	N/A	N/A	`day`
Zeitkomponenten	N/A	`hour` `minute` `second` `millisecond` `microsecond` `nanosecond`	`hour` `minute` `second` `millisecond` `microsecond` `nanosecond`	N/A	`hour` `minute` `second` `millisecond` `microsecond` `nanosecond`	N/A	N/A
Zeitzone	N/A	`timeZoneId` `offset` `offsetNanoseconds` `hoursInDay` `getTimeZoneTransition()` `startOfDay()`	N/A	N/A	N/A	N/A	N/A
Epoche-Zeit	`epochMilliseconds` `epochNanoseconds`	`epochMilliseconds` `epochNanoseconds`	N/A	N/A	N/A	N/A	N/A

Umwandlung zwischen Klassen

Die Tabelle unten fasst alle Umwandlungsmethoden zusammen, die auf jeder Klasse existieren.

		`Instant`	`ZonedDateTime`	`PlainDateTime`	`PlainDate`	`PlainTime`	`PlainYearMonth`	`PlainMonthDay`
		Wie wird umgewandelt von...
zu...	`Instant`	/	`toInstant()`	Erst zu `ZonedDateTime` konvertieren
	`ZonedDateTime`	`toZonedDateTimeISO()`	/	`toZonedDateTime()`	`toZonedDateTime()`	`PlainDate#toZonedDateTime()` (als Argument übergeben)	Erst zu `PlainDate` konvertieren
	`PlainDateTime`	Erst zu `ZonedDateTime` konvertieren	`toPlainDateTime()`	/	`toPlainDateTime()`	`PlainDate#toPlainDateTime()` (als Argument übergeben)	Erst zu `PlainDate` konvertieren
	`PlainDate`		`toPlainDate()`	`toPlainDate()`	/	Keine Überschneidung der Informationen	`toPlainDate()`	`toPlainDate()`
	`PlainTime`		`toPlainTime()`	`toPlainTime()`	Keine Überschneidung der Informationen	/	Keine Überschneidung der Informationen
	`PlainYearMonth`		Erst zu `PlainDate` konvertieren		`toPlainYearMonth()`	Keine Überschneidung der Informationen	/	Erst zu `PlainDate` konvertieren
	`PlainMonthDay`		Erst zu `PlainDate` konvertieren		`toPlainMonthDay()`	Keine Überschneidung der Informationen	Erst zu `PlainDate` konvertieren	/

Mit diesen Tabellen sollten Sie eine grundlegende Vorstellung davon haben, wie man die Temporal API navigiert.

Kalender

Ein Kalender ist eine Möglichkeit, Tage zu organisieren, typischerweise in Perioden von Wochen, Monaten, Jahren und Epochen. Der größte Teil der Welt verwendet den Gregorianischen Kalender, aber es gibt viele andere Kalender, die besonders in religiösen und kulturellen Kontexten verwendet werden. Standardmäßig verwenden alle kalenderfähigen Temporal Objekte das ISO 8601 Kalendersystem, das auf dem Gregorianischen Kalender basiert und zusätzliche Regeln zur Wochenzählung definiert. Intl.supportedValuesOf() listet die meisten Kalender auf, die wahrscheinlich von Browsern unterstützt werden. Hier geben wir eine kurze Übersicht darüber, wie Kalendersysteme gebildet werden, um Ihnen zu helfen, sich einzuprägen, welche Faktoren zwischen Kalendern variieren können.

Es gibt drei herausragende periodische Ereignisse auf der Erde: ihre Rotation um die Sonne (365,242 Tage für eine Umdrehung), die Rotation des Mondes um die Erde (29,53 Tage von Neumond zu Neumond) und ihre Rotation um ihre Achse (24 Stunden von Sonnenaufgang zu Sonnenaufgang). Jede Kultur hat das gleiche Maß für einen "Tag", der 24 Stunden beträgt. Gelegentliche Änderungen wie Sommerzeit sind nicht Bestandteil des Kalenders, sondern gehören zur Zeitzonen Information.

Einige Kalender definieren primär ein Jahr als im Durchschnitt 365,242 Tage, indem Jahre auf 365 Tage definiert werden und etwa alle 4 Jahre ein zusätzlicher Tag, der Schalttag, hinzugefügt wird. Das Jahr kann dann weiter in Teile, die Monate genannt werden, unterteilt werden. Diese Kalender werden Sonnenkalender genannt. Der Gregorianische Kalender und der Solar Hijri Kalender sind Sonnenkalender.
Einige Kalender definieren primär einen Monat als im Durchschnitt 29,5 Tage, indem Monate abwechselnd 29 und 30 Tage lang sind. Dann können 12 Monate zu einem Jahr von 354 Tagen gruppiert werden. Diese Kalender werden Mondkalender genannt. Der Islamische Kalender ist ein Mondkalender. Weil ein Mondjahr künstlich ist und nicht mit dem Saisonzyklus korreliert, sind Mondkalender im Allgemeinen seltener.
Einige Kalender definieren Monate auch primär basierend auf Mondzyklen, wie Mondkalender. Dann wird etwa alle 3 Jahre ein zusätzlicher Monat, der Schaltmonat, hinzugefügt, um die 11-Tage-Diskrepanz mit dem Sonnenjahr auszugleichen. Diese Kalender werden lunisolare Kalender genannt. Der Hebräische Kalender und der Chinesische Kalender sind lunisolare Kalender.

In Temporal wird jedes Datum unter einem Kalendersystem eindeutig durch drei Komponenten identifiziert: year, month und day. Während year typischerweise eine positive ganze Zahl ist, kann es auch null oder negativ sein und erhöht sich monoton mit der Zeit. Das Jahr 1 (oder 0, wenn es existiert) ist als die Kalenderepoch bekannt und ist für jeden Kalender willkürlich. month ist eine positive ganze Zahl, die bei jedem Mal um 1 größer wird, beginnend bei 1 und endend bei date.monthsInYear, dann wieder zurückgesetzt auf 1, während das Jahr voranschreitet. day ist auch eine positive ganze Zahl, aber es kann nicht jedes Mal bei 1 beginnen oder um 1 zunehmen, da politische Veränderungen dazu führen können, dass Tage übersprungen oder wiederholt werden. Aber im Allgemeinen erhöht sich day monoton und wird zurückgesetzt, während der Monat voranschreitet.

Zusätzlich zuyear kann ein Jahr auch durch die Kombination von era und eraYear eindeutig identifiziert werden, für Kalender, die Epochen verwenden. Beispielsweise verwendet der Gregorianische Kalender die Epoche "CE" (Common Era) und "BCE" (Before Common Era), und das Jahr -1 ist dasselbe wie { era: "bce", eraYear: 2 } (beachten Sie, dass das Jahr 0 immer für alle Kalender existiert; für den Gregorianischen Kalender entspricht es 1 v. Chr. aufgrund astronomischer Jahreszählung). era ist eine Kleinbuchstaben-Zeichenfolge, und eraYear ist eine willkürliche ganze Zahl, die null oder negativ sein kann, oder sogar mit der Zeit abnehmen kann (normalerweise für die älteste Epoche).

Hinweis: Verwenden Sie immer era und eraYear im Paar; verwenden Sie keine Eigenschaft ohne die andere. Um Konflikte zu vermeiden, kombinieren Sie nicht year und era/eraYear, um ein Jahr zu bestimmen. Entscheiden Sie sich für eine Jahresdarstellung und verwenden Sie sie konsequent.

Vorsicht vor den folgenden falschen Annahmen über Jahre:

Nehmen Sie nicht an, dass era und eraYear immer vorhanden sind; sie können undefined sein.
Nehmen Sie nicht an, dass era eine benutzerfreundliche Zeichenfolge ist; verwenden Sie toLocaleString(), um Ihr Datum zu formatieren.
Nehmen Sie nicht an, dass zwei year Werte aus verschiedenen Kalendern vergleichbar sind; verwenden Sie die statische Methode compare().
Nehmen Sie nicht an, dass Jahre 365/366 Tage und 12 Monate haben; verwenden Sie stattdessen daysInYear und monthsInYear.
Nehmen Sie nicht an, dass Schaltjahre (inLeapYear ist true) einen zusätzlichen Tag haben; sie können einen zusätzlichen Monat haben.

Zusätzlich zu month kann ein Monat in einem Jahr ebenfalls durch den monthCode eindeutig identifiziert werden. monthCode entspricht normalerweise dem Namen des Monats, month jedoch nicht. Beispielsweise haben bei lunisolarischen Kalendern zwei Monate mit dem gleichen monthCode, von denen einer zu einem Schaltjahr gehört und der andere nicht, unterschiedliche month Werte, wenn sie nach dem Schaltmonat kommen, aufgrund der Einfügung eines zusätzlichen Monats.

Hinweis: Um Konflikte zu vermeiden, kombinieren Sie nicht month und monthCode, um einen Monat zu bestimmen. Entscheiden Sie sich für eine Monatsdarstellung und verwenden Sie sie konsequent. month ist nützlicher, wenn Sie die Reihenfolge der Monate in einem Jahr benötigen (z. B. beim Durchlaufen der Monate), während monthCode nützlicher ist, wenn Sie den Namen des Monats benötigen (z. B. beim Speichern von Geburtstagen).

Vorsicht vor den folgenden falschen Annahmen über Monate:

Nehmen Sie nicht an, dass monthCode und month immer übereinstimmen.
Nehmen Sie nicht die Anzahl der Tage in einem Monat an; verwenden Sie stattdessen daysInMonth.
Nehmen Sie nicht an, dass monthCode eine benutzerfreundliche Zeichenfolge ist; verwenden Sie toLocaleString(), um Ihr Datum zu formatieren.
Allgemein sollten Sie den Namen der Monate nicht in einem Array oder Objekt zwischenspeichern. Auch wenn monthCode normalerweise innerhalb eines Kalenders zum Namen des Monats passt, empfehlen wir, den Namen des Monats immer mit, zum Beispiel, date.toLocaleString("de-DE", { calendar: date.calendarId, month: "long" }) zu berechnen.

Zusätzlich zu day (das ein monatlicher Index ist) kann ein Tag in einem Jahr auch eindeutig durch dayOfYear identifiziert werden. dayOfYear ist eine positive ganze Zahl, die jedes Mal um 1 erhöht wird, beginnend bei 1 und endend bei date.daysInYear.

Das Konzept einer "Woche" ist mit keinem astronomischen Ereignis verbunden, sondern ein kulturelles Konstrukt. Während die häufigste Länge 7 Tage beträgt, können Wochen auch 4, 5, 6, 8 oder mehr Tage haben - oder sogar ganz ohne feste Anzahl von Tagen auskommen. Um die spezifische Anzahl an Tagen einer Woche eines Datums zu erhalten, verwenden Sie daysInWeek des Datums. Temporal identifiziert Wochen durch die Kombination von weekOfYear und yearOfWeek. weekOfYear ist eine positive ganze Zahl, die jedes Mal um 1 erhöht wird, beginnend bei 1, dann wieder auf 1 zurückgesetzt wird, während das Jahr voranschreitet. yearOfWeek ist im Allgemeinen dasselbe wie year, kann jedoch am Anfang oder Ende eines jeden Jahres unterschiedlich sein, da eine Woche zwei Jahre überschreiten kann, und yearOfWeek eines der beiden Jahre basierend auf den Regeln des Kalenders auswählt.

Hinweis: Verwenden Sie immer weekOfYear und yearOfWeek im Paar; verwenden Sie nicht weekOfYear und year.

Vorsicht vor den folgenden falschen Annahmen über Wochen:

Nehmen Sie nicht an, dass weekOfYear und yearOfWeek immer vorhanden sind; sie können undefined sein.
Nehmen Sie nicht an, dass Wochen immer 7 Tage lang sind; verwenden Sie stattdessen daysInWeek.
Beachten Sie, dass die aktuelle Temporal API keine Jahres-Wochen-Daten unterstützt, sodass Sie keine Daten mit diesen Eigenschaften erstellen oder Daten in Jahres-Wochen-Darstellungen serialisieren können. Sie sind nur informative Eigenschaften.

RFC 9557 Format

Alle Temporal Klassen können unter Verwendung des im RFC 9557 spezifizierten Formats serialisiert und deserialisiert werden, das auf ISO 8601 / RFC 3339 basiert. Das Format, in seiner vollständigen Form, ist wie folgt (Leerzeichen sind nur zur Lesbarkeit da und sollten im tatsächlichen String nicht vorhanden sein):

YYYY-MM-DD T HH:mm:ss.sssssssss Z/±HH:mm [time_zone_id] [u-ca=calendar_id]

Unterschiedliche Klassen haben unterschiedliche Anforderungen an das Vorhandensein jeder Komponente, daher finden Sie in der Dokumentation jeder Klasse einen Abschnitt mit dem Titel "RFC 9557 Format", der das von dieser Klasse anerkannte Format spezifiziert.

Dies ist dem Datums- und Uhrzeitzeichenformat ähnlich, das von Date verwendet wird, das ebenfalls auf ISO 8601 basiert. Die Haupterweiterung ist die Möglichkeit, Mikro- und Nanosekundenkomponenten anzugeben, sowie die Möglichkeit, das Zeitzonen- und Kalendersystem anzugeben.

Darstellbare Daten

Alle Temporal Objekte, die ein bestimmtes Kalenderdatum darstellen, legen ein ähnliches Limit für den Bereich der darstellbaren Daten fest, das ±10⁸ Tage (einschließlich) von der Unix-Epoche, oder den Bereich der Momente von -271821-04-20T00:00:00 bis +275760-09-13T00:00:00. Dies entspricht dem gleichen Bereich wie gültige Daten. Genauer gesagt:

Temporal.Instant und Temporal.ZonedDateTime wenden dieses Limit direkt auf ihren epochNanoseconds Wert an.
Temporal.PlainDateTime interpretiert Datum und Uhrzeit in der UTC-Zeitzone und erfordert, dass sie ±(10⁸ + 1) Tage (exklusiv) von der Unix-Epoche entfernt sind, sodass ihr gültiger Bereich -271821-04-19T00:00:00 bis +275760-09-14T00:00:00, exklusiv ist. Dies ermöglicht es, dass jedes ZonedDateTime in ein PlainDateTime umgewandelt werden kann, unabhängig von seinem Offset.
Temporal.PlainDate wendet den gleichen Check wie PlainDateTime auf den Mittag (12:00:00) dieses Datums an, sodass ihr gültiger Bereich -271821-04-19 bis +275760-09-13 ist. Dies ermöglicht es, dass jedes PlainDateTime in ein PlainDate umgewandelt werden kann, unabhängig von seiner Zeit, und umgekehrt.
Temporal.PlainYearMonth hat den gültigen Bereich von -271821-04 bis +275760-09. Dies ermöglicht es, dass jedes PlainDate in ein PlainYearMonth umgewandelt werden kann, unabhängig von seinem Datum (außer wenn der erste Tag eines nicht-ISO-Monats in den ISO-Monat -271821-03 fällt).

Die Temporal Objekte werden sich weigern, eine Instanz zu erstellen, die ein Datum/Zeit jenseits dieses Limits darstellt. Dies schließt ein:

Verwendung des Konstruktors oder der from() statischen Methode.
Verwendung der with() Methode zum Aktualisieren von Kalenderfeldern.
Verwendung von add(), subtract(), round(), oder anderen Methoden zur Ableitung neuer Instanzen.

Statische Eigenschaften

Temporal.Duration Experimentell: Stellt einen Unterschied zwischen zwei Zeitpunkten dar, der in der Datums-/Zeitarithmetik verwendet werden kann. Es wird grundlegend als eine Kombination von Jahren, Monaten, Wochen, Tagen, Stunden, Minuten, Sekunden, Millisekunden, Mikrosekunden und Nanosekunden Werten dargestellt.
Temporal.Instant Experimentell: Stellt einen einzigartigen Moment in der Zeit dar, mit Nanosekunden-Genauigkeit. Es wird grundlegend als die Anzahl der Nanosekunden seit der Unix-Epoche (Mitternacht zu Beginn des 1. Januar 1970, UTC) dargestellt, ohne Zeitzonen- oder Kalendersystem.
Temporal.Now Experimentell: Bietet Methoden, um die aktuelle Zeit in verschiedenen Formaten zu erhalten.
Temporal.PlainDate Experimentell: Stellt ein Kalenderdatum (ein Datum ohne Zeit oder Zeitzone) dar; zum Beispiel ein Ereignis im Kalender, das den ganzen Tag über passiert, egal welche Zeitzone gilt. Es wird grundlegend als ein ISO 8601 Kalenderdatum dargestellt, mit Jahr, Monat und Tag Feldern, und einem zugeordneten Kalendersystem.
Temporal.PlainDateTime Experimentell: Stellt ein Datum (Kalenderdatum) und eine Zeit (Wandzeit) ohne Zeitzone dar. Es wird grundlegend als eine Kombination aus einem Datum (mit einem zugeordneten Kalendersystem) und einer Zeit dargestellt.
Temporal.PlainMonthDay Experimentell: Stellt den Monat und den Tag eines Kalenderdatums dar, ohne Jahr oder Zeitzone; zum Beispiel ein sich jährlich wiederholendes Ereignis, das den ganzen Tag über passiert. Es wird grundlegend als ein ISO 8601 Kalenderdatum dargestellt, mit Jahr, Monat und Tag Feldern, und einem zugeordneten Kalendersystem. Das Jahr wird verwendet, um den Monat-Tag in nicht-ISO-Kalendersystemen zu spezifizieren.
Temporal.PlainTime Experimentell: Stellt eine Zeit ohne Datum oder Zeitzone dar; zum Beispiel ein sich wiederholendes Ereignis, das jeden Tag zur gleichen Zeit stattfindet. Es wird grundlegend als eine Kombination von Stunde, Minute, Sekunde, Millisekunde, Mikrosekunde und Nanosekunde Werten dargestellt.
Temporal.PlainYearMonth Experimentell: Stellt das Jahr und den Monat eines Kalenderdatums dar, ohne Tag oder Zeitzone; zum Beispiel ein Ereignis im Kalender, das den ganzen Monat über passiert. Es wird grundlegend als ein ISO 8601 Kalenderdatum dargestellt, mit Jahr, Monat und Tag Feldern, und einem zugeordneten Kalendersystem. Der Tag wird verwendet, um das Jahr-Monat in nicht-ISO-Kalendersystemen zu spezifizieren.
Temporal.ZonedDateTime Experimentell: Stellt ein Datum und eine Uhrzeit mit einer Zeitzone dar. Es wird grundlegend als eine Kombination aus einem Zeitpunkt, einer Zeitzone, und einem Kalendersystem dargestellt.
Temporal[Symbol.toStringTag]: Der Anfangswert der [Symbol.toStringTag] Eigenschaft ist der String "Temporal". Diese Eigenschaft wird in Object.prototype.toString() verwendet.

Spezifikationen

Specification
Temporal # sec-temporal-objects