Temporal

Eingeschrnkt verfgbar

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.

Mehr erfahren
Vollstndige Kompatibilitt anzeigen

Das Temporal-Objekt ermglicht die Verwaltung von Datum und Uhrzeit in verschiedenen Szenarien, darunter eingebaute Zeitzonen- und Kalenderdarstellung, Wanduhrenzeiteinheiten, Arithmetik, Formatierung und mehr. Es wurde als vollstndiger Ersatz fr das Date-Objekt entworfen.

Beschreibung

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

Temporal hat eine komplexe und leistungsstarke API. Es bietet ber seine verschiedenen Klassen mehr als 200 Hilfsmethoden an und kann so sehr komplex wirken. Wir geben Ihnen einen berblick darber, wie diese APIs miteinander in Beziehung stehen.

Hintergrund und Konzepte

JavaScript wird seit seinen ersten Tagen mit dem Date-Objekt fr die Handhabung von Datum und Zeit ausgeliefert. Die Date-API basiert jedoch auf der schlecht gestalteten java.util.Date-Klasse aus Java, die Anfang der 2010er Jahre ersetzt wurde; aber aufgrund von JavaScripts Ziel der Abwrtskompatibilitt bleibt Date in der Sprache erhalten.

Die wichtigste Lektion gleich zu Beginn der Einfhrung ist, dass Datumshandhabung komplex ist. Die meisten Probleme von Date sind durch das Hinzufgen weiterer Methoden behebbar, aber ein grundlegender Designfehler bleibt bestehen: Es bietet so viele Methoden auf demselben Objekt, dass Entwickler oft verwirrt sind, was sie verwenden sollen, was zu unerwarteten Problemen fhrt. Eine gut gestaltete API sollte nicht nur mehr knnen, sondern auf jeder Abstraktionsebene auch weniger tun, weil die Vermeidung von Fehlanwendungen ebenso wichtig ist wie das Ermglichen von Anwendungsfllen.

Date-Objekte haben eine Doppelfunktion:

Als Zeitstempel: die Anzahl der Millisekunden oder Nanosekunden, die seit einem festgelegten Zeitpunkt (bekannt als Epoch) vergangen sind.
Als Kombination von Komponenten: Jahr, Monat, Tag, Stunde, Minute, Sekunde, Millisekunde und Nanosekunde. Die Jahr-, Monat- und Tagbezeichner sind nur mit Bezug auf ein Kalendersystem sinnvoll. Die gesamte Kombination entspricht einem einzigartigen Moment in der Geschichte, wenn sie mit einer Zeitzone verknpft ist. Date-Objekte bieten Methoden zum Lesen und Modifizieren dieser Komponenten.

Zeitzonen sind die Ursache fr eine erhebliche Anzahl datumsbezogener Fehler. Bei der Interaktion mit einem Date ber das Modell der "Komponentenkombination" kann die Zeit nur in zwei Zeitzonen sein: UTC und lokal (Gert), und es gibt keine Mglichkeit, eine beliebige Zeitzone anzugeben. Auerdem fehlt das Konzept von "keine Zeitzone": Dies wird als Kalenderdatum (fr Daten) oder Wanduhrzeit (fr Zeiten) bezeichnet, was eine Zeit ist, die man "von einem Kalender oder einer Uhr abliest". Wenn Sie beispielsweise einen tglichen Wecker stellen, mchten Sie ihn auf "8:00 Uhr" stellen, unabhngig davon, ob Sommerzeit ist oder nicht, ob Sie in eine andere Zeitzone gereist sind usw.

Ein weiteres Merkmal, das bei Date fehlt, ist ein Kalendersystem. Die meisten Leute kennen den gregorianischen Kalender, 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; und so weiter. Einige dieser Konzepte gelten jedoch mglicherweise nicht, wenn Sie mit einem anderen Kalendersystem arbeiten, wie dem hebrischen Kalender, dem chinesischen Kalender, dem japanischen Kalender usw. Mit Date knnen Sie nur mit dem Modell des gregorianischen Kalenders arbeiten.

Es gibt viele andere unerwnschte Vermchtnisse von Date, wie zum Beispiel, dass alle Setzmethoden vernderlich sind (was oft unerwnschte Nebeneffekte verursacht), das Datums-Zeit-String-Format nicht konsistent geparst werden kann usw. Am Ende ist der beste Lsungsansatz, eine neue API von Grund auf zu entwickeln, was Temporal ist.

