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 das Verwenden von Datum und Zeit in verschiedenen Szenarien, einschließlich integrierter Zeitzonen- und Kalenderdarstellung, Umwandlungen der Uhrzeit, Arithmetik, Formatierungen 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 (ähnlich wie das Math-Objekt).

Temporal verfügt über eine komplexe und leistungsfähige API. Es bietet über 200 Dienstmethoden über mehrere Klassen an, sodass es sehr komplex erscheinen kann. Wir geben einen Überblick darüber, wie diese APIs miteinander in Beziehung stehen.

Hintergrund und Konzepte

JavaScript hat das Date-Objekt seit seinen Anfängen zur Verwaltung von Datum und Zeit. Allerdings basiert die Date-API auf der schlecht gestalteten java.util.Date-Klasse aus Java, die in den frühen 2010er Jahren ersetzt wurde; aufgrund des JavaScript-Ziels der Rückwärtskompatibilität bleibt Date jedoch in der Sprache bestehen.

Die wichtigste Lektion ist, dass die Handhabung von Daten komplex ist. Die meisten Probleme von Date können durch Hinzufügen weiterer Methoden behoben werden, aber ein grundlegender Konstruktionsfehler bleibt: Es werden so viele Methoden auf demselben Objekt bereitgestellt, dass Entwickler oft verwirrt sind, was sie verwenden sollen, was zu unerwarteten Fallen führt. Eine gut gestaltete API muss nicht nur mehr tun, sondern auch weniger auf jeder Abstraktionsebene, da die Vermeidung von Fehlgebrauch genauso wichtig ist wie die Ermöglichung von Anwendungsfällen.

Date-Objekte haben gleichzeitig zwei Rollen:

Als Zeitstempel: die Anzahl der Millisekunden oder Nanosekunden, die seit einem festen Zeitpunkt vergangen sind (bekannt als Epoche).
Als Kombination von Komponenten: Jahr, Monat, Tag, Stunde, Minute, Sekunde, Millisekunde und Nanosekunde. Die Jahr-, Monat- und Tagbezeichnungen ergeben nur im Kontext eines Kalendersystems einen Sinn. Die gesamte Kombination wird in Verbindung mit einer Zeitzone zu einem eindeutigen Zeitpunkt in der Geschichte. Date-Objekte bieten Methoden zum Lesen und Ändern dieser Komponenten.

Zeitzonen sind eine häufige Quelle für datenbezogene Fehler. Wenn Sie über das Modell "Kombination von Komponenten" mit einem Date interagieren, 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 der "keine Zeitzone": Dies wird als Kalenderdatum (für Daten) oder Wanduhrzeit (für Zeiten) bezeichnet, die 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" stellen, unabhängig davon, ob es Sommerzeit ist, 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, bei dem es zwei Epochen gibt, v. Chr. und n. Chr.; es gibt 12 Monate; jeder Monat hat eine unterschiedliche Anzahl von Tagen; es gibt alle 4 Jahre ein Schaltjahr usw. 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 Hinterlassenschaften von Date, wie dass alle Set-Methoden mutierend sind (was oft unerwünschte Nebenwirkungen verursacht), das Datum-Uhrzeit-String-Format, das auf konsistente Weise schwer zu analysieren ist usw. Am Ende besteht die beste Lösung darin, 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 Namespaces, die jeweils einen bestimmten Aspekt der Verwaltung von Datum und Zeit behandeln sollen. Die Klassen können wie folgt gruppiert werden:

Darstellung einer Zeitdauer (ein Unterschied zwischen zwei Zeitpunkten): Temporal.Duration
Darstellung eines Zeitpunkts:
- Darstellung eines einzigartigen Zeitpunktes in der Geschichte:
  - Als Zeitstempel: Temporal.Instant
  - Als Kombination der Datums-Zeit-Komponenten mit einer Zeitzone: Temporal.ZonedDateTime
