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 Zeitzonen- und Kalenderdarstellung, Wanduhren-Zeitumwandlungen, Arithmetik, Formatierungen und mehr. Es wurde als vollständiger Ersatz für das Date Objekt entworfen.

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 leistungsfähige API. Es stellt über 200 Hilfsmethoden über mehrere Klassen zur Verfügung, was zunächst sehr komplex erscheinen kann. Wir bieten Ihnen einen Überblick darüber, wie diese APIs zueinander in Beziehung stehen.

Hintergrund und Konzepte

JavaScript verfügt seit seinen Anfängen über das Date Objekt zur Handhabung von Datum und Uhrzeit. Allerdings basiert die Date API auf der schlecht entworfenen java.util.Date Klasse aus Java, die in den frühen 2010er Jahren ersetzt wurde. Aufgrund des Ziels von JavaScript, die Rückwärtskompatibilität zu wahren, bleibt Date weiterhin in der Sprache bestehen.

Die wichtige Lektion, die der gesamten Einführung vorangestellt werden muss, ist, dass das Arbeiten mit Daten komplex ist. Die meisten Probleme von Date lassen sich durch das Hinzufügen weiterer Methoden beheben, aber ein grundlegender Designfehler bleibt: Es werden so viele Methoden auf demselben Objekt bereitgestellt, dass Entwickler oft verwirrt darüber sind, was sie verwenden sollen, was zu unerwarteten Fallstricken führt. Eine gut gestaltete API sollte nicht nur mehr können, sondern auch weniger auf jeder Abstraktionsebene tun, denn die Vermeidung von Missbrauch ist genauso wichtig wie die Ermöglichung von Anwendungsfällen.

Date Objekte tragen gleichzeitig zwei "Hüte":

Als Zeitstempel: die Anzahl der Millisekunden oder Nanosekunden, die seit einem festen Zeitpunkt (bekannt als Epoch) vergangen sind.
Als Kombination von Komponenten: Jahr, Monat, Tag, Stunde, Minute, Sekunde, Millisekunde und Nanosekunde. Die Identifikatoren für Jahr, Monat und Tag machen nur im Zusammenhang mit einem Kalendersystem Sinn. Die gesamte Kombination entspricht einem einzigartigen Moment in der Geschichte, wenn sie mit einer Zeitzone verbunden ist. Date Objekte bieten Methoden zum Lesen und Ändern dieser Komponenten.

Zeitzonen sind die Ursache einer Vielzahl von datumsbezogenen Fehlern. Bei der Interaktion mit einem Date über das "Kombination der Komponenten"-Modell kann die Zeit nur in zwei Zeitzonen vorhanden sein: UTC und lokal (auf dem Gerät) und es gibt keine Möglichkeit, eine beliebige Zeitzone anzugeben. Außerdem fehlt das Konzept von "keine Zeitzone": Dies wird als Kalenderdatum (für Daten) oder Wanduhrzeit (für Zeiten) bezeichnet, was eine Zeit ist, die Sie "von einem Kalender oder einer Uhr ablesen". Zum Beispiel, wenn Sie einen täglichen Wecker stellen, möchten Sie ihn auf "8:00 AM" stellen, unabhängig davon, ob es sich um Sommerzeit handelt oder nicht, ob Sie in eine andere Zeitzone gereist sind usw.

Ein weiteres Merkmal, das Date fehlt, ist ein Kalendersystem. Die meisten Menschen sind mit dem Gregorianischen Kalender vertraut, in dem es zwei Epochen gibt, BC und AD; es gibt 12 Monate; jeder Monat hat eine unterschiedliche Anzahl von Tagen; es gibt ein Schaltjahr alle 4 Jahre; usw. Allerdings gelten einige dieser Konzepte 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 Gregorianischen Kalender arbeiten.

Es gibt viele andere unerwünschte Altlasten bei Date, wie zum Beispiel, dass alle Setter mutierend sind (was oft unerwünschte Nebeneffekte verursacht), das Datums-Zeit-Zeichenfolgenformat sich nicht konsistent parsen lässt usw. Letztendlich ist die beste Lösung, eine neue API von Grund auf zu entwickeln, was Temporal ist.

API-Übersicht

