Temporal

Eingeschränkt verfügbar

Diese Funktion ist nicht Baseline, da sie in einigen der am weitesten verbreiteten Browser nicht funktioniert.

Want more browser support for this feature? Tell us why.

Vollständige Kompatibilität anzeigen
Mehr erfahren

Das Temporal-Objekt ermöglicht die Verwaltung von Datum und Uhrzeit in verschiedenen Szenarien. Dazu gehören die integrierte Darstellung von Zeitzonen und Kalendersystemen, die Umrechnung von Uhrzeiten, Berechnungen, Formatierung und mehr. Es ist als vollständiger Ersatz für das Date-Objekt konzipiert.

Beschreibung

Anders als die meisten globalen Objekte 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, genau wie beim Math-Objekt.

Temporal verfügt über eine umfangreiche und leistungsfähige API. Sie stellt über mehrere Klassen hinweg mehr als 200 Hilfsmethoden bereit und kann daher sehr komplex wirken. Im Folgenden erhalten Sie einen Überblick darüber, wie diese APIs zusammenhängen. Weitere Informationen finden Sie im Leitfaden Datums- und Uhrzeitwerte darstellen zum Temporal-Objekt und in der Temporal-Rezeptsammlung mit Codebeispielen für häufige Anwendungsfälle, darunter die Migration von Date zu Temporal.

Hintergrund und Konzepte

JavaScript verfügt seit seinen Anfängen über das Date-Objekt zur Verarbeitung von Datum und Uhrzeit. Die Date-API basiert jedoch auf der wenig durchdachten Java-Klasse java.util.Date, die Anfang der 2010er-Jahre ersetzt wurde. Da JavaScript auf Abwärtskompatibilität setzt, ist Date weiterhin Teil der Sprache.

Die wichtigste Erkenntnis vorab lautet: Die Verarbeitung von Datumsangaben ist komplex. Viele Probleme von Date ließen sich durch zusätzliche Methoden beheben. Ein grundlegender Entwurfsfehler bleibt jedoch bestehen: Das Objekt stellt so viele Methoden bereit, dass oft unklar ist, welche davon verwendet werden sollte. Das führt zu unerwarteten Fallstricken. Eine gut gestaltete API muss nicht nur mehr ermöglichen, sondern auf jeder Abstraktionsebene auch weniger tun. Fehlanwendungen zu verhindern ist ebenso wichtig wie Anwendungsfälle zu ermöglichen.

Date-Objekte erfüllen gleichzeitig zwei Aufgaben:

Als Zeitstempel: die Anzahl der Millisekunden oder Nanosekunden, die seit einem festen Zeitpunkt, der sogenannten Epoche, vergangen sind.
Als Kombination von Komponenten: Jahr, Monat, Tag, Stunde, Minute, Sekunde, Millisekunde und Nanosekunde. Jahr, Monat und Tag sind nur in Bezug auf ein Kalendersystem sinnvoll. Zusammen mit einer Zeitzone lässt sich die gesamte Kombination einem eindeutigen Zeitpunkt zuordnen. Date-Objekte bieten Methoden zum Lesen und Ändern dieser Komponenten.

Zeitzonen sind die Ursache vieler datumsbezogener Fehler. Wenn Sie mit einem Date nach dem Modell der „Kombination von Komponenten“ arbeiten, kann die Uhrzeit nur in zwei Zeitzonen angegeben werden: UTC und der lokalen Zeitzone des Geräts. Eine beliebige Zeitzone lässt sich nicht angeben. Ebenso fehlt das Konzept „ohne Zeitzone“: Bei Datumsangaben handelt es sich dabei um ein Kalenderdatum, bei Uhrzeiten um eine Wanduhrzeit – also einen Wert, den Sie von einem Kalender oder einer Uhr ablesen. Wenn Sie beispielsweise einen täglichen Weckalarm einstellen, soll dieser unabhängig von der Sommerzeit oder einer Reise in eine andere Zeitzone um „8:00 Uhr“ ausgelöst werden.