- Darstellung eines zeitzonenunabhängigen Datums/Zeit (alle mit "Plain" vorangestellt):
  - Datum (Jahr, Monat, Tag) + Zeit (Stunde, Minute, Sekunde, Millisekunde, Mikrosekunde, Nanosekunde): Temporal.PlainDateTime (Hinweis: ZonedDateTime ist gleichbedeutend mit 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 noch einen weiteren Dienst-Namespace, Temporal.Now, der Methoden zum Abrufen der aktuellen Zeit in verschiedenen Formaten bereitstellt.

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`
Erzeugung	`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	Nicht zutreffend	`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()`	Nicht zutreffend
Rundung	`round()`	`round()`	`round()`	Nicht zutreffend	`round()`	Nicht zutreffend	Nicht zutreffend
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	Nicht zutreffend	`calendarId`	`calendarId`	`calendarId`	Nicht zutreffend	`calendarId`	`calendarId`
Jahr-bezogene	Nicht zutreffend	`era` `eraYear` `year` `inLeapYear` `monthsInYear` `daysInYear`	`era` `eraYear` `year` `inLeapYear` `monthsInYear` `daysInYear`	`era` `eraYear` `year` `inLeapYear` `monthsInYear` `daysInYear`	Nicht zutreffend	`era` `eraYear` `year` `inLeapYear` `monthsInYear` `daysInYear`	Nicht zutreffend
Monat-bezogene	Nicht zutreffend	`month` `monthCode` `daysInMonth`	`month` `monthCode` `daysInMonth`	`month` `monthCode` `daysInMonth`	Nicht zutreffend	`month` `monthCode` `daysInMonth`	`monthCode`
Woche-bezogene	Nicht zutreffend	`weekOfYear` `yearOfWeek` `daysInWeek`	`weekOfYear` `yearOfWeek` `daysInWeek`	`weekOfYear` `yearOfWeek` `daysInWeek`	Nicht zutreffend	Nicht zutreffend	Nicht zutreffend
Tag-bezogene	Nicht zutreffend	`day` `dayOfWeek` `dayOfYear`	`day` `dayOfWeek` `dayOfYear`	`day` `dayOfWeek` `dayOfYear`	Nicht zutreffend	Nicht zutreffend	`day`
Zeitkomponenten	Nicht zutreffend	`hour` `minute` `second` `millisecond` `microsecond` `nanosecond`	`hour` `minute` `second` `millisecond` `microsecond` `nanosecond`	Nicht zutreffend	`hour` `minute` `second` `millisecond` `microsecond` `nanosecond`	Nicht zutreffend	Nicht zutreffend
Zeitzone	Nicht zutreffend	`timeZoneId` `offset` `offsetNanoseconds` `hoursInDay` `getTimeZoneTransition()` `startOfDay()`	Nicht zutreffend	Nicht zutreffend	Nicht zutreffend	Nicht zutreffend	Nicht zutreffend
Epoch-Zeit	`epochMilliseconds` `epochNanoseconds`	`epochMilliseconds` `epochNanoseconds`	Nicht zutreffend	Nicht zutreffend	Nicht zutreffend	Nicht zutreffend	Nicht zutreffend

Konvertierung zwischen Klassen

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

		`Instant`	`ZonedDateTime`	`PlainDateTime`	`PlainDate`	`PlainTime`	`PlainYearMonth`	`PlainMonthDay`
		Wie man konvertiert 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 Überlappung an Informationen	`toPlainDate()`	`toPlainDate()`
	`PlainTime`		`toPlainTime()`	`toPlainTime()`	Keine Überlappung an Informationen	/	Keine Überlappung an Informationen
	`PlainYearMonth`		Zuerst in `PlainDate` konvertieren		`toPlainYearMonth()`	Keine Überlappung an Informationen	/	Zuerst in `PlainDate` konvertieren
	`PlainMonthDay`		Zuerst in `PlainDate` konvertieren		`toPlainMonthDay()`	Keine Überlappung an Informationen	Zuerst in `PlainDate` konvertieren	/

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

Kalender

Ein Kalender ist ein Mittel, um Tage zu organisieren, typischerweise in Perioden wie Wochen, Monate, Jahre und Epochen. Der größte Teil der Welt verwendet den gregorianischen Kalender, aber es gibt viele andere Kalender, die in religiösen und kulturellen Kontexten verwendet werden. Standardmäßig verwenden alle kalenderbezogenen Temporal-Objekte das ISO 8601-Kalendersystem, das auf dem gregorianischen Kalender basiert und zusätzliche Wochenregeln festlegt. Intl.supportedValuesOf() listet die meisten Kalender auf, die vermutlich von Browsern unterstützt werden. Hier bieten wir einen kurzen Überblick darüber, wie Kalendersysteme gebildet werden, um Ihnen zu helfen, welche Faktoren zwischen Kalendern variieren können.

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

Einige Kalender definieren ein Jahr primär als durchschnittlich 365,242 Tage, indem sie Jahre mit 365 Tagen definieren und etwa alle 4 Jahre einen Extratag, den Schalttag, hinzufügen. Dann kann das Jahr weiter in Monate unterteilt werden. Diese Kalender werden Sonnenkalender genannt. Der gregorianische Kalender und der Solar-Hijri-Kalender sind Sonnenkalender.
Einige Kalender definieren einen Monat primär als durchschnittlich 29,5 Tage, indem sie Monate bestimmen, die zwischen 29 und 30 Tagen wechseln. 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 saisonalen Zyklus korreliert, sind Mondkalender allgemein seltener.
Einige Kalender definieren Monate ebenfalls hauptsächlich basierend auf Mondzyklen, ähnlich wie Mondkalender. Dann wird, um die 11-Tage-Diskrepanz mit dem Sonnenjahr zu kompensieren, etwa alle 3 Jahre ein zusätzlicher Monat, der Schaltmonat, hinzugefügt. Diese Kalender werden lunisolar 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 normalerweise eine positive ganze Zahl ist, kann sie auch null oder negativ sein und monoton mit der Zeit zunehmen. Das Jahr 1 (oder 0, wenn es existiert) ist als Kalenderepoche bekannt und ist 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 zurück auf 1 zurückgesetzt wird, wenn das Jahr fortschreitet. day ist ebenfalls eine positive Ganzzahl, kann aber nicht bei 1 beginnen oder sich jedes Mal um 1 erhöhen, da politische Änderungen Tage überspringen oder wiederholen können. Im Allgemeinen erhöht sich day jedoch monoton und wird zurückgesetzt, wenn 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 Epochen "CE" (Common Era) und "BCE" (Before Common Era), und das Jahr -1 ist dasselbe wie { era: "bce", eraYear: 2 } (Hinweis: dass Jahr 0 existiert immer für alle Kalender; für den gregorianischen Kalender entspricht es 1 v. Chr. aufgrund der astronomischen Jahrzählung). era ist eine Kleinschreibung und eraYear ist eine willkürliche Ganzzahl, 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; verwenden Sie nicht eine Eigenschaft ohne die andere. Um Konflikte zu vermeiden, kombinieren Sie nicht year und era/eraYear, wenn Sie ein Jahr bezeichnen. Wählen Sie eine Jahresdarstellung und verwenden Sie sie konsequent.

Hüten Sie sich vor den folgenden falschen Annahmen über Jahre:

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

Zusätzlich zu month kann ein Monat in einem Jahr auch durch den monthCode eindeutig identifiziert werden. monthCode ordnet sich normalerweise dem Namen des Monats zu, während month dies nicht tut. Zum Beispiel, im Fall von lunisolar Kalendern, werden zwei Monate mit demselben monthCode, bei denen einer zu einem Schaltjahr gehört und der anderer nicht, unterschiedliche month-Werte haben, wenn sie nach dem Schaltmonat auftreten, aufgrund der Einfügung eines zusätzlichen Monats.

Hinweis: Um Konflikte zu vermeiden, kombinieren Sie nicht month und monthCode, wenn Sie einen Monat bezeichnen. 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).

