Datum

Ein JavaScript-Datum wird im Wesentlichen als die seit der Epoche vergangenen Millisekunden spezifiziert, die als Mitternacht zu Beginn des 1. Januar 1970, UTC (entspricht der UNIX-Epoche) definiert ist. Dieser Zeitstempel ist zeitzonenunabhängig und definiert einen einzigartigen Moment in der Geschichte.

Der maximale Zeitstempel, der von einem Date-Objekt darstellbar ist, ist etwas kleiner als die maximale sichere Ganzzahl (Number.MAX_SAFE_INTEGER, die 9.007.199.254.740.991 beträgt). Ein Date-Objekt kann maximal ±8.640.000.000.000.000 Millisekunden oder ±100.000.000 (hundert Millionen) Tage relativ zur Epoche darstellen. Dies ist der Bereich vom 20. April 271821 v. Chr. bis zum 13. September 275760 n. Chr. Jeder Versuch, eine Zeit außerhalb dieses Bereichs darzustellen, führt dazu, dass das Date-Objekt einen Zeitstempelwert von NaN hält, was ein "Ungültiges Datum" ist.

console.log(new Date(8.64e15).toString()); // "Sat Sep 13 275760 00:00:00 GMT+0000 (Coordinated Universal Time)"
console.log(new Date(8.64e15 + 1).toString()); // "Invalid Date"

Es gibt verschiedene Methoden, die es Ihnen ermöglichen, mit dem im Datum gespeicherten Zeitstempel zu interagieren:

• Sie können direkt mit dem Zeitstempelwert interagieren, indem Sie die Methoden getTime() und setTime() verwenden.
• Die Methoden valueOf() und [Symbol.toPrimitive]() (wenn "number" übergeben wird) — die automatisch bei Zahlenzwangskoerzierung aufgerufen werden — geben den Zeitstempel zurück, wodurch Date-Objekte sich wie ihre Zeitstempel verhalten, wenn sie in Zahlkontexten verwendet werden.
• Alle statischen Methoden (Date.now(), Date.parse(), und Date.UTC()) geben Zeitstempel statt Date-Objekte zurück.
• Der Date()-Konstruktor kann mit einem Zeitstempel als einzigem Argument aufgerufen werden.

Ein Datum wird intern als eine einzelne Zahl, der Zeitstempel, dargestellt. Wenn Sie damit interagieren, muss der Zeitstempel als strukturierte Datum-und-Uhrzeit-Darstellung interpretiert werden. Es gibt immer zwei Möglichkeiten, einen Zeitstempel zu interpretieren: als lokale Zeit oder als Coordinated Universal Time (UTC), die globale Standardzeit, die durch die Weltzeit definiert wird. Die lokale Zeitzone wird nicht im Date-Objekt gespeichert, sondern wird durch die Hostumgebung (Gerät des Benutzers) bestimmt.

Zum Beispiel repräsentiert der Zeitstempel 0 einen einzigartigen Moment in der Geschichte, kann jedoch auf zwei Arten interpretiert werden:

• Als UTC-Zeit ist es Mitternacht zu Beginn des 1. Januar 1970, UTC,
• Als lokale Zeit in New York (UTC-5), ist es 19:00:00 am 31. Dezember 1969.

Die Methode getTimezoneOffset() gibt die Differenz zwischen UTC und der lokalen Zeit in Minuten zurück. Beachten Sie, dass der Zeitzonenoffset nicht nur von der aktuellen Zeitzone, sondern auch von der durch das Date-Objekt repräsentierten Zeit abhängt, da es Sommerzeit und historische Veränderungen gibt. Im Wesentlichen ist der Zeitzonenoffset der Offset von der UTC-Zeit zum Zeitpunkt, der vom Date-Objekt und am Standort der Hostumgebung repräsentiert wird.

Es gibt zwei Gruppen von Date-Methoden: Eine Gruppe holt und setzt verschiedene Datumskomponenten, indem der Zeitstempel als lokale Zeit interpretiert wird, während die andere UTC verwendet.

Der Date()-Konstruktor kann mit zwei oder mehr Argumenten aufgerufen werden, wobei diese als Jahr, Monat, Tag, Stunde, Minute, Sekunde und Millisekunde interpretiert werden, jeweils als lokale Zeit. Date.UTC() funktioniert ähnlich, interpretiert die Komponenten jedoch als UTC-Zeit und akzeptiert auch ein Einzelargument, das das Jahr repräsentiert.