Ein weiteres Konzept, das Date fehlt, ist das Kalendersystem. Die meisten Menschen kennen den gregorianischen Kalender: Er unterscheidet die Zeitrechnungen vor und nach Christus, hat zwölf Monate mit unterschiedlich vielen Tagen und ungefähr alle vier Jahre ein Schaltjahr. Bei anderen Kalendersystemen wie dem hebräischen, chinesischen oder japanischen Kalender gelten manche dieser Regeln jedoch nicht. Mit Date können Sie nur nach dem Modell des gregorianischen Kalenders arbeiten.

Date bringt weitere unerwünschte Altlasten mit sich: Alle Setter verändern das bestehende Objekt, was häufig unbeabsichtigte Nebenwirkungen verursacht. Außerdem lässt sich das Format für Datums- und Uhrzeitzeichenfolgen nicht auf konsistente Weise parsen. Die beste Lösung ist daher eine von Grund auf neu entwickelte API: Temporal.

Überblick über die API

Temporal ist ein Namensraum wie Intl. Er enthält mehrere Klassen und Namensräume, die jeweils für einen bestimmten Aspekt der Verwaltung von Datum und Uhrzeit ausgelegt sind. Die Klassen lassen sich wie folgt gruppieren:

Darstellung einer Zeitdauer, also der Differenz zwischen zwei Zeitpunkten: Temporal.Duration
Darstellung eines Zeitpunkts:
- Darstellung eines eindeutigen Zeitpunkts:
  - Als Zeitstempel: Temporal.Instant
  - Als Kombination von Datums- und Uhrzeitkomponenten mit einer Zeitzone: Temporal.ZonedDateTime
- Darstellung eines Datums oder einer Uhrzeit ohne Zeitzone (alle mit dem Präfix „Plain“):
  - Datum (Jahr, Monat, Tag) + Uhrzeit (Stunde, Minute, Sekunde, Millisekunde, Mikrosekunde, Nanosekunde): Temporal.PlainDateTime (Hinweis: ZonedDateTime entspricht PlainDateTime mit einer zusätzlichen Zeitzone.)
    - Datum (Jahr, Monat, Tag): Temporal.PlainDate
      - Jahr, Monat: Temporal.PlainYearMonth
      - Monat, Tag: Temporal.PlainMonthDay
    - Uhrzeit (Stunde, Minute, Sekunde, Millisekunde, Mikrosekunde, Nanosekunde): Temporal.PlainTime

Daneben gibt es den Hilfsnamensraum Temporal.Now. Er stellt Methoden bereit, um die aktuelle Zeit in verschiedenen Formaten abzurufen.

Gemeinsame Schnittstelle der Klassen

Der Namensraum Temporal enthält viele Klassen, die zahlreiche ähnliche Methoden besitzen. Die folgende Tabelle führt alle Methoden der einzelnen Klassen auf, mit Ausnahme der 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()`
Aktualisierung	Nicht verfügbar	`with()` `withCalendar()` `withTimeZone()` `withPlainTime()`	`with()` `withCalendar()` `withPlainTime()`	`with()` `withCalendar()`	`with()`	`with()`	`with()`
Berechnungen	`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 verfügbar
Rundung	`round()`	`round()`	`round()`	Nicht verfügbar	`round()`	Nicht verfügbar	Nicht verfügbar
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 zeigt, welche Eigenschaften die einzelnen Klassen bereitstellen. Dadurch wird deutlich, welche Informationen eine Klasse darstellen kann.

	`Instant`	`ZonedDateTime`	`PlainDateTime`	`PlainDate`	`PlainTime`	`PlainYearMonth`	`PlainMonthDay`