Temporal ist ein Namensraum, ähnlich wie Intl. Es enthält mehrere Klassen und Namensräume, von denen jeder speziell für einen bestimmten Aspekt der Datums- und Zeitverwaltung entwickelt wurde. Die Klassen können wie folgt gruppiert werden:

Darstellung einer Zeitdauer (ein Unterschied zwischen zwei Zeitpunkten): Temporal.Duration
Darstellung eines Zeitpunkts:
- Darstellung eines einzigartigen Moments in der Geschichte:
  - Als Zeitstempel: Temporal.Instant
  - Als Kombination von Datums- und Zeitkomponenten, gepaart mit einer Zeitzone: Temporal.ZonedDateTime
- Darstellung einer nicht zeitzonenbezogenen Zeit (alle mit "Plain" vorangestellt):
  - Datum (Jahr, Monat, Tag) + Zeit (Stunde, Minute, Sekunde, Millisekunde, Mikrosekunde, Nanosekunde): Temporal.PlainDateTime (Hinweis: ZonedDateTime ist äquivalent zu 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

Darüber hinaus gibt es auch einen weiteren Dienstprogramm-Namensraum, Temporal.Now, der Methoden zum Abrufen der aktuellen Zeit in verschiedenen Formaten bietet.

Gemeinsame Klassenoberfläche

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

	`Instant`	`ZonedDateTime`	`PlainDateTime`	`PlainDate`	`PlainTime`	`PlainYearMonth`	`PlainMonthDay`
Erstellung	`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()`
Aktualisierer	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 in jeder Klasse verfügbar sind und gibt Ihnen einen Eindruck 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
Tagesbezogen	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
Epoch-Zeit	`epochMilliseconds` `epochNanoseconds`	`epochMilliseconds` `epochNanoseconds`	N/A	N/A	N/A	N/A	N/A

Konvertierung zwischen Klassen

Die folgende Tabelle fasst alle Konvertierungsmethoden zusammen, die in jeder Klasse existieren.

		`Instant`	`ZonedDateTime`	`PlainDateTime`	`PlainDate`	`PlainTime`	`PlainYearMonth`	`PlainMonthDay`
		Wie zu konvertieren von...
zu...	`Instant`	/	`toInstant()`	Zuerst in `ZonedDateTime` konvertieren
	`ZonedDateTime`	`toZonedDateTimeISO()`	/	`toZonedDateTime()`	`toZonedDateTime()`	`PlainDate#toZonedDateTime()` (als Argument übergeben)	Zuerst in `PlainDate` konvertieren
	`PlainDateTime`	Zuerst in `ZonedDateTime` konvertieren	`toPlainDateTime()`	/	`toPlainDateTime()`	`PlainDate#toPlainDateTime()` (als Argument übergeben)	Zuerst in `PlainDate` konvertieren
	`PlainDate`		`toPlainDate()`	`toPlainDate()`	/	Keine Informationsüberschneidung	`toPlainDate()`	`toPlainDate()`
	`PlainTime`		`toPlainTime()`	`toPlainTime()`	Keine Informationsüberschneidung	/	Keine Informationsüberschneidung
	`PlainYearMonth`		Zuerst in `PlainDate` konvertieren		`toPlainYearMonth()`	Keine Informationsüberschneidung	/	Zuerst in `PlainDate` konvertieren
	`PlainMonthDay`		Zuerst in `PlainDate` konvertieren		`toPlainMonthDay()`	Keine Informationsüberschneidung	Zuerst in `PlainDate` konvertieren	/

Mit diesen Tabellen sollten Sie eine grundlegende Vorstellung davon bekommen, wie Sie in der Temporal API navigieren können.

Kalender

Ein Kalender ist eine Methode, 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 genutzt werden. Standardmäßig verwenden alle kalenderbewussten Temporal Objekte das ISO 8601 Kalendersystem, das auf dem Gregorianischen Kalender basiert und zusätzliche Wochen-Nummerierungsregeln definiert. Intl.supportedValuesOf() listet die meisten Kalender auf, die wahrscheinlich von Browsern unterstützt werden. Hier geben wir einen kurzen Überblick darüber, wie Kalendersysteme aufgebaut sind, um Ihnen zu helfen, die Faktoren zu verstehen, die zwischen Kalendern variieren können.

Es gibt drei prominente periodische Ereignisse auf der Erde: ihre Drehung um die Sonne (365,242 Tage für eine Revolution), die Drehung des Mondes um die Erde (29,53 Tage von Neumond zu Neumond) und ihre Drehung um ihre Achse (24 Stunden von Sonnenaufgang zu Sonnenaufgang). Jede Kultur hat das gleiche Maß eines „Tages“, das 24 Stunden beträgt. Gelegentliche Änderungen, wie die Sommerzeit, sind kein Teil des Kalenders, sondern Teil der Informationen der Zeitzone.

Einige Kalender definieren hauptsächlich ein Jahr im Durchschnitt mit 365,242 Tagen, indem Jahre mit 365 Tagen festgelegt werden und etwa alle 4 Jahre ein zusätzlicher Tag, der Schalttag, hinzugefügt wird. Dann kann das Jahr weiter in Teile namens Monate unterteilt werden. Diese Kalender werden Sonnenkalender genannt. Der Gregorianische Kalender und der Solar-Hijri-Kalender sind Sonnenkalender.
Einige Kalender definieren primär einen Monat im Durchschnitt mit 29,5 Tagen, indem Monate abwechselnd 29 und 30 Tage haben. Dann können 12 Monate in ein Jahr von 354 Tagen gruppiert werden. Diese Kalender werden Mondkalender genannt. Der Islamische Kalender ist ein Mondkalender. Da ein Mondjahr künstlich ist und nicht mit dem Jahreszeitenzyklus korreliert, sind Mondkalender im Allgemeinen seltener.
Einige Kalender definieren Monate auch primär basierend auf Mondzyklen, ähnlich den Mondkalendern. Dann wird zur Kompensation der 11-tägigen Diskrepanz mit dem Sonnenjahr etwa alle 3 Jahre ein zusätzlicher Monat, der Schaltmonat, hinzugefügt. Diese Kalender werden lunisolare Kalender genannt. Der Hebräische 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 Ganzzahl ist, kann es auch null oder negativ sein und monoton mit der Zeit zunehmen. Das Jahr 1 (oder 0, wenn es existiert) ist als Kalenderepoch bekannt und für jeden Kalender willkürlich. month ist eine positive Ganzzahl, die sich jedes Mal um 1 erhöht und bei 1 beginnt und bei date.monthsInYear endet, dann wieder auf 1 zurückgesetzt wird, wenn das Jahr fortschreitet. day ist auch eine positive Ganzzahl, beginnt jedoch möglicherweise nicht bei 1 oder erhöht sich jedes Mal um 1, da politische Änderungen dazu führen können, dass Tage übersprungen oder wiederholt werden. Im Allgemeinen erhöht sich day jedoch monoton und wird zurückgesetzt, wenn der Monat fortschreitet.

Zusätzlich zu year kann ein Jahr auch eindeutig durch die Kombination aus era und eraYear 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 entspricht dem Jahr { era: "bce", eraYear: 2 } (beachten Sie, dass Jahr 0 immer für alle Kalender existiert; beim Gregorianischen Kalender entspricht es 1 BCE 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 (gewöhnlich für die älteste Epoche).

Hinweis: Verwenden Sie immer era und eraYear als Paar; verwenden Sie keine Eigenschaft ohne die andere. Um Konflikte zu vermeiden, kombinieren Sie nicht year und era/eraYear beim Bestimmen eines Jahres. Wählen Sie eine Jahresdarstellung und verwenden Sie sie konsequent.

Seien Sie vorsichtig mit den folgenden falschen Annahmen über Jahre:

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

Zusätzlich zu month kann ein Monat in einem Jahr auch eindeutig durch den monthCode identifiziert werden. monthCode entspricht normalerweise dem Namen des Monats, nicht jedoch month. Zum Beispiel haben im Fall lunisolarer Kalender 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 bei der Bestimmung eines Monats. Wählen Sie 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).

Seien Sie vorsichtig mit den folgenden falschen Annahmen über Monate:

Gehen Sie nicht davon aus, dass monthCode und month immer übereinstimmen.
Gehen Sie nicht von der Anzahl der Tage in einem Monat aus; verwenden Sie stattdessen daysInMonth.
Gehen Sie nicht davon aus, dass monthCode eine benutzerfreundliche Zeichenfolge ist; verwenden Sie toLocaleString(), um Ihr Datum zu formatieren.
Generell sollten Sie den Namen der Monate nicht in einem Array oder Objekt zwischenspeichern. Obwohl monthCode normalerweise innerhalb eines Kalenders dem Namen des Monats entspricht, empfehlen wir, den Namen des Monats immer mit Funktionen wie date.toLocaleString("en-US", { calendar: date.calendarId, month: "long" }) zu berechnen.

Zusätzlich zu day (das ist ein monatlich-basierter Index) kann ein Tag in einem Jahr auch eindeutig durch den dayOfYear identifiziert werden. dayOfYear ist eine positive Ganzzahl, die sich jedes Mal um 1 erhöht und bei 1 beginnt und bei date.daysInYear endet.

Das Konzept einer "Woche" ist nicht mit einem 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 keine feste Anzahl von Tagen insgesamt. Um die spezifische Anzahl der Tage der Woche eines Datums zu erhalten, verwenden Sie daysInWeek des Datums. Temporal identifiziert Wochen durch die Kombination aus weekOfYear und yearOfWeek. weekOfYear ist eine positive Ganzzahl, die sich jedes Mal um 1 erhöht und bei 1 beginnt, dann wieder auf 1 zurückgesetzt wird, wenn das Jahr fortschreitet. yearOfWeek ist in der Regel das gleiche wie year, kann sich jedoch zu Anfang oder Ende eines Jahres unterscheiden, da eine Woche zwei Jahre überspannen kann, und yearOfWeek wählt eines der beiden Jahre basierend auf den Regeln des Kalenders aus.

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

Seien Sie vorsichtig mit den folgenden falschen Annahmen über Wochen:

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

RFC 9557 Format

Alle Temporal Klassen können im Format gemäß RFC 9557 serialisiert und deserialisiert werden, welches auf ISO 8601 / RFC 3339 basiert. Das Format, in seiner vollständigen Form, ist wie folgt (Leerzeichen sind nur zur Lesbarkeit und sollten nicht im tatsächlichen String enthalten sein):

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

Verschiedene Klassen haben unterschiedliche Anforderungen an die Anwesenheit jedes Komponents, sodass Sie in der Dokumentation jeder Klasse einen Abschnitt mit dem Titel "RFC 9557 format" finden, der das von dieser Klasse erkannte Format angibt.

Dies ist sehr ähnlich dem Datums-Zeit-Zeichenfolgenformat, das von Date verwendet wird und ebenfalls auf ISO 8601 basiert. Die wichtigste Erweiterung ist die Möglichkeit, Mikro- und Nanosekundenkomponenten anzugeben sowie die Möglichkeit, die Zeitzone und das Kalendersystem zu spezifizieren.

Darstellbare Daten

Alle Temporal Objekte, die ein bestimmtes Kalendariumdatum darstellen, haben ein ähnliches Limit für den Bereich der darstellbaren Daten, nämlich ±10⁸ Tage (inklusive) von der Unix-Epoche, oder den Bereich der Zeitpunkte von -271821-04-20T00:00:00 bis +275760-09-13T00:00:00. Dies ist der gleiche Bereich wie bei gültigen Daten. Genauer gesagt:

Temporal.Instant und Temporal.ZonedDateTime wenden dieses Limit direkt auf ihren epochNanoseconds Wert an.
Temporal.PlainDateTime interpretiert die Datum-Uhrzeit in der UTC-Zeitzone und erfordert, dass sie ±(10⁸ + 1) Tage (exklusiv) von der Unix-Epoche ist, sodass ihr gültiger Bereich von -271821-04-19T00:00:00 bis +275760-09-14T00:00:00 exklusiv ist. Dies ermöglicht es jedem ZonedDateTime, in PlainDateTime konvertiert zu werden, unabhängig von seinem Offset.
Temporal.PlainDate überprüft ebenso wie PlainDateTime das Datum auf Mittag (12:00:00) dieses Tages, sodass sein gültiger Bereich -271821-04-19 bis +275760-09-13 ist. Dies ermöglicht es jedem PlainDateTime, in PlainDate konvertiert zu werden, unabhängig von seiner Uhrzeit und umgekehrt.
Temporal.PlainYearMonth hat den gültigen Bereich von -271821-04 bis +275760-09. Dies ermöglicht es jedem PlainDate, in PlainYearMonth konvertiert zu werden, unabhängig von seinem Datum (außer wenn der erste Tag eines nicht-ISO Monats innerhalb des ISO Monats -271821-03 fällt).

Die Temporal Objekte werden sich weigern, eine Instanz zu konstruieren, die ein Datum/Uhrzeit jenseits dieses Limits darstellt. Dies umfasst:

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

Statische Eigenschaften

Temporal.Duration Experimentell: Repräsentiert einen Unterschied zwischen zwei Zeitpunkten, der in Datum-/Uhrzeit-Arithmetik verwendet werden kann. Es wird im Wesentlichen als Kombination von Jahren, Monaten, Wochen, Tagen, Stunden, Minuten, Sekunden, Millisekunden, Mikrosekunden und Nanosekunden dargestellt.
Temporal.Instant Experimentell: Repräsentiert einen einzigartigen Zeitpunkt mit Nanosekunden-Genauigkeit. Es wird im Wesentlichen als die Anzahl der Nanosekunden seit der Unix-Epoche (Mitternacht zu Beginn des 1. Januar 1970, UTC) dargestellt, ohne jegliches Zeitzonen- oder Kalendersystem.
Temporal.Now Experimentell: Bietet Methoden zur Abrufung der aktuellen Zeit in verschiedenen Formaten.
Temporal.PlainDate Experimentell: Repräsentiert ein Kalenderdatum (ein Datum ohne eine Uhrzeit oder Zeitzone); zum Beispiel ein Ereignis in einem Kalender, das während des ganzen Tages unabhängig von der Zeitzone stattfindet. Es wird im Wesentlichen als ISO 8601 Kalenderdatum dargestellt, mit Jahr-, Monats- und Tagesfeldern und einem zugehörigen Kalendersystem.
Temporal.PlainDateTime Experimentell: Repräsentiert ein Datum (Kalenderdatum) und eine Zeit (Wanduhrzeit) ohne Zeitzone. Es wird im Wesentlichen als Kombination aus einem Datum (mit einem zugehörigen Kalendersystem) und einer Uhrzeit dargestellt.
Temporal.PlainMonthDay Experimentell: Repräsentiert den Monat und Tag eines Kalenderdatums, ohne Jahr oder Zeitzone; zum Beispiel ein Ereignis in einem Kalender, das sich jedes Jahr wiederholt und den ganzen Tag stattfindet. Es wird im Wesentlichen als ISO 8601 Kalenderdatum dargestellt, mit Jahr-, Monats- und Tagesfeldern und einem zugehörigen Kalendersystem. Das Jahr wird zur Klärung des Monats-Tags in nicht ISO-Kalendersystemen herangezogen.
Temporal.PlainTime Experimentell: Repräsentiert eine Zeit ohne Datum oder Zeitzone; zum Beispiel ein wiederkehrendes Ereignis, das jeden Tag zur gleichen Zeit stattfindet. Es wird im Wesentlichen als Kombination von Stunden-, Minuten-, Sekunden-, Millisekunden-, Mikrosekunden- und Nanosekundenwerten dargestellt.
Temporal.PlainYearMonth Experimentell: Repräsentiert das Jahr und den Monat eines Kalenderdatums, ohne Tag oder Zeitzone; zum Beispiel ein Ereignis in einem Kalender, das während des gesamten Monats stattfindet. Es wird im Wesentlichen als ISO 8601 Kalenderdatum dargestellt, mit Jahr-, Monats- und Tagesfeldern und einem zugehörigen Kalendersystem. Der Tag wird verwendet, um das Jahr-Monat in nicht ISO-Kalendersystemen zu klären.
Temporal.ZonedDateTime Experimentell: Repräsentiert ein Datum und eine Uhrzeit mit einer Zeitzone. Es wird im Wesentlichen als Kombination eines Zeitpunkts, einer Zeitzone und eines Kalendersystems dargestellt.
Temporal[Symbol.toStringTag]: Der anfängliche Wert der [Symbol.toStringTag] Eigenschaft ist der String "Temporal". Diese Eigenschaft wird in Object.prototype.toString() verwendet.

Spezifikationen

Specification
Temporal # sec-temporal-intro