Wenn ein Segment seinen erwarteten Bereich überschreitet oder unterschreitet, wird es normalerweise "an das höhere Segment übertragen" oder "vom höheren Segment ausgeliehen". Zum Beispiel, wenn der Monat auf 12 gesetzt ist (Monate sind nullbasiert, also ist Dezember 11), wird es Januar des nächsten Jahres. Wenn der Tag des Monats auf 0 gesetzt wird, wird es der letzte Tag des vorherigen Monats. Dies gilt auch für Daten, die mit dem Datum-Zeit-String-Format spezifiziert sind.

Es gibt viele Möglichkeiten, um ein Datum als String zu formatieren. Die JavaScript-Spezifikation spezifiziert nur ein Format, das universell unterstützt werden muss: das Datum-Zeit-String-Format, eine Vereinfachung des erweiterten ISO 8601-Kalenderdatumsformats. Das Format ist wie folgt:

YYYY-MM-DDTHH:mm:ss.sssZ

• YYYY ist das Jahr und hat vier Ziffern (0000 bis 9999) oder als ein erweitertes Jahr mit + oder -, gefolgt von sechs Ziffern. Das Vorzeichen ist für erweiterte Jahre erforderlich. -000000 ist ausdrücklich als gültiges Jahr ausgeschlossen.
• MM ist der Monat und hat zwei Ziffern (01 bis 12). Standardmäßig 01.
• DD ist der Tag des Monats und hat zwei Ziffern (01 bis 31). Standardmäßig 01.
• T ist ein literales Zeichen, das den Beginn des _Zeit_teil des Strings anzeigt. Das T ist erforderlich, wenn der Zeitteil angegeben wird.
• HH ist die Stunde und hat zwei Ziffern (00 bis 23). Als Sonderfall ist 24:00:00 erlaubt und wird als Mitternacht am Beginn des nächsten Tages interpretiert. Standardmäßig 00.
• mm ist die Minute und hat zwei Ziffern (00 bis 59). Standardmäßig 00.
• ss ist die Sekunde und hat zwei Ziffern (00 bis 59). Standardmäßig 00.
• sss ist die Millisekunde und hat drei Ziffern (000 bis 999). Standardmäßig 000.
• Z ist der Zeitzonenoffset, der entweder das literale Zeichen Z (was UTC bedeutet) oder + oder -, gefolgt von HH:mm, der Offset in Stunden und Minuten von UTC sein kann.

Verschiedene Komponenten können weggelassen werden, daher sind die folgenden alle gültig:

• Nur-Datum-Form: YYYY, YYYY-MM, YYYY-MM-DD
• Datum-Zeit-Form: eine der obigen Nur-Datum-Formen, gefolgt von T, gefolgt von HH:mm, HH:mm:ss oder HH:mm:ss.sss. Jede Kombination kann von einem Zeitzonenoffset gefolgt werden.

Zum Beispiel sind "2011-10-10" (Nur-Datum Form), "2011-10-10T14:48:00" (Datum-Zeit Form) oder "2011-10-10T14:48:00.000+09:00" (Datum-Zeit Form mit Millisekunden und Zeitzone) alle gültige Datum-Zeit-Strings.

Wenn der Zeitzonenoffset fehlt, werden Nur-Datum-Formen als UTC-Zeit und Datum-Zeit-Formen als lokale Zeit interpretiert. Die Interpretation als UTC-Zeit ist auf einen historischen Spezifikationsfehler zurückzuführen, der nicht mit ISO 8601 konsistent war, aber aufgrund der Web-Kompatibilität nicht geändert werden konnte. Siehe Fehlerhafter Parser - Ein Web-Reality-Problem.

Date.parse() und der Date()-Konstruktor akzeptieren beide Strings im Datum-Zeit-String-Format als Eingabe. Darüber hinaus dürfen Implementierungen andere Datumsformate unterstützen, wenn die Eingabe diesem Format nicht entspricht.

Die Methode toISOString() gibt eine String-Darstellung des Datums im Datum-Zeit-String-Format zurück, wobei der Zeitzonenoffset immer auf Z (UTC) gesetzt ist.

Nicht standardmäßige Strings können beliebig gemäß der Implementierung geparst werden, einschließlich der Zeitzone — die meisten Implementierungen verwenden standardmäßig die lokale Zeitzone. Implementierungen sind nicht dazu verpflichtet, ein ungültiges Datum für außerhalb der Grenzen liegende Datumskomponenten zurückzugeben, obwohl sie es normalerweise tun. Ein String kann in den Grenzen liegende Datumskomponenten haben (mit den oben definierten Grenzen), repräsentiert jedoch keine reale Datumsangabe (zum Beispiel "30. Februar"). Implementierungen verhalten sich in diesem Fall inkonsistent. Die Seite Date.parse() bietet mehr Beispiele zu diesen nicht standardmäßigen Fällen.