Kalender	Nicht verfügbar	`calendarId`	`calendarId`	`calendarId`	Nicht verfügbar	`calendarId`	`calendarId`
Jahresbezogen	Nicht verfügbar	`era` `eraYear` `year` `inLeapYear` `monthsInYear` `daysInYear`	`era` `eraYear` `year` `inLeapYear` `monthsInYear` `daysInYear`	`era` `eraYear` `year` `inLeapYear` `monthsInYear` `daysInYear`	Nicht verfügbar	`era` `eraYear` `year` `inLeapYear` `monthsInYear` `daysInYear`	Nicht verfügbar
Monatsbezogen	Nicht verfügbar	`month` `monthCode` `daysInMonth`	`month` `monthCode` `daysInMonth`	`month` `monthCode` `daysInMonth`	Nicht verfügbar	`month` `monthCode` `daysInMonth`	`monthCode`
Wochenbezogen	Nicht verfügbar	`weekOfYear` `yearOfWeek` `daysInWeek`	`weekOfYear` `yearOfWeek` `daysInWeek`	`weekOfYear` `yearOfWeek` `daysInWeek`	Nicht verfügbar	Nicht verfügbar	Nicht verfügbar
Tagesbezogen	Nicht verfügbar	`day` `dayOfWeek` `dayOfYear`	`day` `dayOfWeek` `dayOfYear`	`day` `dayOfWeek` `dayOfYear`	Nicht verfügbar	Nicht verfügbar	`day`
Uhrzeitkomponenten	Nicht verfügbar	`hour` `minute` `second` `millisecond` `microsecond` `nanosecond`	`hour` `minute` `second` `millisecond` `microsecond` `nanosecond`	Nicht verfügbar	`hour` `minute` `second` `millisecond` `microsecond` `nanosecond`	Nicht verfügbar	Nicht verfügbar
Zeitzone	Nicht verfügbar	`timeZoneId` `offset` `offsetNanoseconds` `hoursInDay` `getTimeZoneTransition()` `startOfDay()`	Nicht verfügbar	Nicht verfügbar	Nicht verfügbar	Nicht verfügbar	Nicht verfügbar
Zeit seit der Epoche	`epochMilliseconds` `epochNanoseconds`	`epochMilliseconds` `epochNanoseconds`	Nicht verfügbar	Nicht verfügbar	Nicht verfügbar	Nicht verfügbar	Nicht verfügbar

Konvertierung zwischen Klassen

Die folgende Tabelle fasst alle Konvertierungsmethoden der einzelnen Klassen zusammen.

		`Instant`	`ZonedDateTime`	`PlainDateTime`	`PlainDate`	`PlainTime`	`PlainYearMonth`	`PlainMonthDay`
		Konvertierung von …
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 gemeinsamen Informationen	`toPlainDate()`	`toPlainDate()`
	`PlainTime`		`toPlainTime()`	`toPlainTime()`	Keine gemeinsamen Informationen	/	Keine gemeinsamen Informationen
	`PlainYearMonth`		Zuerst in `PlainDate` konvertieren		`toPlainYearMonth()`	Keine gemeinsamen Informationen	/	Zuerst in `PlainDate` konvertieren
	`PlainMonthDay`		Zuerst in `PlainDate` konvertieren		`toPlainMonthDay()`	Keine gemeinsamen Informationen	Zuerst in `PlainDate` konvertieren	/

Diese Tabellen vermitteln Ihnen eine grundlegende Orientierung in der Temporal-API.

Kalendersysteme

Ein Kalendersystem ordnet Tage üblicherweise in Zeitabschnitte wie Wochen, Monate, Jahre und Ären ein. Der größte Teil der Welt verwendet den gregorianischen Kalender. Daneben sind zahlreiche andere Kalendersysteme gebräuchlich, insbesondere in religiösen und kulturellen Zusammenhängen. Standardmäßig verwenden alle kalenderbezogenen Temporal-Objekte das Kalendersystem ISO 8601. Es basiert auf dem gregorianischen Kalender und definiert zusätzliche Regeln für die Nummerierung von Wochen. Intl.supportedValuesOf() listet die meisten Kalendersysteme auf, die Browser voraussichtlich unterstützen. Der folgende Überblick über den Aufbau von Kalendersystemen soll Ihnen verdeutlichen, welche Merkmale sich unterscheiden können.

