Datum

Ein JavaScript-Datum wird grundsätzlich als die Zeit in Millisekunden seit der Epoche spezifiziert, die als Mitternacht am Anfang des 1. Januar 1970 UTC (äquivalent zur UNIX-Epoche) definiert ist. Dieser Zeitstempel ist zeitzonenunabhängig und definiert eindeutig einen 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, das sind 9.007.199.254.740.991). Ein Date-Objekt kann maximal ±8.640.000.000.000.000 Millisekunden oder ±100.000.000 (einhundert Millionen) Tage relativ zur Epoche darstellen. Dies entspricht dem Bereich vom 20. April 271821 v. Chr. bis zum 13. September 275760 n. Chr. Jede Versuche, eine Zeit außerhalb dieses Bereichs darzustellen, resultiert darin, dass das Date-Objekt einen Zeitstempelwert von NaN enthä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 Ihnen den Umgang mit dem im Datum gespeicherten Zeitstempel ermöglichen:

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

Ein Datum wird intern als einzelne Zahl dargestellt, der Zeitstempel. Beim Interagieren mit diesem muss der Zeitstempel als strukturierte Datums- und Zeitdarstellung interpretiert werden. Es gibt immer zwei Möglichkeiten, einen Zeitstempel zu interpretieren: als lokale Zeit oder als koordinierte Weltzeit (UTC), dem globalen Standardzeitformat, das durch die Weltzeitstandards definiert wird. Die lokale Zeitzone wird nicht im Datumsobjekt gespeichert, sondern wird durch die Hostumgebung (Benutzergerät) bestimmt.

Zum Beispiel repräsentiert der Zeitstempel 0 einen einzigartigen Moment in der Geschichte, aber er kann 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 den Unterschied zwischen UTC und der lokalen Zeit in Minuten zurück. Beachten Sie, dass der Zeitzonenoffset nicht nur von der aktuellen Zeitzone abhängt, sondern auch von der durch das Date-Objekt repräsentierten Zeit, aufgrund der Sommerzeit und historischer Änderungen. Wesentlich ist der Zeitzonenoffset der Offset von UTC-Zeit, zu der durch das Date-Objekt repräsentierten Zeit und am Standort der Hostumgebung.

Es gibt zwei Gruppen von Date-Methoden: eine Gruppe holt und setzt verschiedene Datumsbestandteile durch Interpretation des Zeitstempels als lokale Zeit, 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 im lokalen Zeitformat interpretiert werden. Date.UTC() funktioniert ähnlich, interpretiert die Komponenten jedoch als UTC-Zeit und akzeptiert auch ein einziges Argument, das das Jahr repräsentiert.

Wenn ein Segment seinen erwarteten Bereich überschreitet oder unterschreitet, "überträgt" es üblicherweise zum oder "borgt" von dem höheren Segment. Zum Beispiel, wenn der Monat auf 12 gesetzt wird (die Monate sind nullbasiert, also ist Dezember 11), wird es zum 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 Format Date Time String angegeben sind.

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

YYYY-MM-DDTHH:mm:ss.sssZ

• YYYY ist das Jahr, mit vier Ziffern (0000 bis 9999), oder als erweitertes Jahr von + 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, mit zwei Ziffern (01 bis 12). Standard ist 01.
• DD ist der Tag des Monats, mit zwei Ziffern (01 bis 31). Standard ist 01.
• T ist ein wörtliches Zeichen, das den Beginn des Zeit-Teils der Zeichenkette angibt. Das T ist erforderlich, wenn der Zeitteil angegeben wird.
• HH ist die Stunde, mit zwei Ziffern (00 bis 23). Ein Sonderfall ist 24:00:00, das als Mitternacht am Anfang des nächsten Tages interpretiert wird. Standard ist 00.
• mm ist die Minute, mit zwei Ziffern (00 bis 59). Standard ist 00.
• ss ist die Sekunde, mit zwei Ziffern (00 bis 59). Standard ist 00.
• sss ist die Millisekunde, mit drei Ziffern (000 bis 999). Standard ist 000.
• Z ist der Zeitzonen-Offset, der entweder das wörtliche Zeichen Z (was UTC anzeigt) sein kann oder + oder -, gefolgt von HH:mm, dem Offset in Stunden und Minuten von UTC.

