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 eingebauten Darstellung von Zeitzonen und Kalendern, Wanduhren-Zeitumwandlungen, Arithmetik, Formatierung und mehr. Es wurde 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 weder mit dem new-Operator verwenden, noch das Temporal-Objekt als Funktion aufrufen. Alle Eigenschaften und Methoden von Temporal sind statisch (ähnlich dem Math-Objekt).

Temporal hat eine komplizierte und leistungsstarke API. Es stellt über 200 Hilfsmethoden über mehrere Klassen zur Verfügung, sodass es sehr komplex erscheinen kann. Wir werden einen Überblick darüber geben, wie diese APIs miteinander in Beziehung stehen.

Hintergrund und Konzepte

JavaScript verfügt seit seinen ersten Tagen über das Date-Objekt zur Handhabung von Datum und Uhrzeit. Die Date-API basiert jedoch auf der schlecht gestalteten Klasse java.util.Date aus Java, die bereits Anfang der 2010er Jahre ersetzt wurde. Aufgrund des Ziels der Rückwärtskompatibilität von JavaScript bleibt Date jedoch in der Sprache erhalten.

Die wichtige Lektion, die dieser Einführung vorausgehen sollte, ist, dass das Handling von Daten komplex ist. Die meisten Probleme von Date lassen sich durch das Hinzufügen weiterer Methoden beheben, aber ein grundlegender Designfehler bleibt bestehen: Es stellt so viele Methoden für dasselbe Objekt zur Verfügung, dass Entwickler oft verwirrt sind, was verwendet werden soll, was zu unerwarteten Fallstricken führt. Eine gut gestaltete API muss nicht nur mehr leisten, sondern sollte auf jeder Abstraktionsebene weniger tun, da das Verhindern von Fehlanwendungen genauso wichtig ist wie das Ermöglichen von Anwendungsfällen.

Date-Objekte tragen gleichzeitig zwei Hüte:

Als Zeitstempel: die Anzahl der Millisekunden oder Nanosekunden, die seit einem festen Zeitpunkt vergangen sind (bekannt als Epoch).
Als Kombination von Komponenten: Jahr, Monat, Tag, Stunde, Minute, Sekunde, Millisekunde und Nanosekunde. Die Jahr-, Monat- und Tagsbezeichnungen machen nur in Bezug auf ein Kalendersystem Sinn. Die ganze Kombination entspricht einem einzigartigen Augenblick in der Geschichte, wenn eine Zeitzone hinzugefügt wird. Date-Objekte bieten Methoden zum Lesen und Ändern dieser Komponenten.