API-bersicht

Temporal ist ein Namensraum, hnlich wie Intl. Es enthlt verschiedene Klassen und Namensrume, von denen jeder einen bestimmten Aspekt der Verwaltung von Datum und Uhrzeit behandelt. Die Klassen lassen sich wie folgt gruppieren:

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 aus Datums- und Zeitkomponenten gepaart mit einer Zeitzone: Temporal.ZonedDateTime
- Darstellung eines zeitunbewussten Datums/Zeitpunkts (alle mit dem Prfix "Plain"):
  - Datum (Jahr, Monat, Tag) + Zeit (Stunde, Minute, Sekunde, Millisekunde, Mikrosekunde, Nanosekunde): Temporal.PlainDateTime (Hinweis: ZonedDateTime entspricht PlainDateTime plus einer Zeitzone)
    - Datum (Jahr, Monat, Tag): Temporal.PlainDate
      - Jahr, Monat: Temporal.PlainYearMonth
      - Monat, Tag: Temporal.PlainMonthDay
    - Zeit (Stunde, Minute, Sekunde, Millisekunde, Mikrosekunde, Nanosekunde): Temporal.PlainTime

Weiterhin gibt es einen weiteren 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 sich viele hnliche Methoden. Die folgende Tabelle listet alle Methoden jeder Klasse auf (auer 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	N/V	`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/V
Rundungen	`round()`	`round()`	`round()`	N/V	`round()`	N/V	N/V
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 verfgbar sind und vermittelt Ihnen eine Vorstellung davon, welche Informationen jede Klasse darstellen kann.

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

Konvertierung zwischen Klassen

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

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

Mit diesen Tabellen sollten Sie ein grundlegendes Verstndnis davon haben, wie Sie die Temporal-API navigieren knnen.

Kalender

Ein Kalender ist eine Mglichkeit, Tage zu organisieren, typischerweise in Perioden von Wochen, Monaten, Jahren und Epochen. Die meisten Teile der Welt verwenden den gregorianischen Kalender, aber es gibt viele andere Kalender, die insbesondere in religisen und kulturellen Kontexten verwendet werden. Standardmig verwenden alle kalenderbewussten Temporal-Objekte das ISO 8601-Kalendersystem, das auf dem gregorianischen Kalender basiert und zustzliche Regeln zur Wochennummerierung definiert. Intl.supportedValuesOf() listet die meisten Kalender auf, die wahrscheinlich von Browsern untersttzt werden. Hier geben wir einen kurzen berblick darber, wie Kalendersysteme gebildet werden, um Ihnen zu helfen, zu verstehen, welche Faktoren zwischen Kalendern variieren knnen.

Es gibt drei prominente periodische Ereignisse auf der Erde: Ihre Rotation um die Sonne (365,242 Tage fr eine Umdrehung), die Rotation des Mondes um die Erde (29,53 Tage von Neumond zu Neumond) und ihre Rotation um ihre Achse (24 Stunden von Sonnenaufgang zu Sonnenaufgang). Jede Kultur hat dieselbe Definition eines "Tages", das sind 24 Stunden. Gelegentliche nderungen wie Sommerzeit gehren nicht zum Kalender, sondern sind Teil der Zeitzonen-Informationen.

Einige Kalender definieren in erster Linie ein Jahr als durchschnittlich 365,242 Tage, indem sie Jahre mit 365 Tagen definieren und etwa alle 4 Jahre einen zustzlichen Tag, den Schalttag, hinzufgen. Dann kann das Jahr weiter in Teile geteilt werden, die Monate genannt werden. Diese Kalender werden Sonnenkalender genannt. Der gregorianische Kalender und der Solar Hijri-Kalender sind Sonnenkalender.
Einige Kalender definieren in erster Linie einen Monat als durchschnittlich 29,5 Tage, indem sie Monate definieren, die zwischen 29 und 30 Tagen alternieren. Dann knnen 12 Monate in einem Jahr von 354 Tagen gruppiert werden. Diese Kalender werden Mondkalender genannt. Der islamische Kalender ist ein Mondkalender. Da ein Mondjahr knstlich ist und nicht mit dem Jahreszeitenzyklus korreliert, sind Mondkalender im Allgemeinen seltener.
Einige Kalender definieren ebenfalls in erster Linie Monate basierend auf Mondzyklen, wie Mondkalender. Um jedoch die 11-tgige Abweichung zum Sonnenjahr auszugleichen, wird etwa alle 3 Jahre ein weiterer Monat, der Schaltmonat, hinzugefgt. Diese Kalender werden lunisolare Kalender genannt. Der hebrische 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. Whrend yearzumeist eine positive ganze Zahl ist, kann es auch null oder negativ sein und monoton mit der Zeit zunehmen. Das Jahr 1 (oder 0, falls es existiert) wird als Kalenderepoche bezeichnet und ist fr jeden Kalender willkrlich. month ist eine positive ganze Zahl, die bei jedem Schritt um 1 erhht wird, beginnend bei 1 und endend bei date.monthsInYear, und dann zurck auf 1 gesetzt wird, wenn das Jahr fortschreitet. day ist ebenfalls eine positive ganze Zahl, beginnt jedoch mglicherweise nicht bei 1 oder wird nicht jedes Mal um 1 erhht, da politische nderungen dazu fhren knnen, dass Tage bersprungen oder wiederholt werden. Im Allgemeinen erhht sich day jedoch monoton und wird zurckgesetzt, wenn der Monat fortschreitet.

Zustzlich zu year kann ein Jahr auch eindeutig durch die Kombination von era und eraYear fr Kalender identifiziert werden, die Epochen verwenden. Der gregorianische Kalender verwendet beispielsweise die Epoche "CE" (Common Era) und "BCE" (Before Common Era), und das Jahr -1 entspricht { era: "bce", eraYear: 2 } (beachten Sie, dass das Jahr 0 immer fr alle Kalender existiert; im gregorianischen Kalender entspricht es 1 v.Chr. aufgrund der astronomischen Jahrzhlung). 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 fr die lteste Epoche).

[!HINWEIS] Verwenden Sie immer era und eraYear als Paar; verwenden Sie nicht eine Eigenschaft, ohne die andere zu verwenden. Vermeiden Sie zudem Konflikte, indem Sie year und era/eraYear nicht kombinieren, wenn Sie ein Jahr angeben. Whlen Sie eine Jahresdarstellung und verwenden Sie sie konsequent.

Seien Sie vorsichtig bei den folgenden falschen Annahmen ber Jahre:

Gehen Sie nicht davon aus, dass era und eraYear immer vorhanden sind; sie knnen 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 zustzlichen Tag haben; sie knnen einen zustzlichen Monat haben.

Zustzlich zu month kann ein Monat in einem Jahr auch eindeutig durch den monthCode identifiziert werden. monthCode entspricht normalerweise dem Namen des Monats, month jedoch nicht. Zum Beispiel sind bei lunisolaren Kalendern zwei Monate mit demselben monthCode, wobei einer zu einem Schaltjahr gehrt und der andere nicht, unterschiedliche month-Werte, wenn sie nach dem Schaltmonat folgen, aufgrund der Einfgung eines zustzlichen Monats.

[!HINWEIS] Um Konflikte zu vermeiden, kombinieren Sie month und monthCode nicht, wenn Sie einen Monat angeben. Whlen Sie eine Monatsdarstellung und verwenden Sie sie konsequent. month ist ntzlicher, wenn Sie die Reihenfolge der Monate im Jahr bentigen (z.B. beim Durchlaufen der Monate), whrend monthCode ntzlicher ist, wenn Sie den Namen des Monats bentigen (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 korrespondieren.

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 Zeichenkette ist; verwenden Sie toLocaleString(), um Ihr Datum zu formatieren.

Speichern Sie im Allgemeinen den Namen der Monate nicht in einem Array oder Objekt. Auch wenn monthCode normalerweise dem Monatsnamen innerhalb eines Kalenders entspricht, empfehlen wir, stets den Monatsnamen zu berechnen, zum Beispiel mit date.toLocaleString("de-DE", { calendar: date.calendarId, month: "long" }).

Zustzlich zu day (was ein monatsbasiertes Indiz ist) kann ein Tag in einem Jahr auch eindeutig durch dayOfYear identifiziert werden. dayOfYear ist eine positive Ganzzahl, die sich bei jedem Schritt um 1 erhht, beginnend bei 1 und endend bei date.daysInYear.

Das Konzept einer "Woche" ist mit keinem astronomischen Ereignis verbunden, sondern ein kulturelles Konstrukt. Whrend die hufigste Lnge 7 Tage betrgt, knnen Wochen auch 4, 5, 6, 8 oder mehr Tage haben oder sogar gar keine feste Anzahl von Tagen. Um die spezifische Anzahl von Tagen der Woche eines Datums zu erhalten, verwenden Sie daysInWeek des Datums. Temporal identifiziert Wochen durch die Kombination von weekOfYear und yearOfWeek. weekOfYear ist eine positive Ganzzahl, die sich bei jedem Schritt um 1 erhht, beginnend bei 1 und dann zu 1 zurcksetzt, wenn das Jahr fortschreitet. yearOfWeek ist im Allgemeinen dasselbe wie year, kann aber zu Beginn oder Ende jedes Jahres anders sein, weil eine Woche zwei Jahre berqueren kann, und yearOfWeek eines der beiden Jahre basierend auf den Regeln des Kalenders auswhlt.

[!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 knnen undefined sein.

Gehen Sie nicht davon aus, dass Wochen immer 7 Tage haben; verwenden Sie daysInWeek.

Beachten Sie, dass die aktuelle Temporal-API keine Jahr-Woche-Daten untersttzt, sodass Sie keine Daten mit diesen Eigenschaften konstruieren oder Daten in Jahr-Woche-Darstellungen serialisieren knnen. Sie sind nur informative Eigenschaften.

RFC 9557 Format

Alle Temporal-Klassen knnen unter Verwendung des Formats gem RFC 9557 serialisiert und deserialisiert werden, das auf ISO 8601 / RFC 3339 basiert. Das Format in seiner vollstndigen Form ist wie folgt (Leerzeichen dienen nur der Lesbarkeit und sollten im tatschlichen 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. In der Dokumentation jeder Klasse finden Sie einen Abschnitt mit dem Titel "RFC 9557 Format", der das von dieser Klasse erkannte Format spezifiziert.

Das ist sehr hnlich zum Datums-Zeit-String-Format, das von Date verwendet wird, welches ebenfalls auf ISO 8601 basiert. Die Hauptneuerung ist die Mglichkeit, Mikro- und Nanosekundenkomponenten anzugeben sowie die Zeitzone und das Kalendersystem zu spezifizieren.

Darstellbare Daten

Alle Temporal-Objekte, die ein bestimmtes Kalendariumdatum darstellen, legen eine hnliche Grenze fr den Bereich der darstellbaren Daten fest, die 108 Tage (einschlielich) ab der Unix-Epoche oder den Bereich der Momente von -271821-04-20T00:00:00 bis +275760-09-13T00:00:00 umfasst. Dies ist derselbe Bereich wie gltige Daten. Genauer gesagt:

Temporal.Instant und Temporal.ZonedDateTime wenden dieses Limit direkt auf ihren epochNanoseconds-Wert an.
Temporal.PlainDateTime interpretiert das Datum und die Uhrzeit in der UTC-Zeitzone und erfordert, dass sie (108 + 1) Tage (exklusiv) von der Unix-Epoche entfernt sind, sodass ihr gltiger Bereich -271821-04-19T00:00:00 bis +275760-09-14T00:00:00 ist, exklusiv. Dies ermglicht es jedem ZonedDateTime, unabhngig von seinem Offset in ein PlainDateTime konvertiert zu werden.
Temporal.PlainDate fhrt die gleiche berprfung wie PlainDateTime zur Mittagszeit (12:00:00) dieses Datums durch, sodass ihr gltiger Bereich -271821-04-19 bis +275760-09-13 betrgt. Dies ermglicht es jedem PlainDateTime, unabhngig von seiner Uhrzeit in ein PlainDate umgewandelt zu werden und umgekehrt.
Temporal.PlainYearMonth hat den gltigen Bereich von -271821-04 bis +275760-09. Dies ermglicht es jedem PlainDate, unabhngig von seinem Datum (auer wenn der erste Tag eines nicht-ISO-Monats in den ISO-Monat -271821-03 fllt) in ein PlainYearMonth umgewandelt zu werden.

Die Temporal-Objekte werden sich weigern, eine Instanz zu konstruieren, die ein Datum/Zeitp htte, das ber diesem Limit liegt. Dies schliet ein:

Die Verwendung des Konstruktors oder der statischen Methode from().
Die Verwendung der Methode with() zur Aktualisierung von Kalendereintrgen.
Die Verwendung von add(), subtract(), round() oder einer anderen Methode, um neue Instanzen abzuleiten.

Statische Eigenschaften

Temporal.Duration: Stellt einen Unterschied zwischen zwei Zeitpunkten dar, der in der Datums-/Uhrzeitarithmetik verwendet werden kann. Es wird grundlegend als Kombination von Jahren, Monaten, Wochen, Tagen, Stunden, Minuten, Sekunden, Millisekunden, Mikrosekunden und Nanosekunden-Werten dargestellt.
Temporal.Instant: Stellt einen einzigartigen Punkt in der Zeit mit Nanosekundenprzision dar. Es wird grundlegend als die Anzahl der Nanosekunden seit der Unix-Epoche (Mitternacht zu Beginn des 1. Januar 1970, UTC) dargestellt, ohne jegliche Zeitzone oder Kalendersystem.
Temporal.Now: Bietet Methoden zum Abrufen der aktuellen Zeit in verschiedenen Formaten.
Temporal.PlainDate: Stellt ein Kalenderdatum dar (ein Datum ohne Zeit oder Zeitzone); zum Beispiel ein Ereignis in einem Kalender, das den ganzen Tag unabhngig von der Zeitzone geschieht, in der es stattfindet. Es wird grundlegend als ISO 8601-Kalenderdatum mit Jahr-, Monat- und Tagefeldern und einem zugehrigen Kalendersystem dargestellt.
Temporal.PlainDateTime: Stellt ein Datum (Kalenderdatum) und eine Uhrzeit (Wanduhrzeit) ohne Zeitzone dar. Es wird grundlegend als Kombination aus einem Datum (mit einem zugehrigen Kalendersystem) und einer Zeit dargestellt.
Temporal.PlainMonthDay: Stellt den Monat und Tag eines Kalenderdatums dar, ohne Jahr oder Zeitzone; zum Beispiel ein Ereignis auf einem Kalender, das jedes Jahr wiederkehrt und den ganzen Tag ber geschieht. Es wird grundlegend als ISO 8601-Kalenderdatum mit Jahr-, Monat- und Tagefeldern und einem zugehrigen Kalendersystem dargestellt. Das Jahr wird verwendet, um den Monat-Tag in nicht-ISO-Kalendersystemen zu klren.
Temporal.PlainTime: Stellt eine Zeit ohne Datum oder Zeitzone dar; zum Beispiel ein wiederkehrendes Ereignis, das jeden Tag zur gleichen Zeit stattfindet. Es wird grundlegend als Kombination von Stunde, Minute, Sekunde, Millisekunde, Mikrosekunde und Nanosekunde dargestellt.
Temporal.PlainYearMonth: Stellt das Jahr und den Monat eines Kalenderdatums dar, ohne Tag oder Zeitzone; zum Beispiel ein Ereignis in einem Kalender, das den ganzen Monat ber stattfindet. Es wird grundlegend als ISO 8601-Kalenderdatum mit Jahr-, Monat- und Tagefeldern und einem zugehrigen Kalendersystem dargestellt. Der Tag wird verwendet, um das Jahr-Monat in nicht-ISO-Kalendersystemen zu klren.
Temporal.ZonedDateTime: Stellt ein Datum und eine Uhrzeit mit einer Zeitzone dar. Es wird grundlegend als Kombination eines Zeitpunkts, einer Zeitzone und eines Kalendersystems dargestellt.
Temporal[Symbol.toStringTag]: Der Anfangswert der [Symbol.toStringTag]-Eigenschaft ist der String "Temporal". Diese Eigenschaft wird in Object.prototype.toString() verwendet.

Spezifikationen

Spezifikation
Temporal # sec-temporal-objects

Browser-Kompatibilitt

Siehe auch

Help improve MDN

War diese bersetzung hilfreich?

Ja Nein

Erfahren Sie, wie Sie beitragen knnen Diese Seite wurde automatisch aus dem Englischen bersetzt.

bersetzung auf GitHub anzeigen Fehler mit dieser bersetzung melden