Verschiedene Komponenten können ausgelassen werden, sodass Folgendes alles gültig ist:

• Nur-Datum-Form: YYYY, YYYY-MM, YYYY-MM-DD
• Datums-Zeit-Form: eine der oben genannten Nur-Datum-Formen, gefolgt von T, gefolgt von HH:mm, HH:mm:ss, oder HH:mm:ss.sss. Jede Kombination kann von einem Zeitzonen-Offset gefolgt sein.

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

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

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

Die Methode toISOString() gibt eine Zeichenfolgenrepräsentation des Datums im Date Time String Format zurück, wobei der Zeitzonen-Offset immer Z (UTC) gesetzt ist.

Nicht-standardisierte Zeichenfolgen können auf jede gewünschte Weise von der Implementierung analysiert werden, einschließlich der Zeitzone — die meisten Implementierungen verwenden standardmäßig die lokale Zeitzone. Implementierungen sind nicht verpflichtet, ein ungültiges Datum für nicht zulässige Datumskomponenten zurückzugeben, obwohl sie dies normalerweise tun. Eine Zeichenfolge kann in-Bounds Datumskomponenten haben (mit den oben definierten Grenzen), jedoch kein Datum in der Realität darstellen (zum Beispiel "30. Februar"). Implementierungen verhalten sich in diesem Fall inkonsistent. Die Seite Date.parse() bietet mehr Beispiele zu diesen nicht-standardisierten Fällen.

• toISOString() gibt eine Zeichenfolge im Format 1970-01-01T00:00:00.000Z zurück (das oben eingeführte Date Time String Format, das eine vereinfachte ISO 8601 ist). toJSON() ruft toISOString() auf und gibt das Ergebnis zurück.
• toString() gibt eine Zeichenfolge im Format Thu Jan 01 1970 00:00:00 GMT+0000 (Koordinierte Weltzeit) zurück, während toDateString() und toTimeString() die jeweiligen Datums- und Zeitteile der Zeichenfolge zurückgeben. [Symbol.toPrimitive]() (wenn "string" oder "default" übergeben wird) ruft toString() auf und gibt das Ergebnis zurück.
• toUTCString() gibt eine Zeichenfolge im Format Thu, 01 Jan 1970 00:00:00 GMT zurück (generalisierter RFC 7231).
• toLocaleDateString(), toLocaleTimeString(), und toLocaleString() verwenden lokale datums- und zeitformatspezifische Darstellungen, die üblicherweise von der Intl API bereitgestellt werden.

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

Date()

Wenn als Konstruktor aufgerufen, gibt ein neues Date-Objekt zurück. Wenn als Funktion aufgerufen, gibt eine Zeichenfolgenrepräsentation des aktuellen Datums und der aktuellen Uhrzeit zurück.

Date.now()

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

Date.parse()

Analysiert eine Zeichenfolgenrepräsentation eines Datums und gibt die Anzahl von Millisekunden seit dem 1. Januar 1970 00:00:00 UTC zurück, wobei Schaltsekunden ignoriert werden.

Date.UTC()

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

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

Date.prototype.constructor

Die Konstruktorfunktion, die die Instanz erzeugt 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äß der lokalen Zeit zurück.

Date.prototype.getDay()

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

Date.prototype.getFullYear()

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

Date.prototype.getHours()

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

Date.prototype.getMilliseconds()

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

Date.prototype.getMinutes()

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

Date.prototype.getMonth()

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

Date.prototype.getSeconds()

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

Date.prototype.getTime()

Gibt den numerischen Wert des angegebenen Datums als die Anzahl von 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 den aktuellen Ort zurück.