• toISOString() gibt einen String im Format 1970-01-01T00:00:00.000Z zurück (das oben eingeführte Datum-Zeit-String-Format, das ein vereinfachtes ISO 8601 ist). toJSON() ruft toISOString() auf und gibt das Ergebnis zurück.
• toString() gibt einen String im Format Thu Jan 01 1970 00:00:00 GMT+0000 (Coordinated Universal Time) zurück, während toDateString() und toTimeString() den Datums- und den Zeitteil des Strings, jeweils, zurückgeben. [Symbol.toPrimitive]() (wenn "string" oder "default" übergeben wird) ruft toString() auf und gibt das Ergebnis zurück.
• toUTCString() gibt einen String im Format Thu, 01 Jan 1970 00:00:00 GMT zurück (verallgemeinertes RFC 7231).
• toLocaleDateString(), toLocaleTimeString() und toLocaleString() verwenden lokalitätsspezifische Datum- und Zeitformate, die üblicherweise von der Intl-API bereitgestellt werden.

Siehe den Abschnitt Formate der toString-Methoden-Rückgabewerte für Beispiele.

Date()

Wenn er als Konstruktor aufgerufen wird, gibt er ein neues Date-Objekt zurück. Wenn er als Funktion aufgerufen wird, gibt er eine String-Darstellung des aktuellen Datums und der aktuellen Zeit zurück.

Date.now()

Gibt den numerischen Wert zurück, der der aktuellen Zeit entspricht — die Anzahl der Millisekunden seit dem 1. Januar 1970, 00:00:00 UTC, wobei Schaltsekunden ignoriert werden.

Date.parse()

Parst eine String-Darstellung eines Datums und gibt die Anzahl der Millisekunden seit dem 1. Januar 1970, 00:00:00 UTC, wobei Schaltsekunden ignoriert werden, zurück.

Date.UTC()

Akzeptiert die gleichen Parameter wie die längste Form des Konstruktors (d.h. 2 bis 7) und gibt die Anzahl der Millisekunden seit dem 1. Januar 1970, 00:00:00 UTC, wobei Schaltsekunden ignoriert werden, zurück.

Diese Eigenschaften sind auf Date.prototype definiert und werden von allen Date-Instanzen geteilt.

Date.prototype.constructor

Die Konstruktorfunktion, die das Instanzobjekt erstellt hat. Für Date-Instanzen ist der Anfangswert der Date-Konstruktor.

Date.prototype.getDate()

Gibt den Tag des Monats (1 – 31) für das angegebene Datum gemäß lokaler Zeit zurück.

Date.prototype.getDay()

Gibt den Wochentag (0 – 6) für das angegebene Datum gemäß lokaler Zeit zurück.

Date.prototype.getFullYear()

Gibt das Jahr (4 Ziffern für 4-stellige Jahre) des angegebenen Datums gemäß lokaler Zeit zurück.

Date.prototype.getHours()

Gibt die Stunde (0 – 23) im angegebenen Datum gemäß lokaler Zeit zurück.

Date.prototype.getMilliseconds()

Gibt die Millisekunden (0 – 999) im angegebenen Datum gemäß lokaler Zeit zurück.

Date.prototype.getMinutes()

Gibt die Minuten (0 – 59) im angegebenen Datum gemäß lokaler Zeit zurück.

Date.prototype.getMonth()

Gibt den Monat (0 – 11) im angegebenen Datum gemäß lokaler Zeit zurück.

Date.prototype.getSeconds()

Gibt die Sekunden (0 – 59) im angegebenen Datum gemäß lokaler Zeit zurück.

Date.prototype.getTime()

Gibt den numerischen Wert des angegebenen Datums als die Anzahl der Millisekunden seit dem 1. Januar 1970, 00:00:00 UTC, zurück. (Negative Werte werden für frühere Zeiten zurückgegeben.)

Date.prototype.getTimezoneOffset()

Gibt den Zeitzonen-Offset in Minuten für die aktuelle Lokalisierung zurück.

Date.prototype.getUTCDate()

Gibt den Tag (Datum) des Monats (1 – 31) im angegebenen Datum gemäß Weltzeit zurück.

Date.prototype.getUTCDay()

Gibt den Wochentag (0 – 6) im angegebenen Datum gemäß Weltzeit zurück.