Drei periodische Vorgänge sind auf der Erde besonders wichtig: ihr Umlauf um die Sonne (365,242 Tage pro Umlauf), der Umlauf des Mondes um die Erde (29,53 Tage von Neumond zu Neumond) und die Rotation der Erde um ihre eigene Achse (24 Stunden von Sonnenaufgang zu Sonnenaufgang). Alle Kulturen verwenden dieselbe Maßeinheit für einen „Tag“: 24 Stunden. Gelegentliche Änderungen wie die Sommerzeit gehören nicht zum Kalendersystem, sondern zu den Informationen einer Zeitzone.

Manche Kalendersysteme legen ein Jahr hauptsächlich anhand der durchschnittlichen Länge von 365,242 Tagen fest: Ein Jahr hat 365 Tage, und ungefähr alle vier Jahre kommt ein zusätzlicher Tag hinzu, der Schalttag. Das Jahr kann weiter in Monate unterteilt werden. Diese Systeme heißen Sonnenkalender. Der gregorianische und der iranische Kalender sind Sonnenkalender.
Andere Kalendersysteme legen einen Monat hauptsächlich anhand einer durchschnittlichen Länge von 29,5 Tagen fest, indem Monate abwechselnd 29 und 30 Tage haben. Zwölf Monate können dann zu einem Jahr mit 354 Tagen zusammengefasst werden. Diese Systeme heißen Mondkalender. Der islamische Kalender ist ein Mondkalender. Da ein Mondjahr nicht mit dem Zyklus der Jahreszeiten übereinstimmt, sind reine Mondkalender vergleichsweise selten.
Wieder andere Kalendersysteme legen die Monate ebenfalls hauptsächlich anhand der Mondzyklen fest. Um die Abweichung von elf Tagen gegenüber dem Sonnenjahr auszugleichen, fügen sie ungefähr alle drei Jahre einen zusätzlichen Monat ein, den Schaltmonat. Diese Systeme heißen lunisolare Kalender. Der hebräische und der chinesische Kalender sind lunisolare Kalender.

In Temporal wird jedes Datum innerhalb eines Kalendersystems durch drei Komponenten eindeutig bestimmt: year, month und day. year ist normalerweise eine positive ganze Zahl, kann aber auch null oder negativ sein und nimmt im Zeitverlauf monoton zu. Das Jahr 1 (oder 0, sofern vorhanden) bezeichnet den Beginn der Zeitrechnung des jeweiligen Kalendersystems und ist für jedes System frei festgelegt. month ist eine positive ganze Zahl, die jeweils um 1 steigt. Sie beginnt bei 1, reicht bis date.monthsInYear und springt beim nächsten Jahr wieder auf 1. Auch day ist eine positive ganze Zahl. Der Wert muss jedoch nicht bei 1 beginnen oder stets um 1 steigen, da politische Änderungen dazu führen können, dass Tage ausgelassen oder wiederholt werden. Im Allgemeinen steigt day jedoch monoton an und wird beim nächsten Monat zurückgesetzt.

Neben year kann in Kalendersystemen mit Ären auch die Kombination aus era und eraYear ein Jahr eindeutig bestimmen. Der gregorianische Kalender verwendet beispielsweise die Ären „CE“ (Common Era) und „BCE“ (Before Common Era). Das Jahr -1 entspricht { era: "bce", eraYear: 2 }. Beachten Sie, dass das Jahr 0 in allen Kalendersystemen existiert; im gregorianischen Kalender entspricht es aufgrund der astronomischen Jahreszählung dem Jahr 1 v. Chr. era ist eine Zeichenfolge in Kleinbuchstaben. eraYear ist eine beliebige ganze Zahl, die null oder negativ sein oder im Zeitverlauf sogar abnehmen kann – normalerweise bei der ältesten Ära.