Date.prototype.getUTCDate()

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

Date.prototype.getUTCDay()

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

Date.prototype.getUTCFullYear()

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

Date.prototype.getUTCHours()

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

Date.prototype.getUTCMilliseconds()

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

Date.prototype.getUTCMinutes()

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

Date.prototype.getUTCMonth()

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

Date.prototype.getUTCSeconds()

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

Date.prototype.getYear() Veraltet

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

Date.prototype.setDate()

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

Date.prototype.setFullYear()

Setzt das volle Jahr (z.B. 4 Ziffern für 4-stellige Jahre) für ein angegebenes Datum gemäß der lokalen Zeit.

Date.prototype.setHours()

Setzt die Stunde für ein angegebenes Datum gemäß der lokalen Zeit.

Date.prototype.setMilliseconds()

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

Date.prototype.setMinutes()

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

Date.prototype.setMonth()

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

Date.prototype.setSeconds()

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

Date.prototype.setTime()

Setzt das Date-Objekt auf die durch die Anzahl von 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äß universeller Zeit.

Date.prototype.setUTCFullYear()

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

Date.prototype.setUTCHours()

Setzt die Stunde für ein angegebenes Datum gemäß universeller Zeit.

Date.prototype.setUTCMilliseconds()

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

Date.prototype.setUTCMinutes()

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

Date.prototype.setUTCMonth()

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

Date.prototype.setUTCSeconds()

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

Date.prototype.setYear() Veraltet

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

Date.prototype.toDateString()

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

Date.prototype.toISOString()

Konvertiert ein Datum in eine Zeichenfolge, die dem ISO 8601 Extended Format folgt.

Date.prototype.toJSON()

Gibt eine Zeichenfolge zurück, die den Date unter Verwendung von toISOString() darstellt. Vorgesehen für die Verwendung durch JSON.stringify().

Date.prototype.toLocaleDateString()

Gibt eine Zeichenfolge mit einer ortsensitiven Darstellung des Datenteils dieses Datums basierend auf den Systemeinstellungen zurück.

Date.prototype.toLocaleString()

Gibt eine Zeichenfolge mit einer ortsensitiven Darstellung dieses Datums zurück. Überschreibt die Object.prototype.toLocaleString()-Methode.

Date.prototype.toLocaleTimeString()

Gibt eine Zeichenfolge mit einer ortsensitiven Darstellung des Zeitteils dieses Datums basierend auf den Systemeinstellungen zurück.

Date.prototype.toString()

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

Date.prototype.toTimeString()

Gibt den "Zeit"-Teil des Date als menschenlesbare Zeichenfolge zurück.

Date.prototype.toUTCString()

Konvertiert ein Datum in eine Zeichenfolge unter Verwendung der UTC-Zeitzone.

Date.prototype.valueOf()

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

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() weist unerwünschtes, inkonsistentes Verhalten bei zweistelligen Jahreswerten auf; insbesondere, wenn einem new Date()-Aufruf ein zweistelliger Jahreswert gegeben wird, wird dieser Jahreswert nicht als wörtliches Jahr behandelt und verwendet, wie er ist, sondern wird stattdessen als relativer Offset interpretiert — in einigen Fällen als ein Offset vom Jahr 1900, in anderen Fällen als ein 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 zu erhalten, verwenden Sie stattdessen die bevorzugten setFullYear() und getFullYear() Methoden:

// 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 der verstrichene Zeitraum zwischen zwei JavaScript-Daten in Millisekunden bestimmt werden kann.

Aufgrund der unterschiedlichen Längen von Tagen (aufgrund der Umstellung auf Sommerzeit), Monaten und Jahren erfordert die Darstellung von verstrichener 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 einen ganzzahligen Wert zurückzugeben — eine einfache Division reicht hier nicht aus. Es ist auch wichtig, nur tatsächlich verstrichene Sekunden zurückzugeben. (Deshalb verwendet dieser Code Math.floor() und nicht Math.round().)

• Date()