Date.prototype.getUTCFullYear()

Gibt das Jahr (4 Ziffern für 4-stellige Jahre) im angegebenen Datum gemäß Weltzeit zurück.

Date.prototype.getUTCHours()

Gibt die Stunden (0 – 23) im angegebenen Datum gemäß Weltzeit zurück.

Date.prototype.getUTCMilliseconds()

Gibt die Millisekunden (0 – 999) im angegebenen Datum gemäß Weltzeit zurück.

Date.prototype.getUTCMinutes()

Gibt die Minuten (0 – 59) im angegebenen Datum gemäß Weltzeit zurück.

Date.prototype.getUTCMonth()

Gibt den Monat (0 – 11) im angegebenen Datum gemäß Weltzeit zurück.

Date.prototype.getUTCSeconds()

Gibt die Sekunden (0 – 59) im angegebenen Datum gemäß Weltzeit zurück.

Date.prototype.getYear() Veraltet

Gibt das Jahr (normalerweise 2–3 Ziffern) im angegebenen Datum gemäß lokaler Zeit zurück. Verwenden Sie stattdessen getFullYear().

Date.prototype.setDate()

Setzt den Tag des Monats für ein angegebenes Datum gemäß lokaler Zeit.

Date.prototype.setFullYear()

Setzt das vollständige Jahr (z. B. 4 Ziffern für 4-stellige Jahre) für ein angegebenes Datum gemäß lokaler Zeit.

Date.prototype.setHours()

Setzt die Stunden für ein angegebenes Datum gemäß lokaler Zeit.

Date.prototype.setMilliseconds()

Setzt die Millisekunden für ein angegebenes Datum gemäß lokaler Zeit.

Date.prototype.setMinutes()

Setzt die Minuten für ein angegebenes Datum gemäß lokaler Zeit.

Date.prototype.setMonth()

Setzt den Monat für ein angegebenes Datum gemäß lokaler Zeit.

Date.prototype.setSeconds()

Setzt die Sekunden für ein angegebenes Datum gemäß lokaler Zeit.

Date.prototype.setTime()

Setzt das Date-Objekt auf die durch die Anzahl der Millisekunden seit dem 1. Januar 1970, 00:00:00 UTC, dargestellte Zeit. Verwenden Sie negative Zahlen für frühere Zeiten.

Date.prototype.setUTCDate()

Setzt den Tag des Monats für ein angegebenes Datum gemäß Weltzeit.

Date.prototype.setUTCFullYear()

Setzt das vollständige Jahr (z. B. 4 Ziffern für 4-stellige Jahre) für ein angegebenes Datum gemäß Weltzeit.

Date.prototype.setUTCHours()

Setzt die Stunden für ein angegebenes Datum gemäß Weltzeit.

Date.prototype.setUTCMilliseconds()

Setzt die Millisekunden für ein angegebenes Datum gemäß Weltzeit.

Date.prototype.setUTCMinutes()

Setzt die Minuten für ein angegebenes Datum gemäß Weltzeit.

Date.prototype.setUTCMonth()

Setzt den Monat für ein angegebenes Datum gemäß Weltzeit.

Date.prototype.setUTCSeconds()

Setzt die Sekunden für ein angegebenes Datum gemäß Weltzeit.

Date.prototype.setYear() Veraltet

Setzt das Jahr (normalerweise 2–3 Ziffern) für ein angegebenes Datum gemäß lokaler Zeit. Verwenden Sie stattdessen setFullYear().

Date.prototype.toDateString()

Gibt den "Datum"-Teil des Date als menschenlesbaren String wie 'Thu Apr 12 2018' zurück.

Date.prototype.toISOString()

Konvertiert ein Datum in einen String im ISO 8601 Extended Format.

Date.prototype.toJSON()

Gibt einen String zurück, der das Date unter Verwendung von toISOString() darstellt. Soll implizit von JSON.stringify() aufgerufen werden.

Date.prototype.toLocaleDateString()

Gibt einen String mit einer lokalitätssensitiven Darstellung des Datumsanteils dieses Datums basierend auf Systemeinstellungen zurück.

Date.prototype.toLocaleString()

Gibt einen String mit einer lokalitätssensitiven Darstellung dieses Datums zurück. Überschreibt die Methode Object.prototype.toLocaleString().

Date.prototype.toLocaleTimeString()

Gibt einen String mit einer lokalitätssensitiven Darstellung des Zeitanteils dieses Datums basierend auf Systemeinstellungen zurück.

Date.prototype.toString()