Hinweis: Verwenden Sie era und eraYear immer zusammen; verwenden Sie keine der beiden Eigenschaften ohne die andere. Um Konflikte zu vermeiden, sollten Sie außerdem year nicht mit era/eraYear kombinieren, wenn Sie ein Jahr angeben. Wählen Sie eine Darstellung des Jahres und verwenden Sie diese konsequent.

Vermeiden Sie folgende falsche 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 stattdessen toLocaleString(), um das Datum zu formatieren.
Gehen Sie nicht davon aus, dass zwei year-Werte aus verschiedenen Kalendersystemen vergleichbar sind. Verwenden Sie stattdessen die statische Methode compare().
Gehen Sie nicht davon aus, dass Jahre 365 oder 366 Tage und zwölf 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önnen auch einen zusätzlichen Monat haben.

Neben month kann auch monthCode einen Monat innerhalb eines Jahres eindeutig bestimmen. monthCode entspricht normalerweise dem Namen des Monats, month dagegen nicht. In lunisolaren Kalendern haben beispielsweise zwei Monate mit demselben monthCode unterschiedliche month-Werte, wenn einer in einem Schaltjahr liegt, der andere nicht und sie nach dem Schaltmonat liegen. Das liegt am eingefügten zusätzlichen Monat.

Hinweis: Um Konflikte zu vermeiden, sollten Sie month und monthCode nicht kombinieren, wenn Sie einen Monat angeben. Wählen Sie eine Darstellung des Monats und verwenden Sie diese konsequent. month ist hilfreicher, wenn Sie die Reihenfolge der Monate innerhalb eines Jahres benötigen, etwa beim Durchlaufen aller Monate. monthCode ist hilfreicher, wenn Sie den Monatsnamen benötigen, beispielsweise zum Speichern von Geburtstagen.

Vermeiden Sie folgende falsche Annahmen über Monate:

Gehen Sie nicht davon aus, dass monthCode und month immer einander entsprechen.
Gehen Sie nicht von einer festen Anzahl von Tagen pro Monat aus. Verwenden Sie stattdessen daysInMonth.
Gehen Sie nicht davon aus, dass monthCode eine benutzerfreundliche Zeichenfolge ist. Verwenden Sie stattdessen toLocaleString(), um das Datum zu formatieren.
Speichern Sie Monatsnamen grundsätzlich nicht in einem Array oder Objekt zwischen. Obwohl monthCode innerhalb eines Kalendersystems normalerweise einem Monatsnamen entspricht, empfehlen wir, den Monatsnamen stets neu zu ermitteln, beispielsweise mit date.toLocaleString("en-US", { calendar: date.calendarId, month: "long" }).

Neben day, einem auf den Monat bezogenen Index, kann auch dayOfYear einen Tag innerhalb eines Jahres eindeutig bestimmen. dayOfYear ist eine positive ganze Zahl, die jeweils um 1 steigt. Sie beginnt bei 1 und reicht bis date.daysInYear.

Das Konzept einer „Woche“ ist nicht an ein astronomisches Ereignis gebunden, sondern kulturell festgelegt. Am häufigsten umfasst eine Woche 7 Tage. Sie kann aber auch 4, 5, 6, 8 oder mehr Tage haben – oder überhaupt keine feste Anzahl von Tagen. Die Anzahl der Tage einer Woche für ein bestimmtes Datum erhalten Sie über dessen daysInWeek. Temporal bestimmt Wochen anhand der Kombination aus weekOfYear und yearOfWeek. weekOfYear ist eine positive ganze Zahl, die bei 1 beginnt, jeweils um 1 steigt und beim nächsten Jahr wieder auf 1 springt. yearOfWeek entspricht im Allgemeinen year, kann aber am Anfang oder Ende eines Jahres davon abweichen: Eine Woche kann sich über zwei Jahre erstrecken, und yearOfWeek wählt nach den Regeln des Kalendersystems eines dieser beiden Jahre aus.

