Dieser Inhalt wurde automatisch aus dem Englischen übersetzt, und kann Fehler enthalten.Erfahre mehr über dieses Experiment.

View in EnglishAlways switch to English

Temporal

Limited availability

This feature is not Baseline because it does not work in some of the most widely-used browsers.

DasTemporal-Objekt ermöglicht die Verwaltung von Datum und Uhrzeit in verschiedenen Szenarien, darunter eingebaute Zeitzonen- und Kalenderdarstellung, Wanduhrenzeiteinheiten, Arithmetik, Formatierung und mehr. Es wurde als vollständiger Ersatz für dasDate-Objekt entworfen.

Beschreibung

Im Gegensatz zu den meisten globalen Objekten istTemporal kein Konstruktor. Sie können es nicht mit demnew-Operator verwenden oder dasTemporal-Objekt als Funktion aufrufen. Alle Eigenschaften und Methoden vonTemporal sind statisch (genau wie dasMath-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 darüber, wie diese APIs miteinander in Beziehung stehen.

Hintergrund und Konzepte

JavaScript wird seit seinen ersten Tagen mit demDate-Objekt für die Handhabung von Datum und Zeit ausgeliefert. DieDate-API basiert jedoch auf der schlecht gestaltetenjava.util.Date-Klasse aus Java, die Anfang der 2010er Jahre ersetzt wurde; aber aufgrund von JavaScripts Ziel der Abwärtskompatibilität bleibtDate in der Sprache erhalten.

Die wichtigste Lektion gleich zu Beginn der Einführung ist, dassDatumshandhabung komplex ist. Die meisten Probleme vonDate sind durch das Hinzufügen 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 führt. Eine gut gestaltete API sollte nicht nur mehr können, sondern auf jeder Abstraktionsebene auchweniger tun, weil die Vermeidung von Fehlanwendungen ebenso wichtig ist wie das Ermöglichen von Anwendungsfällen.

Date-Objekte haben eine Doppelfunktion:

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

Zeitzonen sind die Ursache für eine erhebliche Anzahl datumsbezogener Fehler. Bei der Interaktion mit einemDate über das Modell der "Komponentenkombination" 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 alsKalenderdatum (für Daten) oderWanduhrzeit (für Zeiten) bezeichnet, was eine Zeit ist, die man "von einem Kalender oder einer Uhr abliest". Wenn Sie beispielsweise einen täglichen Wecker stellen, möchten Sie ihn auf "8:00 Uhr" stellen, unabhängig davon, ob Sommerzeit ist oder nicht, ob Sie in eine andere Zeitzone gereist sind usw.

Ein weiteres Merkmal, das beiDate fehlt, ist einKalendersystem. 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 möglicherweise nicht, wenn Sie mit einem anderen Kalendersystem arbeiten, wie dem hebräischen Kalender, dem chinesischen Kalender, dem japanischen Kalender usw. MitDate können Sie nur mit dem Modell des gregorianischen Kalenders arbeiten.

Es gibt viele andere unerwünschte Vermächtnisse vonDate, wie zum Beispiel, dass alle Setzmethoden veränderlich sind (was oft unerwünschte Nebeneffekte verursacht), dasDatums-Zeit-String-Format nicht konsistent geparst werden kann usw. Am Ende ist der beste Lösungsansatz, eine neue API von Grund auf zu entwickeln, wasTemporal ist.

API-Übersicht

Temporal ist ein Namensraum, ähnlich wieIntl. Es enthält verschiedene Klassen und Namensräume, 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 Präfix "Plain"):
  - Datum (Jahr, Monat, Tag) + Zeit (Stunde, Minute, Sekunde, Millisekunde, Mikrosekunde, Nanosekunde):Temporal.PlainDateTime (Hinweis:ZonedDateTime entsprichtPlainDateTime 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 imTemporal-Namensraum, aber sie teilen sich viele ähnliche Methoden. Die folgende Tabelle listet alle Methoden jeder Klasse auf (außerKonvertierungsmethoden):

	`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 verfügbar 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 Verständnis davon haben, wie Sie dieTemporal-API navigieren können.

Kalender

Ein Kalender ist eine Möglichkeit, 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 religiösen und kulturellen Kontexten verwendet werden. Standardmäßig verwenden alle kalenderbewusstenTemporal-Objekte das ISO 8601-Kalendersystem, das auf dem gregorianischen Kalender basiert und zusätzliche Regeln zur Wochennummerierung definiert.Intl.supportedValuesOf() listet die meisten Kalender auf, die wahrscheinlich von Browsern unterstützt werden. Hier geben wir einen kurzen Überblick darüber, wie Kalendersysteme 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 Rotation um die Sonne (365,242 Tage für 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 gehören nicht zum Kalender, sondern sind Teil derZeitzonen-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 zusätzlichen Tag, denSchalttag, hinzufügen. Dann kann das Jahr weiter in Teile geteilt werden, die Monate genannt werden. Diese Kalender werdenSonnenkalender 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 können 12 Monate in einem Jahr von 354 Tagen gruppiert werden. Diese Kalender werdenMondkalender genannt. Der islamische Kalender ist ein Mondkalender. Da ein Mondjahr künstlich ist und nicht mit dem Jahreszeitenzyklus korreliert, sind Mondkalender im Allgemeinen seltener.
Einige Kalender definieren ebenfalls in erster Linie Monate basierend auf Mondzyklen, wie Mondkalender. Um jedoch die 11-tägige Abweichung zum Sonnenjahr auszugleichen, wird etwa alle 3 Jahre ein weiterer Monat, derSchaltmonat, hinzugefügt. Diese Kalender werdenlunisolare Kalender genannt. Der hebräische Kalender und der chinesische Kalender sind lunisolare Kalender.

InTemporal wird jedes Datum unter einem Kalendersystem eindeutig durch drei Komponenten identifiziert:year,month undday. Währendyearzumeist eine positive ganze Zahl ist, kann es auch null oder negativ sein und monoton mit der Zeit zunehmen. Das Jahr1 (oder0, falls es existiert) wird als Kalenderepoche bezeichnet und ist für jeden Kalender willkürlich.month ist eine positive ganze Zahl, die bei jedem Schritt um 1 erhöht wird, beginnend bei1 und endend beidate.monthsInYear, und dann zurück auf1 gesetzt wird, wenn das Jahr fortschreitet.day ist ebenfalls eine positive ganze Zahl, beginnt jedoch möglicherweise nicht bei 1 oder wird nicht jedes Mal um 1 erhöht, da politische Änderungen dazu führen können, dass Tage übersprungen oder wiederholt werden. Im Allgemeinen erhöht sichday jedoch monoton und wird zurückgesetzt, wenn der Monat fortschreitet.

Zusätzlich zuyear kann ein Jahr auch eindeutig durch die Kombination vonera underaYear für 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 Jahr0 immer für alle Kalender existiert; im gregorianischen Kalender entspricht es 1 v.Chr. aufgrund derastronomischen Jahrzählung).era ist eine kleingeschriebene Zeichenkette, underaYear 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 immerera underaYear als Paar; verwenden Sie nicht eine Eigenschaft, ohne die andere zu verwenden. Vermeiden Sie zudem Konflikte, indem Sieyear undera/eraYear nicht kombinieren, wenn Sie ein Jahr angeben. Wählen Sie eine Jahresdarstellung und verwenden Sie sie konsequent.
Seien Sie vorsichtig bei den folgenden falschen Annahmen über Jahre:
Gehen Sie nicht davon aus, dassera underaYear immer vorhanden sind; sie könnenundefined sein.
Gehen Sie nicht davon aus, dassera eine benutzerfreundliche Zeichenkette ist; verwenden SietoLocaleString(), um Ihr Datum zu formatieren.
Gehen Sie nicht davon aus, dass zweiyear-Werte aus verschiedenen Kalendern vergleichbar sind; verwenden Sie stattdessen die statische Methodecompare().
Gehen Sie nicht davon aus, dass Jahre 365/366 Tage und 12 Monate haben; verwenden Sie stattdessendaysInYear undmonthsInYear.
Gehen Sie nicht davon aus, dass Schaltjahre (inLeapYear isttrue) einen zusätzlichen Tag haben; sie können einen zusätzlichen Monat haben.

Zusätzlich zumonth kann ein Monat in einem Jahr auch eindeutig durch denmonthCode identifiziert werden.monthCode entspricht normalerweise dem Namen des Monats,month jedoch nicht. Zum Beispiel sind bei lunisolaren Kalendern zwei Monate mit demselbenmonthCode, wobei einer zu einem Schaltjahr gehört und der andere nicht, unterschiedlichemonth-Werte, wenn sie nach dem Schaltmonat folgen, aufgrund der Einfügung eines zusätzlichen Monats.

[!HINWEIS]Um Konflikte zu vermeiden, kombinieren Siemonth undmonthCode nicht, wenn Sie einen Monat angeben. Wählen Sie eine Monatsdarstellung und verwenden Sie sie konsequent.month ist nützlicher, wenn Sie die Reihenfolge der Monate im Jahr benötigen (z.B. beim Durchlaufen der Monate), währendmonthCode 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, dassmonthCode undmonth immer korrespondieren.
Gehen Sie nicht von der Anzahl der Tage in einem Monat aus; verwenden Sie stattdessendaysInMonth.
Gehen Sie nicht davon aus, dassmonthCode eine benutzerfreundliche Zeichenkette ist; verwenden SietoLocaleString(), um Ihr Datum zu formatieren.
Speichern Sie im Allgemeinen den Namen der Monate nicht in einem Array oder Objekt. Auch wennmonthCode normalerweise dem Monatsnamen innerhalb eines Kalenders entspricht, empfehlen wir, stets den Monatsnamen zu berechnen, zum Beispiel mitdate.toLocaleString("de-DE", { calendar: date.calendarId, month: "long" }).

Zusätzlich zuday (was ein monatsbasiertes Indiz ist) kann ein Tag in einem Jahr auch eindeutig durchdayOfYear identifiziert werden.dayOfYear ist eine positive Ganzzahl, die sich bei jedem Schritt um 1 erhöht, beginnend bei1 und endend beidate.daysInYear.

Das Konzept einer "Woche" ist mit keinem astronomischen Ereignis verbunden, sondern ein kulturelles Konstrukt. Während die häufigste Länge7 Tage beträgt, können 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 SiedaysInWeek des Datums.Temporal identifiziert Wochen durch die Kombination vonweekOfYear undyearOfWeek.weekOfYear ist eine positive Ganzzahl, die sich bei jedem Schritt um 1 erhöht, beginnend bei1 und dann zu1 zurücksetzt, wenn das Jahr fortschreitet.yearOfWeek ist im Allgemeinen dasselbe wieyear, kann aber zu Beginn oder Ende jedes Jahres anders sein, weil eine Woche zwei Jahre überqueren kann, undyearOfWeek eines der beiden Jahre basierend auf den Regeln des Kalenders auswählt.

[!HINWEIS]Verwenden Sie immerweekOfYear undyearOfWeek als Paar; verwenden Sie nichtweekOfYear undyear.
Seien Sie vorsichtig bei den folgenden falschen Annahmen über Wochen:
Gehen Sie nicht davon aus, dassweekOfYear undyearOfWeek immer vorhanden sind; sie könnenundefined sein.
Gehen Sie nicht davon aus, dass Wochen immer 7 Tage haben; verwenden SiedaysInWeek.
Beachten Sie, dass die aktuelleTemporal-API keine Jahr-Woche-Daten unterstützt, sodass Sie keine Daten mit diesen Eigenschaften konstruieren oder Daten in Jahr-Woche-Darstellungen serialisieren können. Sie sind nur informative Eigenschaften.

RFC 9557 Format

AlleTemporal-Klassen können unter Verwendung des Formats gemäßRFC 9557 serialisiert und deserialisiert werden, das aufISO 8601 / RFC 3339 basiert. Das Format in seiner vollständigen Form ist wie folgt (Leerzeichen dienen nur der 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. 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 zumDatums-Zeit-String-Format, das vonDate verwendet wird, welches ebenfalls auf ISO 8601 basiert. Die Hauptneuerung ist die Möglichkeit, Mikro- und Nanosekundenkomponenten anzugeben sowie die Zeitzone und das Kalendersystem zu spezifizieren.

Darstellbare Daten

AlleTemporal-Objekte, die ein bestimmtes Kalendariumdatum darstellen, legen eine ähnliche Grenze für den Bereich der darstellbaren Daten fest, die ±10⁸ Tage (einschließlich) 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 wiegültige Daten. Genauer gesagt:

Temporal.Instant undTemporal.ZonedDateTime wenden dieses Limit direkt auf ihrenepochNanoseconds-Wert an.
Temporal.PlainDateTime interpretiert das Datum und die Uhrzeit in der UTC-Zeitzone und erfordert, dass sie ±(10⁸ + 1) Tage (exklusiv) von der Unix-Epoche entfernt sind, sodass ihr gültiger Bereich-271821-04-19T00:00:00 bis+275760-09-14T00:00:00 ist, exklusiv. Dies ermöglicht es jedemZonedDateTime, unabhängig von seinem Offset in einPlainDateTime konvertiert zu werden.
Temporal.PlainDate führt die gleiche Überprüfung wiePlainDateTime zur Mittagszeit (12:00:00) dieses Datums durch, sodass ihr gültiger Bereich-271821-04-19 bis+275760-09-13 beträgt. Dies ermöglicht es jedemPlainDateTime, unabhängig von seiner Uhrzeit in einPlainDate umgewandelt zu werden und umgekehrt.
Temporal.PlainYearMonth hat den gültigen Bereich von-271821-04 bis+275760-09. Dies ermöglicht es jedemPlainDate, unabhängig von seinem Datum (außer wenn der erste Tag eines nicht-ISO-Monats in den ISO-Monat-271821-03 fällt) in einPlainYearMonth umgewandelt zu werden.

DieTemporal-Objekte werden sich weigern, eine Instanz zu konstruieren, die ein Datum/Zeitp hätte, das über diesem Limit liegt. Dies schließt ein:

Die Verwendung des Konstruktors oder der statischen Methodefrom().
Die Verwendung der Methodewith() zur Aktualisierung von Kalendereinträgen.
Die Verwendung vonadd(),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 Nanosekundenpräzision 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 unabhängig von der Zeitzone geschieht, in der es stattfindet. Es wird grundlegend als ISO 8601-Kalenderdatum mit Jahr-, Monat- und Tagefeldern und einem zugehörigen Kalendersystem dargestellt.
Temporal.PlainDateTime: Stellt ein Datum (Kalenderdatum) und eine Uhrzeit (Wanduhrzeit) ohne Zeitzone dar. Es wird grundlegend als Kombination aus einemDatum (mit einem zugehörigen Kalendersystem) und einerZeit 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 zugehörigen Kalendersystem dargestellt. Das Jahr wird verwendet, um den Monat-Tag in nicht-ISO-Kalendersystemen zu klären.
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 zugehörigen Kalendersystem dargestellt. Der Tag wird verwendet, um das Jahr-Monat in nicht-ISO-Kalendersystemen zu klären.
Temporal.ZonedDateTime: Stellt ein Datum und eine Uhrzeit mit einer Zeitzone dar. Es wird grundlegend als Kombination einesZeitpunkts, einer Zeitzone und eines Kalendersystems dargestellt.
Temporal[Symbol.toStringTag]: Der Anfangswert der[Symbol.toStringTag]-Eigenschaft ist der String"Temporal". Diese Eigenschaft wird inObject.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

Movatterモバイル変換

Temporal

Help improve MDN