Hüten Sie sich vor den folgenden falschen Annahmen über Monate:

Gehen Sie nicht davon aus, dass monthCode und month immer übereinstimmen.
Nehmen Sie nicht die Anzahl der Tage in einem Monat an; verwenden Sie daysInMonth stattdessen.
Nehmen Sie nicht an, dass monthCode eine benutzerfreundliche Zeichenfolge ist; verwenden Sie toLocaleString(), um das Datum zu formatieren.
Im Allgemeinen sollten Sie den Namen der Monate nicht in einem Array oder Objekt zwischenspeichern. Obwohl monthCode normalerweise dem Namen des Monats innerhalb eines Kalenders zugeordnet ist, empfehlen wir immer, den Monatsnamen mit z. B. date.toLocaleString("de-DE", { calendar: date.calendarId, month: "long" }) zu berechnen.

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

Das Konzept einer "Woche" ist mit keinem astronomischen Ereignis verbunden, sondern ist 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 fixen Tage. Verwenden Sie die daysInWeek, um die spezifische Anzahl von Tagen der Woche eines Datums zu erhalten. 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 auf 1 gesetzt wird, wenn das Jahr fortschreitet. yearOfWeek ist im Allgemeinen dasselbe wie year, kann jedoch am Anfang oder Ende jedes Jahres unterschiedlich sein, da eine Woche zwei Jahre überschreiten kann und yearOfWeek basierend auf den Regeln des Kalenders eines der beiden Jahre auswählt.

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