Hinweis: Verwenden Sie weekOfYear und yearOfWeek immer zusammen; kombinieren Sie weekOfYear nicht mit year.

Vermeiden Sie folgende falsche 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 sieben Tage lang sind. Verwenden Sie stattdessen daysInWeek.
Beachten Sie, dass die aktuelle Temporal-API keine Jahr-Woche-Datumsangaben unterstützt. Sie können mit diesen Eigenschaften daher weder Datumswerte erstellen noch Datumswerte als Jahr-Woche-Angaben serialisieren. Die Eigenschaften dienen nur zur Information.

RFC-9557-Format

Alle Temporal-Klassen können im Format von RFC 9557 serialisiert und deserialisiert werden. Dieses Format basiert auf ISO 8601 / RFC 3339. In seiner vollständigen Form sieht es wie folgt aus. Die Leerzeichen dienen nur der Lesbarkeit und dürfen in der tatsächlichen Zeichenfolge nicht vorkommen:

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

Für die einzelnen Klassen gelten unterschiedliche Anforderungen daran, welche Komponenten vorhanden sein müssen. In der Dokumentation jeder Klasse finden Sie deshalb einen Abschnitt mit dem Titel „RFC-9557-Format“, der das von der jeweiligen Klasse erkannte Format beschreibt.

Es ähnelt stark dem Format für Datums- und Uhrzeitzeichenfolgen von Date, das ebenfalls auf ISO 8601 basiert. Die wichtigsten Ergänzungen sind die Möglichkeit, Mikrosekunden- und Nanosekundenkomponenten sowie die Zeitzone und das Kalendersystem anzugeben.

Darstellbare Datumswerte

Für alle Temporal-Objekte, die ein bestimmtes Kalenderdatum darstellen, gilt eine ähnliche Begrenzung des darstellbaren Bereichs: ±10⁸ Tage (einschließlich) relativ zur Unix-Epoche. Das entspricht dem Bereich von Zeitpunkten zwischen -271821-04-20T00:00:00 und +275760-09-13T00:00:00. Es ist derselbe Bereich wie bei gültigen Datumswerten. Im Einzelnen gilt:

Temporal.Instant und Temporal.ZonedDateTime wenden diese Grenze direkt auf ihren epochNanoseconds-Wert an.
Temporal.PlainDateTime interpretiert Datum und Uhrzeit in der Zeitzone UTC und verlangt, dass der Wert innerhalb von ±(10⁸ + 1) Tagen (ohne die Grenzwerte) relativ zur Unix-Epoche liegt. Der gültige Bereich reicht daher von -271821-04-19T00:00:00 bis +275760-09-14T00:00:00, jeweils ohne die Grenzwerte. Dadurch kann jedes ZonedDateTime unabhängig von seinem Offset in ein PlainDateTime konvertiert werden.
Temporal.PlainDate führt dieselbe Prüfung wie PlainDateTime für die Mittagszeit (12:00:00) des betreffenden Datums durch. Der gültige Bereich reicht daher von -271821-04-19 bis +275760-09-13. Dadurch kann jedes PlainDateTime unabhängig von seiner Uhrzeit in ein PlainDate konvertiert werden und umgekehrt.
Temporal.PlainYearMonth hat den gültigen Bereich -271821-04 bis +275760-09. Dadurch kann jedes PlainDate unabhängig von seinem Tag in ein PlainYearMonth konvertiert werden. Eine Ausnahme besteht, wenn der erste Tag eines Monats in einem Nicht-ISO-Kalendersystem in den ISO-Monat -271821-03 fällt.