Zeitzonen sind Grund für eine beträchtliche Anzahl datumsbezogener Fehler. Wenn Sie mit einem Date-Objekt durch das "Kombination von Komponenten"-Modell interagieren, kann die Zeit nur in zwei Zeitzonen sein: UTC und lokal (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 Wanduhrenzeit (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 Uhr" einstellen, unabhängig davon, ob Sommerzeit ist oder nicht, ob Sie in eine andere Zeitzone gereist sind, usw.

Ein weiteres fehlendes Merkmal von Date ist ein Kalendersystem. Die meisten Menschen kennen wahrscheinlich den gregorianischen Kalender, in dem es zwei Epochen, BC und AD gibt; es gibt 12 Monate; jeder Monat hat eine unterschiedliche Anzahl von Tagen; es gibt alle 4 Jahre ein Schaltjahr; und so weiter. Einige dieser Konzepte können jedoch nicht zutreffen, 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 Kalendermodell arbeiten.

Es gibt viele andere unerwünschte Altlasten bei Date, wie zum Beispiel, dass alle Setter ändernd sind (was oft unerwünschte Nebenwirkungen verursacht), das Datumszeit-String-Format nicht konsistent geparst werden kann usw. Letztendlich ist die beste Lösung, eine neue API von Grund auf zu erstellen, was Temporal ist.

API-Übersicht

Temporal ist ein Namensraum, wie Intl. Es enthält mehrere Klassen und Namensräume, die jeweils entwickelt wurden, um einen bestimmten Aspekt der Verwaltung von Datum und Uhrzeit zu handhaben. Die Klassen können wie folgt gruppiert werden:

Darstellung einer Zeitdauer (ein Unterschied zwischen zwei Zeitpunkten): Temporal.Duration
Darstellung eines Zeitpunkts:
- Darstellung eines einzigartigen Augenblicks in der Geschichte:
  - Als Zeitstempel: Temporal.Instant
  - Als Kombination von Datum-Zeit-Komponenten gepaart mit einer Zeitzone: Temporal.ZonedDateTime
- Darstellung eines zeitzonenunabhängigen Datums/Zeit (die alle mit "Plain" beginnen):
  - Datum (Jahr, Monat, Tag) + Zeit (Stunde, Minute, Sekunde, Millisekunde, Mikrosekunde, Nanosekunde): Temporal.PlainDateTime (Hinweis: ZonedDateTime entspricht PlainDateTime zuzüglich 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 einen zusätzlichen Hilfsnamensraum, Temporal.Now, der Methoden zum Abrufen der aktuellen Zeit in verschiedenen Formaten bereitstellt.

Gemeinsame Klassenschnittstelle

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`
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()`
Aktualisierung	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 vermittelt Ihnen ein Gefühl dafür, 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
Monatbezogen	N/A	`month` `monthCode` `daysInMonth`	`month` `monthCode` `daysInMonth`	`month` `monthCode` `daysInMonth`	N/A	`month` `monthCode` `daysInMonth`	`monthCode`
Wochennah	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
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 man von ... konvertiert
nach ...	`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 Überschneidung in den Informationen	`toPlainDate()`	`toPlainDate()`
	`PlainTime`		`toPlainTime()`	`toPlainTime()`	Keine Überschneidung in den Informationen	/	Keine Überschneidung in den Informationen
	`PlainYearMonth`		Zuerst in `PlainDate` konvertieren		`toPlainYearMonth()`	Keine Überschneidung in den Informationen	/	Zuerst in `PlainDate` konvertieren
	`PlainMonthDay`		Zuerst in `PlainDate` konvertieren		`toPlainMonthDay()`	Keine Überschneidung in den Informationen	Zuerst in `PlainDate` konvertieren	/

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

Kalender

Ein Kalender ist eine Methode zur Organisation von Tagen, 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, insbesondere in religiösen und kulturellen Kontexten. 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 der Kalender auf, von denen Browser wahrscheinlich unterstützt werden. Hier bieten wir einen Überblick darüber, wie Kalendersysteme gebildet werden, um Ihnen zu helfen, zu verstehen, welche Faktoren zwischen Kalendern variieren können.

Es gibt drei prominente periodische Ereignisse auf der Erde: ihre Umlaufbahn um die Sonne (365,242 Tage für eine Umdrehung), die Umlaufbahn des Mondes um die Erde (29,53 Tage von Neumond zu Neumond), und ihre Rotation um ihre Achse (24 Stunden von Sonnenaufgang zu Sonnenaufgang). Jedes Kultur hat das gleiche Maß für einen "Tag", nämlich 24 Stunden. Gelegentliche Änderungen wie die Sommerzeit gehören nicht zum Kalender, sondern sind Teil der Zeitzonen-Informationen.

Einige Kalender definieren primär ein Jahr als durchschnittlich 365,242 Tage, indem sie Jahre zu 365 Tagen definieren und alle 4 Jahre einen zusätzlichen Tag, den Schalttag, hinzufügen. 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 als durchschnittlich 29,5 Tage, indem sie Monate abwechselnd auf 29 und 30 Tage definieren. Dann können 12 Monate zu einem 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 generell seltener.
Einige Kalender definieren auch primär Monate basierend auf Mondzyklen, ähnlich wie Mondkalender. Dann wird zur Kompensation der 11-Tage-Abweichung zum Sonnenjahr etwa alle 3 Jahre ein zusätzlicher Monat, der Schaltmonat, hinzugefügt. Diese Kalender werden lunisolare Kalender genannt. Der hebräische Kalender und der chinesische Kalender sind lunisolare Kalender.

In Temporal wird jedes Datum in 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 monotone mit der Zeit. Das Jahr 1 (oder 0, falls vorhanden) ist bekannt als der Kalenderstart und ist für jeden Kalender willkürlich. month ist eine positive ganze Zahl, die jedes Mal um 1 erhöht wird, beginnend bei 1 und endend bei date.monthsInYear, dann zurück zu 1, während das Jahr voranschreitet. day ist ebenfalls eine positive ganze Zahl, kann aber nicht immer bei 1 beginnen oder jedes Mal um 1 erhöht werden, da politische Veränderungen dazu führen können, dass Tage übersprungen oder wiederholt werden. Aber im Allgemeinen erhöht sich day monoton und setzt sich zurück, während der Monat fortschreitet.

Zusätzlich zu year kann ein Jahr auch durch die Kombination von era und eraYear eindeutig identifiziert werden, für Kalender, die Epochen verwenden. Zum Beispiel verwendet der gregorianische Kalender die Epoche "CE" (Common Era) und "BCE" (Before Common Era), und das Jahr -1 entspricht { era: "bce", eraYear: 1 }. era ist eine kleingeschriebene Zeichenkette, und eraYear ist eine beliebige ganze Zahl, die null oder negativ sein oder sogar mit der Zeit abnehmen kann (normalerweise für die älteste Epoche).

Hinweis: Verwenden Sie immer era und eraYear als Paar; nutzen Sie nicht eine Eigenschaft ohne die andere. Um Konflikte zu vermeiden, kombinieren Sie nicht year und era/eraYear, wenn Sie ein Jahr angeben. Wählen Sie eine Jahresdarstellung und verwenden Sie sie konsistent.

Seien Sie vorsichtig bei 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 Zeichenkette ist; verwenden Sie toLocaleString(), um Ihr Datum zu formatieren.
Gehen Sie nicht davon aus, dass zwei year-Werte aus 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 Tag mehr haben; sie können einen zusätzlichen Monat haben.

Zusätzlich zu month kann ein Monat in einem Jahr auch durch den monthCode eindeutig identifiziert werden. monthCode entspricht normalerweise dem Namen des Monats, aber month nicht. Zum Beispiel können im Fall von lunisolarer Kalender zwei Monate mit demselben monthCode, wobei einer zu einem Schaltjahr gehört und der andere nicht, unterschiedliche month-Werte haben, wenn sie auf den Schaltmonat folgen, aufgrund der Einfügung eines zusätzlichen Monats.

Hinweis: Um Konflikte zu vermeiden, kombinieren Sie nicht month und monthCode, wenn Sie einen Monat angeben. Wählen Sie eine Monatsdarstellung und verwenden Sie sie konsistent. 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 bei den folgenden falschen Annahmen über Monate:

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

Neben day (das ist ein monatsbasierter Index) kann ein Tag in einem Jahr auch durch den dayOfYear eindeutig identifiziert werden. dayOfYear ist eine positive Ganzzahl, 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 verkettet, sondern ein kulturelles Konstrukt. Während die gebräuchlichste Länge 7 Tage ist, können Wochen auch 4, 5, 6, 8 oder mehr Tage haben — oder sogar völlig variabel sein. Um die spezifische Anzahl der Tage der Woche eines Datums zu erhalten, verwenden Sie die daysInWeek-Eigenschaft des Datums. Temporal identifiziert Wochen durch die Kombination von weekOfYear und yearOfWeek. weekOfYear ist eine positive Ganzzahl, die sich jedes Mal um 1 erhöht, beginnend bei 1, dann zurück zu 1, während das Jahr fortschreitet. yearOfWeek ist im Allgemeinen dasselbe wie year, kann aber zu Beginn oder Ende eines jeden Jahres unterschiedlich sein, da eine Woche zwei Jahre umfassen kann, und yearOfWeek wählt eines der beiden Jahre basierend auf den Regeln des Kalenders.

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

Seien Sie vorsichtig bei 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 Jahres-Woche-Daten unterstützt, sodass Sie keine Daten mit diesen Eigenschaften konstruieren oder Daten in Jahres-Woche-Darstellungen serialisieren können. Sie sind lediglich informationelle Eigenschaften.

RFC 9557-Format

Alle Temporal-Klassen können im Format des RFC 9557 serialisiert und deserialisiert werden, das auf ISO 8601 / RFC 3339 basiert. Das Format, in seiner vollständigen Form, lautet wie folgt (Leerzeichen sind nur zur Lesbarkeit vorhanden und sollten im tatsächlichen Zeichenstring nicht vorkommen):

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 Präsenz 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 dem Datums-Zeit-String-Format sehr ähnlich, das von Date verwendet wird und ebenfalls auf ISO 8601 basiert. Die Hauptverbesserung besteht in der Möglichkeit, Mikro- und Nanosekundenkomponenten anzugeben sowie die Zeitzone und das Kalendersystem zu spezifizieren.

Darstellbare Daten

Alle Temporal-Objekte, die ein spezifisches Kalenderdatum repräsentieren, unterliegen einer ähnlichen Grenze bezüglich des Bereichs darstellbarer Daten, die ±10⁸ Tage (inklusive) ab der Unix-Epoche beträgt, oder der Bereich von Augenblicken von -271821-04-20T00:00:00 bis +275760-09-13T00:00:00. Dies ist derselbe Bereich wie bei gültigen Daten. Genauer gesagt:

Temporal.Instant und Temporal.ZonedDateTime wenden dieses Limit direkt auf den epochNanoseconds-Wert an.
Temporal.PlainDateTime interpretiert das Datum-Uhrzeit in der UTC-Zeitzone und erfordert, dass es ±(10⁸ + 1) Tage (exklusiv) ab der Unix-Epoche ist, sodass der gültige Bereich von -271821-04-19T00:00:00 bis +275760-09-14T00:00:00 (exklusiv) reicht. Dadurch kann jedes ZonedDateTime in ein PlainDateTime konvertiert werden, unabhängig von seinem Offset.
Temporal.PlainDate wendet denselben Check wie PlainDateTime auf den Mittag (12:00:00) dieses Datums an, sodass der gültige Bereich von -271821-04-19 bis +275760-09-13 reicht. Dies erlaubt es, jedes PlainDateTime in ein PlainDate zu konvertieren, unabhängig von seiner Zeit und umgekehrt.
Temporal.PlainYearMonth hat den gültigen Bereich von -271821-04 bis +275760-09. Dies erlaubt es, jedes PlainDate in ein PlainYearMonth zu konvertieren, 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 es ablehnen, eine Instanz zu konstruieren, die ein Datum/Uhrzeit außerhalb dieses Limits darstellt. Dies beinhaltet:

Verwenden des Konstruktors oder der from()-statischen Methode.
Verwenden der with()-Methode zum Aktualisieren von Kalenderfeldern.
Verwenden von add(), subtract(), round() oder einer anderen Methode, um neue Instanzen abzuleiten.

Statische Eigenschaften

Temporal.Duration Experimentell: Repräsentiert einen Unterschied zwischen zwei Zeitpunkten, die in Datum/Uhrzeit-Arithmetik verwendet werden können. Es wird grundsätzlich als eine Kombination von Jahren, Monaten, Wochen, Tagen, Stunden, Minuten, Sekunden, Millisekunden, Mikrosekunden und Nanosekundenwerten dargestellt.
Temporal.Instant Experimentell: Repräsentiert einen einzigartigen Punkt in der Zeit mit Nanosekundenauflösung. Es wird grundsätzlich als die Anzahl der Nanosekunden dargestellt, die seit der Unix-Epoche vergangen sind (Mitternacht zu Beginn des 1. Januar 1970, UTC), ohne Zeitzonen- oder Kalendersystem.
Temporal.Now Experimentell: Bietet Methoden zum Abrufen der aktuellen Zeit in verschiedenen Formaten.
Temporal.PlainDate Experimentell: Repräsentiert ein Kalenderdatum (ein Datum ohne eine Uhrzeit oder Zeitzone); z. B. ein Ereignis in einem Kalender, das den ganzen Tag über passiert, unabhängig davon, in welcher Zeitzone es stattfindet. Es wird grundsätzlich als ein ISO 8601-Kalenderdatum repräsentiert, mit Jahres-, Monats- und Tagesfeldern und einem zugehörigen Kalendersystem.
Temporal.PlainDateTime Experimentell: Repräsentiert ein Datum (Kalenderdatum) und eine Uhrzeit (Wanduhrenzeit) ohne eine Zeitzone. Es wird grundsätzlich als eine Kombination aus einem Datum (mit einem zugehörigen Kalendersystem) und einer Uhrzeit repräsentiert.
Temporal.PlainMonthDay Experimentell: Repräsentiert den Monat und Tag eines Kalenderdatums, ohne Jahr oder Zeitzone; z. B. ein Ereignis in einem Kalender, das jedes Jahr wiederkehrt und den ganzen Tag über stattfindet. Es wird grundsätzlich als ein ISO 8601-Kalenderdatum repräsentiert, mit Jahres-, Monats- und Tagesfeldern und einem zugehörigen Kalendersystem. Das Jahr wird verwendet, um den Monat-Tag in nicht ISO-Kalendersystemen zu unterscheiden.
Temporal.PlainTime Experimentell: Repräsentiert eine Uhrzeit ohne ein Datum oder Zeitzone; z. B. ein wiederkehrendes Ereignis, das jeden Tag zur gleichen Uhrzeit stattfindet. Es wird grundsätzlich als eine Kombination von Stunden-, Minuten-, Sekunden-, Millisekunden-, Mikrosekunden- und Nanosekundenwerten repräsentiert.
Temporal.PlainYearMonth Experimentell: Repräsentiert das Jahr und den Monat eines Kalenderdatums, ohne Tag oder Zeitzone; z. B. ein Ereignis in einem Kalender, das den ganzen Monat stattfindet. Es wird grundsätzlich als ein ISO 8601-Kalenderdatum repräsentiert, mit Jahres-, Monats- und Tagesfeldern und einem zugehörigen Kalendersystem. Der Tag wird verwendet, um das Jahr-Monat in nicht ISO-Kalendersystemen zu unterscheiden.
Temporal.ZonedDateTime Experimentell: Repräsentiert ein Datum und eine Uhrzeit mit einer Zeitzone. Es wird grundsätzlich als eine Kombination von einem Augenblick, einer Zeitzone und einem Kalendersystem repräsentiert.
Temporal[Symbol.toStringTag]: Der Anfangswert der [Symbol.toStringTag]-Eigenschaft ist der String "Temporal". Diese Eigenschaft wird in Object.prototype.toString() verwendet.

Spezifikationen

Specification
Temporal proposal # sec-temporal-intro