Temporal-Kochbuch
Hinweis: Dieses Dokument basiert auf dem Kochbuch in der ursprünglichen Dokumentation des TC39-Vorschlags.
Dieser Leitfaden enthält Codebeispiele für häufige Anwendungsfälle von Temporal. Lesen Sie bei Bedarf zuerst den Leitfaden Datums- und Zeitangaben darstellen, um die grundlegenden Konzepte und die API von Temporal kennenzulernen.
Aktuelles Datum und aktuelle Uhrzeit
const date = Temporal.Now.plainDateISO(); // Gets the current date
date.toString(); // returns the date in ISO 8601 date format
// If you additionally want the time:
Temporal.Now.plainDateTimeISO().toString(); // date and time in ISO 8601 format
Wenn Sie nur das Datum und nicht die Uhrzeit benötigen, verwenden Sie Temporal.PlainDate. Wenn Sie beides benötigen, verwenden Sie Temporal.PlainDateTime.
Unix-Zeitstempel
const timeStamp = Temporal.Now.instant();
// Timestamp in milliseconds
timeStamp.epochMilliseconds;
// Timestamp in seconds
Math.floor(timeStamp.epochMilliseconds / 1000);
Zwischen Temporal-Typen und dem bisherigen Date konvertieren
>Bisheriges Date in Temporal.Instant und/oder Temporal.ZonedDateTime konvertieren
So konvertieren Sie ein bisheriges Date in eine Instanz von Temporal.Instant oder Temporal.ZonedDateTime, die denselben exakten Zeitpunkt repräsentiert.
Wenn Sie ein ZonedDateTime benötigen, verwenden Sie die Methode toZonedDateTimeISO() des resultierenden Instant. Sie müssen eine Zeitzone angeben, da das bisherige Date nur einen exakten Zeitpunkt und keine Zeitzone speichert.
Wenn Sie Methoden auf einer bisherigen Date-Instanz aufrufen, müssen Sie entscheiden, ob Sie den exakten Zeitpunkt als UTC-Wert interpretieren möchten (mit Methoden, deren Namen „UTC“ enthalten) oder in der aktuellen Systemzeitzone (mit den anderen Methoden). Das kann verwirrend sein; Temporal bietet dafür eine ausdrücklichere Vorgehensweise.
Um die lokale Zeitzone des Systems zu verwenden – entsprechend den Methoden getFullYear(), getMonth() usw. des bisherigen Date –, übergeben Sie Temporal.Now.timeZoneId() als Zeitzone. In einem Browser ist dies die Zeitzone der Benutzerin oder des Benutzers. Auf einem Server kann der Wert jedoch von Ihrer Erwartung abweichen; vermeiden Sie diese Vorgehensweise daher im Serverkontext.
const legacyDate = new Date("1970-01-01T00:00:01Z");
const instant = legacyDate.toTemporalInstant();
console.log(instant.epochMilliseconds === legacyDate.getTime()); // true
console.log(instant.toString()); // '1970-01-01T00:00:01Z'
const zoned = instant.toZonedDateTimeISO(Temporal.Now.timeZoneId());
console.log(zoned.epochMilliseconds === legacyDate.getTime()); // true
Hier ist ein Beispiel mit einer bestimmten Zeitzone. Insbesondere im Serverkontext würden Sie diese Zeitzone aus anderen Daten entnehmen, die Sie verarbeiten. Wenn auf die bisherige Date-Instanz mit den Methoden getUTCFullYear(), getUTCMonth() usw. zugegriffen wurde, sollten Sie erwägen, einfach Instant zu verwenden. Falls Sie ZonedDateTime verwenden müssen, muss die angegebene Zeitzone möglicherweise "UTC" sein.
const zoned2 = instant.toZonedDateTimeISO("Asia/Shanghai");
console.log(zoned2.epochMilliseconds === legacyDate.getTime()); // true
console.log(zoned2.timeZoneId); // 'Asia/Shanghai'
Werte, die nur ein Datum enthalten: bisheriges Date in Temporal.PlainDate konvertieren
Ein häufiger Fehler ergibt sich aus einer einfachen Frage: Welches Datum (Jahr, Monat und Tag) repräsentiert dieses Date? Das Problem: Die Antwort hängt von der Zeitzone ab. Dasselbe Date kann in San Francisco den 31. Dezember, in London oder Tokio aber den 1. Januar bezeichnen.
Daher ist es entscheidend, das Date im Kontext der richtigen Zeitzone zu interpretieren, bevor Sie Jahr, Monat oder Tag daraus auslesen oder Berechnungen mit Datumseinheiten durchführen, etwa für die Frage „Ist das gestern passiert?“. Aus diesem Grund verfügt Temporal.Instant (das Temporal-Gegenstück zu Date) nicht über die Eigenschaften year, month und day. Um in Temporal auf Datums- oder Zeiteinheiten zuzugreifen, muss eine Zeitzone angegeben werden, wie im obigen Codebeispiel beschrieben.
Ein weiterer fehleranfälliger Fall ist die (missbräuchliche) Verwendung von Date zum Speichern eines Werts, der nur ein Datum enthält, etwa des Geburtsdatums einer Person. Bei Date werden solche Werte üblicherweise mit Mitternacht als Uhrzeit gespeichert. Um das Datum später korrekt auszulesen, müssen Sie jedoch wissen, welche Zeitzone bei der Erstellung des Date für Mitternacht verwendet wurde. Beispielsweise verwendet new Date(2000, 0, 1) die Zeitzone des aufrufenden Systems, während new Date("2000-01-01") UTC verwendet.
Um ein Date, das nur ein Datum enthält, korrekt in ein Temporal.PlainDate zu konvertieren und dabei Fehler um einen Tag zu vermeiden, müssen Sie ermitteln, in welcher Zeitzone Mitternacht für die Erstellung des Date verwendet wurde. Verwenden Sie anschließend dieselbe Zeitzone bei der Konvertierung von Temporal.Instant in Temporal.PlainDate.
// Convert a year/month/day `Date` to a `Temporal.PlainDate`. Uses the caller's time zone.
let date = new Date(2000, 0, 1);
// Sat Jan 01 2000 00:00:00 GMT-0800 (Pacific Standard Time)
let plainDate = date
.toTemporalInstant() // 2000-01-01T08:00:00Z
.toZonedDateTimeISO(Temporal.Now.timeZoneId()) // 2000-01-01T00:00:00-08:00[America/Los_Angeles]
.toPlainDate(); // 2000-01-01
console.log(plainDate.toString()); // '2000-01-01'
// Convert a year/month/day `Date` to a `Temporal.PlainDate`. Uses UTC.
date = new Date(Date.UTC(2000, 0, 1));
// Fri Dec 31 1999 16:00:00 GMT-0800 (Pacific Standard Time)
date = new Date("2000-01-01T00:00Z");
// Fri Dec 31 1999 16:00:00 GMT-0800 (Pacific Standard Time)
plainDate = date
.toTemporalInstant() // 2000-01-01T00:00:00Z
.toZonedDateTimeISO("UTC") // 2000-01-01T00:00:00+00:00[UTC]
.toPlainDate(); // 2000-01-01
console.log(plainDate.toString()); // '2000-01-01'
Temporal-Typen in das bisherige Date konvertieren
Das bisherige Date repräsentiert einen exakten Zeitpunkt. Daher lässt sich eine Instanz von Temporal.Instant oder Temporal.ZonedDateTime unkompliziert in eine entsprechende bisherige Date-Instanz konvertieren. Verwenden Sie für die Konvertierung von Instant in das bisherige Date die Eigenschaft epochMilliseconds.
const instant = Temporal.Instant.from("2020-01-01T00:00:01.000999Z");
const result = new Date(instant.epochMilliseconds);
console.log(result.getTime()); // 1577836801000 // ms since Unix epoch
console.log(result.toISOString()); // '2020-01-01T00:00:01.000Z'
Für ZonedDateTime gilt dasselbe. Beachten Sie, dass das bisherige Date die Zeitzone des ZonedDateTime nicht beibehält.
const zoned = Temporal.ZonedDateTime.from(
"2020-01-01T00:00:01.001[Asia/Tokyo]",
);
const result2 = new Date(zoned.epochMilliseconds);
console.log(result2.getTime()); // 1577804401001 // note, different time
console.log(result2.toISOString()); // '2019-12-31T15:00:01.001Z'
Für die meisten Anwendungsfälle ist new Date(x.epochMilliseconds) ausreichend. Wenn Sie ein anderes Rundungsverhalten als Abschneiden wünschen, müssen Sie gegebenenfalls einen zusätzlichen Schritt mit round() einfügen. Hier werden beispielsweise 999 Mikrosekunden auf 1 Millisekunde gerundet.
const result3 = new Date(
instant.round({ smallestUnit: "millisecond" }).epochMilliseconds,
);
console.log(result3.getTime()); // 1577836801001
console.log(result3.toISOString()); // '2020-01-01T00:00:01.001Z'
Erstellung
>Kalendereingabeelement
Sie können Eigenschaften eines Kalendereingabefelds mit Temporal-Objekten festlegen. Das folgende Beispiel verwendet ein HTML-Element <input type="date">, in dem alle Tage nach „heute“ deaktiviert und nicht auswählbar sind.
(Wie Sie ein Temporal-Objekt aus dem Kalendereingabefeld erhalten, zeigt das Beispiel Zukünftiges Datum.)
<input type="date" id="calendar-input" />
const datePicker = document.getElementById("calendar-input");
const today = Temporal.Now.plainDateISO();
datePicker.max = today;
datePicker.value = today;
Zwischen Typen konvertieren
>Mittag an einem bestimmten Datum
Ein Beispiel dafür, wie ein Kalenderdatum (Temporal.PlainDate) und eine lokale Uhrzeit (Temporal.PlainTime) zu einem Temporal.PlainDateTime kombiniert werden.
const date = Temporal.PlainDate.from("2020-05-14");
const noonOnDate = date.toPlainDateTime(Temporal.PlainTime.from({ hour: 12 }));
console.log(noonOnDate.toString()); // '2020-05-14T12:00:00'
Geburtstag im Jahr 2030
Ein Beispiel dafür, wie ein Tag im Kalender (Temporal.PlainMonthDay) und ein Jahr zu einem Temporal.PlainDate kombiniert werden.
const birthday = Temporal.PlainMonthDay.from("12-15");
const birthdayIn2030 = birthday.toPlainDate({ year: 2030 });
birthdayIn2030.dayOfWeek; // 7
console.log(birthdayIn2030.toString()); // '2030-12-15'
Serialisierung
>Zeitpunkt mit Zeitzone aus Zeitpunkt und Zeitzone
Um einen exakten Zeitpunkt als Temporal.Instant in einen String zu serialisieren, verwenden Sie toString(). Ohne Argumente erhalten Sie einen String in UTC-Zeit.
const instant = Temporal.Instant.from("2020-01-03T10:41:51Z");
const result = instant.toString();
console.log(result); // '2020-01-03T10:41:51Z'
console.log(instant.equals(Temporal.Instant.from(result))); // true
Wenn Ihr String einen UTC-Offset enthalten soll, verwenden Sie die Option timeZone von Temporal.Instant.prototype.toString(). Sie gibt eine String-Darstellung der lokalen Uhrzeit zurück, die in dieser Zeitzone dem exakten Zeitpunkt entspricht.
const result2 = instant.toString({ timeZone: "America/Yellowknife" });
console.log(result2); // '2020-01-03T03:41:51-07:00'
console.log(instant.equals(Temporal.Instant.from(result2))); // true
Dabei geht die Information verloren, zu welcher Zeitzone der String gehört, da nur der UTC-Offset der Zeitzone zu diesem bestimmten Zeitpunkt erhalten bleibt. Wenn Ihr String den Namen der Zeitzone enthalten soll, verwenden Sie stattdessen Temporal.ZonedDateTime, das diese Information beibehält.
const zoned = instant.toZonedDateTimeISO("Asia/Seoul");
const result3 = zoned.toString();
console.log(result3); // '2020-01-03T19:41:51+09:00[Asia/Seoul]'
console.log(instant.equals(Temporal.Instant.from(result3))); // true
console.log(zoned.equals(Temporal.ZonedDateTime.from(result3))); // true
Sortieren
Jeder Temporal-Typ außer Temporal.PlainMonthDay verfügt über eine statische Methode compare(), die Sie als Vergleichsfunktion an Array.prototype.sort() übergeben können, um ein Array von Temporal-Werten zu sortieren.
PlainDateTime-Werte sortieren
Sortieren Sie eine Liste von Temporal.PlainDateTime-Werten, um beispielsweise einen Konferenzplan in die richtige Reihenfolge zu bringen. Andere Temporal-Typen lassen sich genauso sortieren. Die folgende Funktion gibt eine sortierte Kopie des Arrays zurück. Das optionale Argument reverse ermöglicht eine absteigende Sortierung.
function getSortedLocalDateTimes(dateTimes, reverse = false) {
let newDateTimes = Array.from(dateTimes).sort(Temporal.PlainDateTime.compare);
return reverse ? newDateTimes.reverse() : newDateTimes;
}
// Sorting some conferences without timezones for example vue.js Amsterdam 2020
const a = Temporal.PlainDateTime.from({
year: 2020,
day: 20,
month: 2,
hour: 8,
minute: 45,
}); // Introduction
const b = Temporal.PlainDateTime.from({
year: 2020,
day: 21,
month: 2,
hour: 13,
minute: 10,
}); // Lunch Break
const c = Temporal.PlainDateTime.from({
year: 2020,
day: 20,
month: 2,
hour: 15,
minute: 30,
}); // Coffee Break
const results = getSortedLocalDateTimes([a, b, c]);
console.log(results.map((x) => x.toString()));
// ['2020-02-20T08:45:00', '2020-02-20T15:30:00', '2020-02-21T13:10:00']
ISO-Datums- und Zeitstrings sortieren
Sortieren Sie eine Liste von Datums- und Zeitstrings im Format ISO 8601 oder RFC 9557, um beispielsweise Protokolleinträge in die richtige Reihenfolge zu bringen. Die folgende Funktion nimmt ein Array von Strings entgegen, die als Temporal.Instant-Werte geparst werden können, und gibt eine nach exaktem Zeitpunkt sortierte Kopie zurück. Das optionale Argument reverse ermöglicht eine absteigende Sortierung.
function sortInstantStrings(strings, reverse = false) {
const sortedInstants = strings
.map((v) => [v, Temporal.Instant.from(v)])
.sort(([, i1], [, i2]) => Temporal.Instant.compare(i1, i2))
.map(([str]) => str);
return reverse ? sortedInstants.reverse() : sortedInstants;
}
// simple string comparison order would not be correct here:
const a = "2020-01-23T17:04:36.491865121-08:00";
const b = "2020-02-10T17:04:36.491865121-08:00";
const c = "2020-04-01T05:01:00-04:00[America/New_York]";
const d = "2020-04-01T10:00:00+01:00[Europe/London]";
const e = "2020-04-01T11:02:00+02:00[Europe/Berlin]";
const results = sortInstantStrings([a, b, c, d, e]);
// results will have correct order
console.log(results);
// [
// '2020-01-23T17:04:36.491865121-08:00',
// '2020-02-10T17:04:36.491865121-08:00',
// '2020-04-01T10:00:00+01:00[Europe/London]',
// '2020-04-01T05:01:00-04:00[America/New_York]',
// '2020-04-01T11:02:00+02:00[Europe/Berlin]'
// ]
Runden
>Eine Uhrzeit auf volle Stunden abrunden
Verwenden Sie die Methode round() des jeweiligen Temporal-Typs, wenn Sie Zeitfelder runden möchten. Das folgende Beispiel rundet eine Uhrzeit auf die letzte volle Stunde ab:
const time = Temporal.PlainTime.from("12:38:28.138818731");
const wholeHour = time.round({ smallestUnit: "hour", roundingMode: "floor" });
console.log(wholeHour.toString()); // '12:00:00'
Ein Datum auf den nächstgelegenen Monatsanfang runden
Runden ist nur für Zeitfelder definiert. Das Runden eines Datumsfelds kann mehrdeutig sein. Daher haben Typen, die nur ein Datum enthalten, wie Temporal.PlainDate, keine Methode round(). Wenn Sie beispielsweise ein Datum auf den nächstgelegenen Monat runden müssen, müssen Sie ausdrücklich festlegen, welche Art der Rundung Sie wünschen. Das folgende Beispiel rundet auf den nächstgelegenen Monatsanfang und bei gleichem Abstand auf:
const date = Temporal.PlainDate.from("2018-09-16");
const firstOfCurrentMonth = date.with({ day: 1 });
const firstOfNextMonth = firstOfCurrentMonth.add({ months: 1 });
const sinceCurrent = date.since(firstOfCurrentMonth);
const untilNext = date.until(firstOfNextMonth);
const isCloserToNextMonth =
Temporal.Duration.compare(sinceCurrent, untilNext) >= 0;
const nearestMonth = isCloserToNextMonth
? firstOfNextMonth
: firstOfCurrentMonth;
console.log(nearestMonth.toString()); // '2018-10-01'
Unter Ein Startdatum verschieben finden Sie außerdem eine einfachere Möglichkeit, immer auf den nächsten Monatsanfang aufzurunden.
Zeitzonenkonvertierung
>Lokale Uhrzeit beibehalten
Ordnen Sie ein Datum und eine Uhrzeit ohne Zeitzone einer Temporal.Instant-Instanz zu, bei der das lokale Datum und die lokale Uhrzeit in einer angegebenen Zeitzone übereinstimmen. Mit dateTime.toZonedDateTime(timeZone).toInstant() ist dies einfach möglich. Das folgende Beispiel zeigt jedoch, wie Sie andere Verfahren zur Auflösung mehrdeutiger Zeitangaben implementieren können als die in Temporal integrierten Optionen "compatible", "earlier", "later" und "reject". Die folgende Funktion nimmt ein Temporal.PlainDateTime, eine Zeitzonenkennung und einen Modus zur Auflösung mehrdeutiger Zeitangaben entgegen (standardmäßig "earlier"). Sie gibt ein Temporal.Instant zurück und unterstützt zwei zusätzliche Modi:
"clipEarlier": Verwendet den früheren Zeitpunkt, wenn die Uhr zurückgestellt wird, oder den Zeitpunkt unmittelbar vor der Umstellung, wenn die Uhr vorgestellt wird."clipLater": Verwendet den späteren Zeitpunkt, wenn die Uhr zurückgestellt wird, oder den Zeitpunkt der Umstellung, wenn die Uhr vorgestellt wird.
function getInstantWithLocalTimeInZone(
dateTime,
timeZone,
disambiguation = "earlier",
) {
// Handle the built-in modes first
if (["compatible", "earlier", "later", "reject"].includes(disambiguation)) {
return dateTime.toZonedDateTime(timeZone, { disambiguation }).toInstant();
}
const possibilities = ["earlier", "later"].map((disambiguation) =>
dateTime.toZonedDateTime(timeZone, { disambiguation }),
);
const instants = possibilities
.map((zdt) => zdt.toInstant())
.reduce((a, b) => (a.equals(b) ? [a] : [a, b]));
// Return only possibility if no disambiguation needed
if (instants.length === 1) return instants[0];
switch (disambiguation) {
case "clipEarlier":
if (possibilities[0].toPlainDateTime().equals(dateTime)) {
return instants[0];
}
return possibilities[0]
.getTimeZoneTransition("next")
.subtract({ nanoseconds: 1 })
.toInstant();
case "clipLater":
if (possibilities[1].toPlainDateTime().equals(dateTime)) {
return instants[1];
}
return possibilities[0].getTimeZoneTransition("next").toInstant();
}
throw new RangeError(`invalid disambiguation ${disambiguation}`);
}
const nonexistentGermanWallTime =
Temporal.PlainDateTime.from("2019-03-31T02:45");
const germanResults = {
earlier: "2019-03-31T01:45:00+01:00",
later: "2019-03-31T03:45:00+02:00",
compatible: "2019-03-31T03:45:00+02:00",
clipEarlier: "2019-03-31T01:59:59.999999999+01:00",
clipLater: "2019-03-31T03:00:00+02:00",
};
for (const [disambiguation, result] of Object.entries(germanResults)) {
console.log(
getInstantWithLocalTimeInZone(
nonexistentGermanWallTime,
"Europe/Berlin",
disambiguation,
).toString({
timeZone: "Europe/Berlin",
}) === result,
); // true
}
const doubleEasternBrazilianWallTime =
Temporal.PlainDateTime.from("2019-02-16T23:45");
const brazilianResults = {
earlier: "2019-02-16T23:45:00-02:00",
later: "2019-02-16T23:45:00-03:00",
compatible: "2019-02-16T23:45:00-02:00",
clipEarlier: "2019-02-16T23:45:00-02:00",
clipLater: "2019-02-16T23:45:00-03:00",
};
for (const [disambiguation, result] of Object.entries(brazilianResults)) {
console.log(
getInstantWithLocalTimeInZone(
doubleEasternBrazilianWallTime,
"America/Sao_Paulo",
disambiguation,
).toString({
timeZone: "America/Sao_Paulo",
}) === result,
); // true
}
Exakten Zeitpunkt beibehalten
Ordnen Sie ein Datum und eine Uhrzeit mit Zeitzone einem Datum und einer Uhrzeit in einer anderen Zielzeitzone zu, die denselben exakten Zeitpunkt repräsentieren. Dies kann beispielsweise bei der Konvertierung von Datums- und Zeiteingaben zwischen Zeitzonen verwendet werden.
const source = Temporal.ZonedDateTime.from("2020-01-09T00:00[America/Chicago]");
const result = source.withTimeZone("America/Los_Angeles");
// On this date, when it's midnight in Chicago, it's 10 PM the previous night in LA
console.log(result.toString());
// '2020-01-08T22:00:00-08:00[America/Los_Angeles]'
Hier ist ein weiteres Beispiel, das dem vorherigen ähnelt und die Zeitzone für zukünftige Ereignisse verwendet. Die Zeiten und Orte einer Reihe zukünftiger Besprechungen werden als Paar von Strings gespeichert: einer für das Kalenderdatum und die lokale Uhrzeit, der andere für die Zeitzone. Sie können nicht als exakter Zeitpunkt gespeichert werden, da sich die Zeitzonenregeln für die Sommerzeit bis zum Ereignis ändern könnten – Brasilien hat beispielsweise 2019 die Sommerzeit abgeschafft. Die Besprechung würde an diesem Datum dennoch zur selben lokalen Uhrzeit stattfinden. Wenn sich die Zeitzonenregeln ändern, ändert sich also der exakte Zeitpunkt des Ereignisses.
Dieses Beispiel berechnet die Anfangszeiten aller Ecma-TC39-Besprechungen im Jahr 2019 in der lokalen Zeit von Tokio.
// Dates of the 2019 TC39 meetings:
const tc39meetings = [
{
dateTime: "2019-01-28T10:00",
timeZone: "America/Phoenix",
},
{
dateTime: "2019-03-26T10:00",
timeZone: "America/New_York",
},
{
dateTime: "2019-06-04T10:00",
timeZone: "Europe/Berlin",
},
{
dateTime: "2019-07-23T10:00",
timeZone: "America/Los_Angeles",
},
{
dateTime: "2019-10-01T10:00",
timeZone: "America/New_York",
},
{
dateTime: "2019-12-03T10:00",
timeZone: "America/Los_Angeles",
},
];
// To follow the meetings remotely from Tokyo, calculate the times you would
// need to join:
const localTimeZone = "Asia/Tokyo";
const localTimes = tc39meetings.map(({ dateTime, timeZone }) =>
Temporal.PlainDateTime.from(dateTime)
.toZonedDateTime(timeZone, { disambiguation: "reject" })
.withTimeZone(localTimeZone)
.toPlainDateTime(),
);
console.log(localTimes.map((dt) => dt.toString()));
// [
// "2019-01-29T02:00:00",
// "2019-03-26T23:00:00",
// "2019-06-04T17:00:00",
// "2019-07-24T02:00:00",
// "2019-10-01T23:00:00",
// "2019-12-04T03:00:00",
// ]
Tägliches Ereignis zur lokalen Uhrzeit
Ähnlich wie im vorherigen Beispiel werden die exakten Zeitpunkte eines täglichen Ereignisses berechnet, das zu einer bestimmten lokalen Uhrzeit in einer bestimmten Zeitzone stattfindet. Der folgende Generator nimmt ein Temporal.PlainDate als Anfangsdatum, ein Temporal.PlainTime und eine Zeitzonenkennung entgegen und liefert jedes Ereignis als Temporal.Instant.
function* calculateDailyOccurrence(startDate, plainTime, timeZone) {
for (let date = startDate; ; date = date.add({ days: 1 })) {
yield date.toZonedDateTime({ plainTime, timeZone }).toInstant();
}
}
// Daily meeting at 8 AM California time
const startDate = Temporal.PlainDate.from("2017-03-10");
const time = Temporal.PlainTime.from("08:00");
const timeZone = "America/Los_Angeles";
const iter = calculateDailyOccurrence(startDate, time, timeZone);
console.log(iter.next().value.toString()); // '2017-03-10T16:00:00Z'
console.log(iter.next().value.toString()); // '2017-03-11T16:00:00Z'
// DST change:
console.log(iter.next().value.toString()); // '2017-03-12T15:00:00Z'
console.log(iter.next().value.toString()); // '2017-03-13T15:00:00Z'
UTC-Offset für ein Ereignis in einer Zeitzone als String
Verwenden Sie Temporal.Instant.prototype.toZonedDateTimeISO() und offset, um aus einer Temporal.Instant-Instanz und einer Zeitzone den UTC-Offset zu diesem exakten Zeitpunkt in dieser Zeitzone als String zu ermitteln.
const instant = Temporal.Instant.from("2020-01-09T00:00Z");
const source = instant.toZonedDateTimeISO("America/New_York");
source.offset; // '-05:00'
UTC-Offset für ein Ereignis in einer Zeitzone als Anzahl von Sekunden
Verwenden Sie entsprechend Temporal.Instant.prototype.toZonedDateTimeISO() und offsetNanoseconds, um den Offset als Anzahl von Sekunden zu ermitteln. (Denken Sie daran, durch 109 zu teilen, um Nanosekunden in Sekunden umzurechnen.)
const instant = Temporal.Instant.from("2020-01-09T00:00Z");
instant.toZonedDateTimeISO("America/New_York").offsetNanoseconds / 1e9;
// -18000
Offset zwischen zwei Zeitzonen zu einem exakten Zeitpunkt
Mit Temporal.Instant.prototype.toZonedDateTimeISO() und Temporal.ZonedDateTime.offsetNanoseconds können wir außerdem aus einer Temporal.Instant-Instanz und zwei Zeitzonen die Differenz der UTC-Offsets dieser Zeitzonen zu diesem exakten Zeitpunkt als vorzeichenbehaftete Anzahl von Sekunden ermitteln.
function getUtcOffsetDifferenceSecondsAtInstant(
instant,
sourceTimeZone,
targetTimeZone,
) {
const sourceOffsetNs =
instant.toZonedDateTimeISO(sourceTimeZone).offsetNanoseconds;
const targetOffsetNs =
instant.toZonedDateTimeISO(targetTimeZone).offsetNanoseconds;
return (targetOffsetNs - sourceOffsetNs) / 1e9;
}
const instant = Temporal.Instant.from("2020-01-09T00:00Z");
// At this exact time, Chicago is 3600 seconds earlier than New York
console.log(
getUtcOffsetDifferenceSecondsAtInstant(
instant,
"America/New_York",
"America/Chicago",
),
); // -3600
Datums- und Zeitangaben an einem festen Standort verarbeiten
Das folgende Beispiel verwendet Temporal in einem Diagramm, das fiktive Aktivitätsdaten für einen Lagertank an einem festen Standort (Stockholm, Schweden) zeigt. Das Diagramm beginnt immer um Mitternacht am Standort des Tanks, seine Beschriftungen werden jedoch in der Zeitzone der betrachtenden Person angezeigt.
// Generate fictitious "data"
const start = Temporal.Now.instant().subtract({ hours: 24 });
const blank = Array(24 * 12);
const tankDataX = Array.from(blank, (_, ix) => start.add({ minutes: ix * 5 }));
const tankDataY = Array.from(blank);
tankDataY[0] = 25;
for (let ix = 1; ix < tankDataY.length; ix++) {
tankDataY[ix] = Math.max(0, tankDataY[ix - 1] + 3 * (Math.random() - 0.5));
}
// tankDataX and tankDataY are X and Y-axis data for the last 24 hours,
// obtained from elsewhere, e.g. const [tankDataX, tankDataY] = fetchData();
// tankDataX is an array of Temporal.Instant, and tankDataY is an array of numbers.
// Show data starting from the most recent midnight in the tank's location (Stockholm)
const tankTimeZone = "Europe/Stockholm";
const labelFormatter = new Intl.DateTimeFormat(undefined, {
weekday: "short",
hour: "numeric",
minute: "numeric",
timeZone: Temporal.Now.timeZoneId(),
});
const browserCalendar = labelFormatter.resolvedOptions().calendar;
const tankMidnight = Temporal.Now.zonedDateTimeISO()
.withCalendar(browserCalendar)
.withTimeZone(tankTimeZone)
.startOfDay()
.toInstant();
const atOrAfterMidnight = (x) => Temporal.Instant.compare(x, tankMidnight) >= 0;
const dataStartIndex = tankDataX.findIndex(atOrAfterMidnight);
const graphLabels = tankDataX
.slice(dataStartIndex)
.map((x) => labelFormatter.format(x));
const graphPoints = tankDataY.slice(dataStartIndex);
const ctx = document.getElementById("storage-tank").getContext("2d");
// The graph is made with Chart.js (https://www.chartjs.org/)
new Chart(ctx, {
type: "line",
data: {
labels: graphLabels,
datasets: [
{
label: "Fill level",
data: graphPoints,
},
],
},
options: {
title: {
display: true,
text: "Stockholm storage tank",
},
scales: {
yAxes: [
{
ticks: {
beginAtZero: true,
},
},
],
},
},
});
Eine Besprechung über Zeitzonen hinweg planen
Im Web gibt es mehrere Werkzeuge, mit denen sich Besprechungszeiten finden lassen, die für die Zeitzonen aller Teilnehmenden geeignet sind. Dazu gehören World Time Buddy und World Clock Meeting Planner; entsprechende Funktionen sind auch in verschiedenen Kalenderprogrammen integriert.
// Display local time zone and three others
const browserCalendar = new Intl.DateTimeFormat().resolvedOptions().calendar;
const now = Temporal.Now.zonedDateTimeISO().withCalendar(browserCalendar);
const timeZones = [
{ name: "Here", tz: now.timeZoneId },
{ name: "New York", tz: "America/New_York" },
{ name: "London", tz: "Europe/London" },
{ name: "Tokyo", tz: "Asia/Tokyo" },
];
// Start the table at midnight local time
const startTime = now.startOfDay();
// Build the table
const table = document.getElementById("meeting-planner");
timeZones.forEach(({ name, tz }) => {
const row = document.createElement("tr");
const title = document.createElement("td");
const startTimeHere = startTime.withTimeZone(tz);
title.textContent = `${name} (UTC${startTimeHere.offset})`;
row.appendChild(title);
for (let hours = 0; hours < 24; hours++) {
const cell = document.createElement("td");
const columnTime = startTimeHere.add({ hours });
cell.className = `time-${columnTime.hour}`;
// Highlight the current hour in each row
if (hours === now.hour) cell.className += " time-current";
// Show the date in midnight cells
let formatOptions;
if (columnTime.hour === columnTime.startOfDay().hour) {
formatOptions = { month: "short", day: "numeric" };
} else {
formatOptions = { hour: "numeric" };
}
cell.textContent = columnTime.toLocaleString(undefined, formatOptions);
row.appendChild(cell);
}
table.appendChild(row);
});
Berechnungen
>Wie viele Tage bis zu einem zukünftigen Datum verbleiben
Ein Beispiel für ein HTML-Formular, inspiriert vom Days Calculator auf timeanddate.com:
<form>
<label>
Enter future date:
<input type="date" name="future-date" />
</label>
<button>Submit</button>
</form>
<div id="future-date-results"></div>
// Initialize the input; see 'Calendar input element'.
const futureDatePicker = document.querySelector('input[name="future-date"]');
const today = Temporal.Now.plainDateISO();
futureDatePicker.min = today;
futureDatePicker.value = today.add({ months: 1 });
document.querySelector("form").addEventListener("submit", (event) => {
event.preventDefault();
const futureDateParam = futureDatePicker.value;
if (!futureDateParam) return;
const browserCalendar = new Intl.DateTimeFormat().resolvedOptions().calendar;
const futureDate =
Temporal.PlainDate.from(futureDateParam).withCalendar(browserCalendar);
const today = Temporal.Now.plainDateISO().withCalendar(browserCalendar);
const until = today.until(futureDate, { largestUnit: "day" });
const untilMonths = until.round({ largestUnit: "month", relativeTo: today });
const dayString = until.toLocaleString();
const results = document.getElementById("future-date-results");
results.innerHTML = `
<p>From and including: <strong>${today.toLocaleString()}</strong></p>
<p>To but not including: <strong>${futureDate.toLocaleString()}</strong></p>
<h4>Result: ${dayString}</h4>
<p>It is ${dayString} from the start date to the end date, but not
including the end date.</p>
<p>Or ${untilMonths.toLocaleString()} excluding the end date.</p>
`;
});
Dauer zwischen jetzt und einem vergangenen oder zukünftigen Ereignis in einer Zeitzone mit begrenzten Einheiten
Ermitteln Sie die Differenz zwischen zwei Temporal.Instant-Instanzen als Temporal.Duration-Instanz (positiv oder negativ). Diese stellt die Dauer zwischen den beiden Zeitpunkten dar und verwendet keine größeren als die angegebenen Einheiten – beispielsweise, um einen aussagekräftigen Countdown mit oder ohne Monate beziehungsweise Tage anzuzeigen.
const result = Temporal.Instant.from("2020-01-09T04:00Z").since(
Temporal.Instant.from("2020-01-09T00:00Z"),
{
largestUnit: "hour",
},
);
console.log(`${result}`); // 'PT4H'
const result2 = Temporal.Instant.from("2020-01-09T00:00Z").until(
Temporal.Instant.from("2020-01-09T04:00Z"),
{
largestUnit: "minute",
},
);
console.log(`${result2}`); // 'PT240M'
// Example of using it in a countdown:
const duration = Temporal.Now.instant().until(
Temporal.Instant.from("2020-04-01T13:00-07:00[America/Los_Angeles]"),
);
`It's ${duration.abs().toLocaleString()} ${duration.sign < 0 ? "since" : "until"} the TC39 Temporal presentation`;
Nächste Offset-Umstellung in einer Zeitzone
Ordnen Sie einer Temporal.ZonedDateTime-Instanz eine andere Temporal.ZonedDateTime-Instanz zu, die den nächsten exakten Zeitpunkt repräsentiert, an dem in der Zeitzone eine Offset-Umstellung stattfindet (beispielsweise zum Einrichten von Erinnerungen). Die folgende Funktion nimmt außerdem ein inclusive-Flag entgegen, um eine Umstellung zum Anfangszeitpunkt einzubeziehen, und gibt null zurück, wenn keine Umstellung bekannt ist.
function getNextOffsetTransitionFromExactTime(zonedDateTime, inclusive) {
let nearest;
if (inclusive) {
// In case instant itself is the exact time of a transition:
nearest = zonedDateTime
.subtract({ nanoseconds: 1 })
.getTimeZoneTransition("next");
} else {
nearest = zonedDateTime.getTimeZoneTransition("next");
}
return nearest;
}
const nycTime = Temporal.ZonedDateTime.from(
"2019-04-16T21:01Z[America/New_York]",
);
const nextTransition = getNextOffsetTransitionFromExactTime(nycTime, false);
console.log(nextTransition.toString());
// '2019-11-03T01:00:00-05:00[America/New_York]'
// Inclusive
const sameTransition = getNextOffsetTransitionFromExactTime(
nextTransition,
true,
);
console.log(sameTransition.toString() === nextTransition.toString()); // true
// No known future DST transitions in a time zone
const reginaTime = Temporal.ZonedDateTime.from(
"2019-04-16T21:01Z[America/Regina]",
);
console.log(getNextOffsetTransitionFromExactTime(reginaTime)); // null
Einen exakten Zeitpunkt mit Geschäftszeiten vergleichen
Die folgende Funktion nimmt ein Temporal.ZonedDateTime, einen Wochenplan und ein Temporal.Duration entgegen, das festlegt, welcher Zeitraum als „bald“ gilt. Sie gibt „öffnet bald“, „geöffnet“, „schließt bald“ oder „geschlossen“ zurück. Der Plan ist ein Array mit sieben Einträgen, beginnend mit Sonntag. Jeder Eintrag ist entweder null für einen geschlossenen Tag oder ein Objekt mit den Eigenschaften open und close, die Temporal.PlainTime-Werte enthalten.
function getBusinessOpenStateText(now, businessHours, soonWindow) {
const compare = Temporal.ZonedDateTime.compare;
function inRange(zdt, start, end) {
return compare(zdt, start) >= 0 && compare(zdt, end) < 0;
}
// Because of times wrapping around at midnight, we may need to consider
// yesterday's and tomorrow's hours as well
for (const delta of [-1, 0]) {
const openDate = now.toPlainDate().add({ days: delta });
// convert weekday (1..7) to 0-based index, for array:
const index = (openDate.dayOfWeek + 7) % 7;
if (!businessHours[index]) continue;
const timeZone = now.timeZoneId;
const { open: openTime, close: closeTime } = businessHours[index];
const open = openDate.toZonedDateTime({ plainTime: openTime, timeZone });
const isWrap = Temporal.PlainTime.compare(closeTime, openTime) < 0;
const closeDate = isWrap ? openDate.add({ days: 1 }) : openDate;
const close = closeDate.toZonedDateTime({ plainTime: closeTime, timeZone });
if (inRange(now, open, close)) {
return compare(now, close.subtract(soonWindow)) >= 0
? "closing soon"
: "open";
}
if (inRange(now.add(soonWindow), open, close)) return "opening soon";
}
return "closed";
}
// For example, a restaurant or bar might have opening hours that go past
// midnight; make sure this is handled correctly
const businessHours = [
/* Sun */ {
open: Temporal.PlainTime.from("13:00"),
close: Temporal.PlainTime.from("20:30"),
},
/* Mon */ null, // closed Mondays
/* Tue */ {
open: Temporal.PlainTime.from("11:00"),
close: Temporal.PlainTime.from("20:30"),
},
/* Wed */ {
open: Temporal.PlainTime.from("11:00"),
close: Temporal.PlainTime.from("20:30"),
},
/* Thu */ {
open: Temporal.PlainTime.from("11:00"),
close: Temporal.PlainTime.from("22:00"),
},
/* Fri */ {
open: Temporal.PlainTime.from("11:00"),
close: Temporal.PlainTime.from("00:00"),
},
/* Sat */ {
open: Temporal.PlainTime.from("11:00"),
close: Temporal.PlainTime.from("02:00"),
},
];
const now = Temporal.ZonedDateTime.from(
"2019-04-07T00:00+02:00[Europe/Berlin]",
);
const soonWindow = Temporal.Duration.from({ minutes: 30 });
const saturdayNightState = getBusinessOpenStateText(
now,
businessHours,
soonWindow,
);
console.log(saturdayNightState); // 'open'
const lastCall = now.add({ hours: 1, minutes: 50 });
console.log(lastCall.toString()); // '2019-04-07T01:50:00+02:00[Europe/Berlin]'
const lastCallState = getBusinessOpenStateText(
lastCall,
businessHours,
soonWindow,
);
console.log(lastCallState); // 'closing soon'
const tuesdayEarly = now.add({ days: 2, hours: 6 });
const tuesdayEarlyState = getBusinessOpenStateText(
tuesdayEarly,
businessHours,
soonWindow,
);
console.log(tuesdayEarlyState); // 'closed'
Ankunftszeit, Abflugzeit und Flugdauer
Berechnen Sie aus Abflug- und Ankunftszeiten in ihren jeweiligen Ortszeiten die Reisedauer in Einheiten, die nicht größer als Stunden sind. (Standardmäßig sind Differenzen zwischen ZonedDateTime-Instanzen exakte Differenzen in Zeiteinheiten.)
const departure = Temporal.ZonedDateTime.from(
"2020-03-08T11:55:00+08:00[Asia/Hong_Kong]",
);
const arrival = Temporal.ZonedDateTime.from(
"2020-03-08T09:50:00-07:00[America/Los_Angeles]",
);
const flightTime = departure.until(arrival);
console.log(flightTime.toString()); // 'PT12H55M'
Berechnen Sie aus einer Abflugzeit mit Zeitzone und einer Flugdauer die Ankunftszeit in der Zeitzone des Zielorts. Verwenden Sie dazu zeitzonenbewusste Berechnungen.
const departure = Temporal.ZonedDateTime.from(
"2020-03-08T11:55:00+08:00[Asia/Hong_Kong]",
);
const flightTime = Temporal.Duration.from({ minutes: 775 });
const arrival = departure.add(flightTime).withTimeZone("America/Los_Angeles");
console.log(arrival.toString());
// '2020-03-08T09:50:00-07:00[America/Los_Angeles]'
Ein Startdatum verschieben
Die folgende Funktion nimmt ein Temporal.PlainDate und eine Anzahl von Tagen der Verzögerung entgegen (beispielsweise die Zeit, die für eine Genehmigung benötigt wurde). Sie gibt ein Temporal.PlainDate für den Anfang des Monats zurück, der auf das verschobene Datum folgt.
function plusAndRoundToMonthStart(date, delayDays) {
return (
date
.add({ days: delayDays })
.add({ months: 1 })
// constrains to end of month if needed, e.g. Jan 31 -> Feb 28
.with({ day: 1 })
);
}
const oldLaunchDate = Temporal.PlainDate.from("2019-06-01");
const fifteenDaysDelay = plusAndRoundToMonthStart(oldLaunchDate, 15);
console.log(fifteenDaysDelay.toString()); // '2019-07-01'
const sixtyDaysDelay = plusAndRoundToMonthStart(oldLaunchDate, 60);
console.log(sixtyDaysDelay.toString()); // '2019-08-01'
Eine Erinnerung vor dem Erreichen einer Rekorddauer planen
Bei einem Rekord (beispielsweise einer persönlichen Bestzeit im Sport) möchten Sie möglicherweise kurz vor dessen Übertreffen benachrichtigt werden. Dieses Beispiel nimmt einen Rekord als Temporal.Duration, den exakten Anfangszeitpunkt des aktuellen Versuchs als Temporal.Instant und ein weiteres Temporal.Duration entgegen. Letzteres gibt an, wie lange vor dem Zeitpunkt eines möglichen neuen Rekords Sie benachrichtigt werden möchten. Die Funktion gibt den exakten Zeitpunkt zurück, zu dem eine Benachrichtigung gesendet werden könnte, beispielsweise: „Weiter so! Noch 5 Minuten bis zu Ihrer persönlichen Bestzeit!“
Dies könnte für das Aufzeichnen von Trainingseinheiten, für Rennen (einschließlich langer Rennen, die möglicherweise Zeitzonen durchqueren, wie die Bullrun Rally, das Iditarod, der Self-Transcendence 3100 und das Clipper Round The World Race) oder sogar für fortlaufende Aktivitäten wie tägliche „Streaks“ verwendet werden.
function getInstantBeforeOldRecord(start, previousRecord, noticeWindow) {
return start.add(previousRecord).subtract(noticeWindow);
}
// Start of the men's 10000 meters at the Rio de Janeiro 2016 Olympic Games
const raceStart = Temporal.Instant.from(
"2016-08-13T21:27-03:00[America/Sao_Paulo]",
);
// Kenenisa Bekele's world record set in 2005
const record = Temporal.Duration.from({
minutes: 26,
seconds: 17,
milliseconds: 530,
});
const noticeWindow = Temporal.Duration.from({ minutes: 1 });
// Time to send a "hurry up, can you finish the race in 1 minute?" push
// notification to all the runners
const reminderAt = getInstantBeforeOldRecord(raceStart, record, noticeWindow);
console.log(reminderAt.toString()); // '2016-08-14T00:52:17.53Z'
Der n-te Wochentag des Monats
Die folgende Funktion nimmt ein Temporal.PlainYearMonth entgegen und gibt ein Temporal.PlainDate zurück, das den ersten Dienstag dieses Monats repräsentiert. Sie lässt sich für andere Wochentage anpassen.
function getFirstTuesday(queriedMonth) {
// We first need to convert to a date
const firstOfMonth = queriedMonth.toPlainDate({ day: 1 });
// We have Monday = 1, Sunday = 7, and we want to add a positive number
// smaller than 7 to get to the first Tuesday.
// If we're already on a Tuesday (2) then we want to add 0.
// So for the first of the month being a Monday through Sunday the additions are:
// 1, 0, 6, 5, 4, 3, 2 which is given by that formula.
// This lookup table makes this example easier to read, but you can also
// calculate the answer: (7 + desiredWeekday - firstOfMonth.dayOfWeek) % 7
return firstOfMonth.add({
days: [1, 0, 6, 5, 4, 3, 2][firstOfMonth.dayOfWeek - 1],
});
}
const myMonth = Temporal.PlainYearMonth.from("2020-02");
const firstTuesdayOfMonth = getFirstTuesday(myMonth);
console.log(firstTuesdayOfMonth.toString()); // '2020-02-04'
console.log(firstTuesdayOfMonth.dayOfWeek); // 2
// Similarly, to get the second Tuesday:
const secondWeek = myMonth.toPlainDate({ day: 8 });
const secondTuesday = secondWeek.add({
days: [1, 0, 6, 5, 4, 3, 2][secondWeek.dayOfWeek - 1],
});
console.log(secondTuesday.day === firstTuesdayOfMonth.day + 7); // true
// And the last Tuesday:
const lastOfMonth = myMonth.toPlainDate({ day: myMonth.daysInMonth });
const lastTuesday = lastOfMonth.subtract({
days: [6, 0, 1, 2, 3, 4, 5][lastOfMonth.dayOfWeek - 1],
});
console.log(lastTuesday.toString()); // '2020-02-25'
console.log(lastTuesday.dayOfWeek); // 2
// or:
const lastTuesday2 = lastOfMonth.subtract({
days: (7 + lastOfMonth.dayOfWeek - 2) % 7,
});
console.log(Temporal.PlainDate.compare(lastTuesday, lastTuesday2)); // 0
Die folgende Funktion nimmt ein Temporal.PlainYearMonth und einen Wochentag von 1 (Montag) bis 7 (Sonntag) entgegen. Sie gibt ein chronologisch geordnetes Array von Temporal.PlainDate-Instanzen für alle entsprechenden Tage des Monats zurück.
function getWeeklyDaysInMonth(yearMonth, dayNumberOfTheWeek) {
const firstOfMonth = yearMonth.toPlainDate({ day: 1 });
let nextWeekday = firstOfMonth.add({
days: (7 + dayNumberOfTheWeek - firstOfMonth.dayOfWeek) % 7,
});
const result = [];
while (nextWeekday.month === yearMonth.month) {
result.push(nextWeekday);
nextWeekday = nextWeekday.add({ days: 7 });
}
return result;
}
console.log(
getWeeklyDaysInMonth(Temporal.PlainYearMonth.from("2020-02"), 1).join(" "),
); // '2020-02-03 2020-02-10 2020-02-17 2020-02-24'
console.log(
getWeeklyDaysInMonth(Temporal.PlainYearMonth.from("2020-02"), 6).join(" "),
); // '2020-02-01 2020-02-08 2020-02-15 2020-02-22 2020-02-29'
Die folgende Funktion nimmt ein Temporal.PlainDate entgegen und gibt die Anzahl der vorhergehenden Tage im selben Monat zurück, die auf denselben Wochentag fallen.
function countPrecedingWeeklyDaysInMonth(date) {
// This doesn't actually require Temporal
return Math.floor((date.day - 1) / 7);
}
console.log(
countPrecedingWeeklyDaysInMonth(Temporal.PlainDate.from("2020-02-28")),
); // 3
console.log(
countPrecedingWeeklyDaysInMonth(Temporal.PlainDate.from("2020-02-29")),
); // 4
Den Tag des Monats ändern
Hier sind einige Beispiele dafür, wie Sie bei einem vorhandenen Datum den Tag des Monats ändern.
const date = Temporal.PlainDate.from("2020-04-14");
// Third day of next month:
const thirdOfNextMonth = date.add({ months: 1 }).with({ day: 3 });
console.log(thirdOfNextMonth.toString()); // '2020-05-03'
// Last day of this month:
const lastOfThisMonth = date.with({ day: date.daysInMonth });
console.log(lastOfThisMonth.toString()); // '2020-04-30'
// On the 18th of this month at 8 PM:
const thisMonth18thAt8PM = date
.with({ day: 18 })
.toPlainDateTime(Temporal.PlainTime.from("20:00"));
console.log(thisMonth18thAt8PM.toString()); // '2020-04-18T20:00:00'
Dasselbe Datum in einem anderen Monat
Ebenso zeigen die folgenden Beispiele, wie Sie bei einem vorhandenen Datum den Monat ändern und dabei Tag und Jahr beibehalten.
Je nach gewünschtem Verhalten müssen Sie die passende Option overflow wählen. Der Standardwert "constrain" sollte jedoch für die meisten Fälle richtig sein.
const date = Temporal.PlainDate.from("2020-05-31");
// Same date and time, but in February
// (and use the last day if the date doesn't exist in February):
const feb = date.with({ month: 2 });
console.log(feb.toString()); // '2020-02-29'
// Same date and time, but in April
// (and throw an exception if the date doesn't exist in April):
date.with({ month: 4 }, { overflow: "reject" }); // Throws a RangeError
Nächstes wöchentliches Ereignis
Die folgende Funktion nimmt ein Temporal.ZonedDateTime als Anfangszeitpunkt, einen Wochentag von 1 (Montag) bis 7 (Sonntag), ein Temporal.PlainTime und eine Zeitzonenkennung entgegen. Sie gibt ein Temporal.ZonedDateTime zurück, das das nächste Auftreten des wöchentlichen Ereignisses repräsentiert (beispielsweise „wöchentlich donnerstags um 08:45 Uhr kalifornischer Zeit“).
function nextWeeklyOccurrence(now, weekday, eventTime, eventTimeZone) {
const nowInEventTimeZone = now.withTimeZone(eventTimeZone);
const nextDate = nowInEventTimeZone
.toPlainDate()
.add({ days: (weekday + 7 - nowInEventTimeZone.dayOfWeek) % 7 });
let nextOccurrence = nextDate.toZonedDateTime({
plainTime: eventTime,
timeZone: eventTimeZone,
});
// Handle the case where the event is today but already happened
if (Temporal.ZonedDateTime.compare(now, nextOccurrence) > 0) {
nextOccurrence = nextOccurrence.add({ weeks: 1 });
}
return nextOccurrence.withTimeZone(now.timeZoneId);
}
// "Weekly on Thursdays at 08:45 California time":
const weekday = 4;
const eventTime = Temporal.PlainTime.from("08:45");
const eventTimeZone = "America/Los_Angeles";
const rightBefore = Temporal.ZonedDateTime.from(
"2020-03-26T15:30+00:00[Europe/London]",
);
let next = nextWeeklyOccurrence(rightBefore, weekday, eventTime, eventTimeZone);
console.log(next.toString()); // '2020-03-26T15:45:00+00:00[Europe/London]'
const rightAfter = Temporal.ZonedDateTime.from(
"2020-03-26T16:00+00:00[Europe/London]",
);
next = nextWeeklyOccurrence(rightAfter, weekday, eventTime, eventTimeZone);
console.log(next.toString()); // '2020-04-02T16:45:00+01:00[Europe/London]'
Wochentag eines jährlichen Ereignisses
In einigen Ländern wird ein zusätzlicher „Brückentag“ als Feiertag am Montag oder Freitag begangen, wenn ein Feiertag auf einen Dienstag oder Donnerstag fällt. So erhalten Beschäftigte ein langes Wochenende. Die folgende Funktion nimmt ein Temporal.PlainMonthDay und ein Jahr entgegen und gibt ein Array von Temporal.PlainDate-Werten für den Feiertag und einen möglichen Brückentag zurück. Fällt der Feiertag auf ein Wochenende, gibt sie ein leeres Array zurück.
function bridgePublicHolidays(holiday, year) {
const date = holiday.toPlainDate({ year });
switch (date.dayOfWeek) {
case 1: // Mon
case 3: // Wed
case 5: // Fri
return [date];
case 2: // Tue; take Monday off
return [date.subtract({ days: 1 }), date];
case 4: // Thu; take Friday off
return [date, date.add({ days: 1 })];
case 6: // Sat
case 7: // Sun
return [];
}
}
const laborDay = Temporal.PlainMonthDay.from("05-01");
// No bridge day
console.log(bridgePublicHolidays(laborDay, 2020).map((d) => d.toString()));
// ['2020-05-01']
// Bridge day
console.log(bridgePublicHolidays(laborDay, 2018).map((d) => d.toString()));
// ['2018-04-30', '2018-05-01']
// Bad luck, the holiday is already on a weekend
console.log(bridgePublicHolidays(laborDay, 2021).map((d) => d.toString()));
// []