Gibt einen String zurück, der das angegebene Date-Objekt darstellt. Überschreibt die Methode Object.prototype.toString().

Date.prototype.toTemporalInstant()

Gibt ein neues Temporal.Instant-Objekt zurück, das denselben epochMilliseconds-Wert wie dieser Datum`s Zeitstempel hat.

Date.prototype.toTimeString()

Gibt den "Zeit"-Teil des Date als menschenlesbaren String zurück.

Date.prototype.toUTCString()

Konvertiert ein Datum in einen String unter Verwendung der UTC-Zeitzone.

Date.prototype.valueOf()

Gibt den primitiven Wert eines Date-Objekts zurück. Überschreibt die Methode Object.prototype.valueOf().

Date.prototype[Symbol.toPrimitive]()

Konvertiert dieses Date-Objekt in einen primitiven Wert.

Die folgenden Beispiele zeigen verschiedene Möglichkeiten, JavaScript-Daten zu erstellen:

const today = new Date();
const birthday = new Date("December 17, 1995 03:24:00"); // DISCOURAGED: may not work in all runtimes
const birthday2 = new Date("1995-12-17T03:24:00"); // This is standardized and will work reliably
const birthday3 = new Date(1995, 11, 17); // the month is 0-indexed
const birthday4 = new Date(1995, 11, 17, 3, 24, 0);
const birthday5 = new Date(628021800000); // passing epoch timestamp

new Date() zeigt unerwünschte, inkonsistente Legacy-Verhaltensweisen mit zweistelligen Jahreswerten: speziell, wenn einem new Date()-Aufruf ein zweistelliger Jahreswert gegeben wird, wird dieser Jahreswert nicht als wörtliches Jahr behandelt und unverändert verwendet, sondern stattdessen als relativer Offset interpretiert – in einigen Fällen als Offset vom Jahr 1900, in anderen Fällen als Offset vom Jahr 2000.

let date = new Date(98, 1); // Sun Feb 01 1998 00:00:00 GMT+0000 (GMT)
date = new Date(22, 1); // Wed Feb 01 1922 00:00:00 GMT+0000 (GMT)
date = new Date("2/1/22"); // Tue Feb 01 2022 00:00:00 GMT+0000 (GMT)

// Legacy method; always interprets two-digit year values as relative to 1900
date.setYear(98);
date.toString(); // Sun Feb 01 1998 00:00:00 GMT+0000 (GMT)
date.setYear(22);
date.toString(); // Wed Feb 01 1922 00:00:00 GMT+0000 (GMT)

Um also Daten zwischen den Jahren 0 und 99 zu erstellen und abzurufen, verwenden Sie stattdessen die bevorzugten Methoden setFullYear() und getFullYear().

// Preferred method; never interprets any value as being a relative offset,
// but instead uses the year value as-is
date.setFullYear(98);
date.getFullYear(); // 98 (not 1998)
date.setFullYear(22);
date.getFullYear(); // 22 (not 1922, not 2022)

Die folgenden Beispiele zeigen, wie die verstrichene Zeit zwischen zwei JavaScript-Daten in Millisekunden bestimmt werden kann:

Aufgrund der unterschiedlichen Längen von Tagen (aufgrund der Sommerzeitumstellung), Monaten und Jahren erfordert die Angabe der verstrichenen Zeit in Einheiten größer als Stunden, Minuten und Sekunden die Berücksichtigung einer Reihe von Problemen und sollte gründlich recherchiert werden, bevor sie versucht wird.

// Using Date objects
const start = Date.now();

// The event to time goes here:
doSomethingForALongTime();
const end = Date.now();
const elapsed = end - start; // elapsed time in milliseconds

// Using built-in methods
const start = new Date();

// The event to time goes here:
doSomethingForALongTime();
const end = new Date();
const elapsed = end.getTime() - start.getTime(); // elapsed time in milliseconds

// To test a function and get back its return
function printElapsedTime(testFn) {
  const startTime = Date.now();
  const result = testFn();
  const endTime = Date.now();

  console.log(`Elapsed time: ${String(endTime - startTime)} milliseconds`);
  return result;
}

const yourFunctionReturn = printElapsedTime(yourFunction);

const seconds = Math.floor(Date.now() / 1000);

In diesem Fall ist es wichtig, nur eine ganze Zahl zurückzugeben - also wird eine einfache Division nicht funktionieren. Es ist auch wichtig, nur tatsächlich verstrichene Sekunden zurückzugeben. (Deshalb verwendet dieser Code Math.floor(), und nicht Math.round().)

• Date()