Temporal-Objekte lassen sich nicht erstellen, wenn sie ein Datum oder eine Uhrzeit außerhalb dieser Grenzen darstellen würden. Dies gilt unter anderem für:

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

Statische Eigenschaften

Temporal.Duration: Stellt die Differenz zwischen zwei Zeitpunkten dar und kann für Berechnungen mit Datums- und Uhrzeitwerten verwendet werden. Grundlage ist eine Kombination von Werten für Jahre, Monate, Wochen, Tage, Stunden, Minuten, Sekunden, Millisekunden, Mikrosekunden und Nanosekunden.
Temporal.Instant: Stellt einen eindeutigen Zeitpunkt mit Nanosekundengenauigkeit dar. Grundlage ist die Anzahl der Nanosekunden seit der Unix-Epoche (Mitternacht zu Beginn des 1. Januar 1970 in UTC), ohne Zeitzone oder Kalendersystem.
Temporal.Now: Stellt Methoden bereit, um die aktuelle Zeit in verschiedenen Formaten abzurufen.
Temporal.PlainDate: Stellt ein Kalenderdatum ohne Uhrzeit oder Zeitzone dar. Ein Beispiel ist ein Kalendereintrag, der unabhängig von der Zeitzone den ganzen Tag dauert. Grundlage ist ein Datum nach ISO 8601 mit Feldern für Jahr, Monat und Tag sowie einem zugehörigen Kalendersystem.
Temporal.PlainDateTime: Stellt ein Datum (Kalenderdatum) und eine Uhrzeit (Wanduhrzeit) ohne Zeitzone dar. Grundlage ist die Kombination aus einem Datum mit einem zugehörigen Kalendersystem und einer Uhrzeit.
Temporal.PlainMonthDay: Stellt Monat und Tag eines Kalenderdatums ohne Jahr oder Zeitzone dar. Ein Beispiel ist ein Kalendereintrag, der jedes Jahr wiederkehrt und den ganzen Tag dauert. Grundlage ist ein Datum nach ISO 8601 mit Feldern für Jahr, Monat und Tag sowie einem zugehörigen Kalendersystem. Das Jahr dient dazu, Monat und Tag in Nicht-ISO-Kalendersystemen eindeutig zu bestimmen.
Temporal.PlainTime: Stellt eine Uhrzeit ohne Datum oder Zeitzone dar. Ein Beispiel ist ein wiederkehrendes Ereignis, das jeden Tag zur selben Uhrzeit stattfindet. Grundlage ist eine Kombination von Werten für Stunde, Minute, Sekunde, Millisekunde, Mikrosekunde und Nanosekunde.
Temporal.PlainYearMonth: Stellt Jahr und Monat eines Kalenderdatums ohne Tag oder Zeitzone dar. Ein Beispiel ist ein Kalendereintrag, der den ganzen Monat dauert. Grundlage ist ein Datum nach ISO 8601 mit Feldern für Jahr, Monat und Tag sowie einem zugehörigen Kalendersystem. Der Tag dient dazu, Jahr und Monat in Nicht-ISO-Kalendersystemen eindeutig zu bestimmen.
Temporal.ZonedDateTime: Stellt ein Datum und eine Uhrzeit mit Zeitzone dar. Grundlage ist die Kombination aus einem Zeitpunkt, einer Zeitzone und einem Kalendersystem.
Temporal[Symbol.toStringTag]: Der Anfangswert der Eigenschaft [Symbol.toStringTag] ist die Zeichenfolge "Temporal". Diese Eigenschaft wird von Object.prototype.toString() verwendet.

Spezifikationen

Spezifikation
Temporal # sec-temporal-objects

Browser-Kompatibilität

Siehe auch

Help improve MDN

Erfahren Sie, wie Sie beitragen können Diese Seite wurde automatisch aus dem Englischen übersetzt.

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