Hüten Sie sich vor den folgenden falschen Annahmen über Wochen:

Gehen Sie nicht davon aus, dass weekOfYear und yearOfWeek immer vorhanden sind; sie könnten undefined sein.
Nehmen Sie nicht an, dass Wochen immer 7 Tage lang sind; verwenden Sie daysInWeek stattdessen.
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. Es sind lediglich informative Eigenschaften.

RFC 9557-Format

Alle Temporal-Klassen können serialisiert und deserialisiert werden, indem das im RFC 9557 spezifizierte Format verwendet wird, das auf ISO 8601 / RFC 3339 basiert. Das Format, in seiner vollständigen Form, ist wie folgt (Leerzeichen sind nur für die Lesbarkeit 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]

Verschiedene Klassen haben unterschiedliche Anforderungen an die Anwesenheit jeder Komponente, also finden Sie einen Abschnitt mit dem Titel "RFC 9557-Format" in der Dokumentation jeder Klasse, der das von dieser Klasse erkannte Format spezifiziert.

Dies ist dem Datum-Uhrzeit-String-Format sehr ähnlich, das von Date verwendet wird, das ebenfalls auf ISO 8601 basiert. Die Hauptneuheit ist die Möglichkeit, Mikro- und Nanosekundenkomponenten anzugeben sowie Zeitzone und Kalendersystem anzugeben.

Darstellbare Daten

Alle Temporal-Objekte, die ein spezifisches Kalenderdatum darstellen, legen eine ähnliche Begrenzung für den Bereich darstellbarer Daten auf, nämlich ±10⁸ Tage (einschließlich) von der Unix-Epoche oder den Bereich von Momenten von -271821-04-20T00:00:00 bis +275760-09-13T00:00:00. Dies entspricht demselben Bereich wie bei gültigen Daten. Genauer:

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

Die Temporal-Objekte verweigern es, eine Instanz zu erstellen, die ein Datum/Zeit jenseits dieses Limits darstellt. Dies schließt ein:

Verwendung des Konstruktors oder der statischen Methode from().
Verwendung der with()-Methode zur Aktualisierung von Kalenderfeldern.
Verwendung von add(), subtract(), round() oder einer anderen Methode zur Ableitung neuer Instanzen.

Statische Eigenschaften

Temporal.Duration Experimentell: Repräsentiert einen Unterschied zwischen zwei Zeitpunkten, der in Arithmetik von Datum/Zeit verwendet werden kann. Es wird grundlegend als Kombination von Jahren, Monaten, Wochen, Tagen, Stunden, Minuten, Sekunden, Millisekunden, Mikrosekunden und Nanosekundenwerten dargestellt.
Temporal.Instant Experimentell: Repräsentiert einen einzigartigen Zeitpunkt 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 Zeitzone oder Kalendersystem.
Temporal.Now Experimentell: Bietet Methoden zum Abrufen der aktuellen Zeit in verschiedenen Formaten.
Temporal.PlainDate Experimentell: Repräsentiert ein Kalendarium (ein Datum ohne Zeit oder Zeitzone); zum Beispiel ein Ereignis in einem Kalender, das den ganzen Tag über unabhängig von der Zeitzone stattfindet. Es wird grundlegend als ISO 8601-Kalendarium mit Jahr-, Monat- und Tagesfeldern und einem assoziierten Kalendersystem dargestellt.
Temporal.PlainDateTime Experimentell: Repräsentiert ein Datum (Kalendarium) und eine Zeit (Wanduhrzeit) ohne Zeitzone. Es wird grundlegend als Kombination eines Datums (mit einem assoziierten Kalendersystem) und einer Zeit dargestellt.
Temporal.PlainMonthDay Experimentell: Repräsentiert den Monat und Tag eines Kalenderdatums ohne Jahr oder Zeitzone; zum Beispiel ein jährlich wiederkehrendes Ereignis, das den ganzen Tag über stattfindet. Es wird grundlegend als ISO 8601-Kalendarium mit Jahr-, Monat- und Tagesfeldern und einem assoziierten Kalendersystem dargestellt. Das Jahr wird verwendet, um den Monat-Tag in nicht-ISO-Kalendersystemen zu unterscheiden.
Temporal.PlainTime Experimentell: Repräsentiert eine Zeit ohne Datum oder Zeitzone; zum Beispiel ein sich wiederholendes Ereignis, das jeden Tag zur gleichen Zeit stattfindet. Es wird grundlegend als Kombination von Stunde-, Minute-, Sekunde-, Millisekunde-, Mikrosekunde- und Nanosekundenwerten dargestellt.
Temporal.PlainYearMonth Experimentell: Repräsentiert das Jahr und den Monat eines Kalenderdatums ohne Tag oder Zeitzone; zum Beispiel ein Ereignis auf einem Kalender, das während des ganzen Monats stattfindet. Es wird grundlegend als ISO 8601-Kalendarium mit Jahr-, Monat- und Tagesfeldern und einem assoziierten Kalendersystem dargestellt. Der Tag wird verwendet, um den Jahr-Monat in nicht-ISO-Kalendersystemen zu unterscheiden.
Temporal.ZonedDateTime Experimentell: Repräsentiert ein Datum und Uhrzeit mit Zeitzone. Es wird grundlegend als Kombination eines Moment, einer Zeitzone und eines Kalendersystems dargestellt.
Temporal[Symbol.toStringTag]: Der Initialwert der [Symbol.toStringTag]-Eigenschaft ist der String "Temporal". Diese Eigenschaft wird in Object.prototype.toString() verwendet.

Spezifikationen

Specification
Temporal # sec-temporal-objects

Browser-Kompatibilität

Siehe auch

Help improve MDN

Learn how to contribute Diese Seite wurde automatisch aus dem Englischen übersetzt.

Übersetzung auf GitHub anzeigen • Fehler mit dieser Übersetzung melden