Date

Ein JavaScript-Datum wird grundsätzlich als die Zeit in Millisekunden angegeben, die seit der Epoche vergangen ist, die als Mitternacht des 1. Januar 1970, UTC (gleichwertig zur UNIX-Epoche) definiert ist. Dieser Zeitstempel ist zeitzonenunabhängig und definiert einen einmaligen Moment in der Geschichte.

Der maximale Zeitstempel, der von einem Date-Objekt dargestellt werden kann, ist etwas kleiner als die maximale sichere Ganzzahl (Number.MAX_SAFE_INTEGER, was 9.007.199.254.740.991 ist). Ein Date-Objekt kann maximal ±8.640.000.000.000.000 Millisekunden oder ±100.000.000 (einhundert 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 "Invalid Date" (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 ermöglichen, mit dem im Datum gespeicherten Zeitstempel zu interagieren:

• 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 Zahlenerzwung aufgerufen werden — geben den Zeitstempel zurück und lassen Date-Objekte sich in Zahlkontexten wie ihre Zeitstempel 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 einziges Argument aufgerufen werden.

Ein Datum wird intern als eine einzelne Zahl, der Zeitstempel, dargestellt. Wenn Sie mit ihm interagieren, muss der Zeitstempel als eine strukturierte Datum-und-Uhrzeit-Darstellung interpretiert werden. Es gibt immer zwei Wege, einen Zeitstempel zu interpretieren: als Ortszeit oder als koordinierte Weltzeit (UTC), der globale Standardzeit, definiert durch den internationalen Weltzeitstandard. Die lokale Zeitzone wird nicht im Datumsobjekt gespeichert, sondern vom Hostumfeld (Gerät des Benutzers) bestimmt.

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

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

Die Methode getTimezoneOffset() gibt den Unterschied zwischen UTC und der Ortszeit in Minuten zurück. Beachten Sie, dass der Zeitzonenversatz nicht nur von der aktuellen Zeitzone, sondern auch von der durch das Date-Objekt repräsentierten Zeit abhängt, wegen der Sommerzeit und historischer Änderungen. Im Wesentlichen ist der Zeitzonenversatz der Versatz von UTC zum Zeitpunkt, der durch das Date-Objekt repräsentiert wird, und am Standort des Hostumfelds.

Es gibt zwei Gruppen von Date-Methoden: eine Gruppe erhält und setzt verschiedene Datumsbestandteile, indem der Zeitstempel als Ortszeit interpretiert wird, während die andere UTC verwendet.

Der Date()-Konstruktor kann mit zwei oder mehr Argumenten aufgerufen werden. In diesem Fall werden sie als Jahr, Monat, Tag, Stunde, Minute, Sekunde und Millisekunde interpretiert, jeweils in Ortszeit. Date.UTC() funktioniert ähnlich, interpretiert die Komponenten jedoch als UTC-Zeit und akzeptiert auch ein einziges Argument, das das Jahr darstellt.

Wenn ein Segment seinen erwarteten Bereich über- oder unterschreitet, "trägt es in der Regel über" oder "leiht es von" dem höheren Segment. Zum Beispiel, wenn der Monat auf 12 gesetzt wird (Monate sind nullbasiert, also ist Dezember 11), wird er zum Januar des nächsten Jahres. Wenn der Tag des Monats auf 0 gesetzt wird, wird er zum letzten Tag des vorherigen Monats. Dies gilt auch für Daten, die mit dem Datumszeitzeichenfolgenformat angegeben werden.

Beim Versuch, die Ortszeit auf eine Zeit innerhalb eines Versatzübergangs (in der Regel Sommerzeit) einzustellen, wird die genaue Zeit mithilfe des gleichen Verhaltens wie bei Temporal's disambiguation: "compatible" Option bestimmt. Das heißt, wenn die Ortszeit zwei Zeitpunkten entspricht, wird der frühere gewählt; wenn die Ortszeit nicht existiert (es gibt eine Lücke), gehen wir um die Dauer der Lücke weiter.

// Assume America/New_York local time zone
// 2024-03-10 02:30 is within the spring-forward transition and does not exist
// 01:59 (UTC-5) jumps to 03:00 (UTC-4), so 02:30 moves forward by one hour
console.log(new Date(2024, 2, 10, 2, 30).toString());
// Sun Mar 10 2024 03:30:00 GMT-0400 (Eastern Daylight Time)

// 2024-11-03 01:30 is within the fall-back transition and exists twice
// 01:59 (UTC-4) jumps to 01:00 (UTC-5), so the earlier 01:30 (UTC-4) is chosen
console.log(new Date(2024, 10, 3, 1, 30).toString());
// Sun Nov 03 2024 01:30:00 GMT-0400 (Eastern Daylight Time)

Es gibt viele Möglichkeiten, ein Datum als Zeichenfolge zu formatieren. Die JavaScript-Spezifikation legt nur ein Format fest, das universell unterstützt wird: das Datumszeit-Zeichenfolgenformat, eine Vereinfachung des erweiterten ISO 8601-Kalenderdatumsformats. Das Format ist wie folgt:

YYYY-MM-DDTHH:mm:ss.sssZ

• YYYY ist das Jahr, mit vier Ziffern (0000 bis 9999), oder als ein erweitertes Jahr von + oder - gefolgt von sechs Ziffern. Das Zeichen 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örtlicher Charakter, der den Beginn des _Zeit-_Teils der Zeichenfolge anzeigt. Das T ist erforderlich, wenn der Zeitteil angegeben wird.
• HH ist die Stunde, mit zwei Ziffern (00 bis 23). Als Sonderfall ist 24:00:00 erlaubt und wird als Mitternacht am Beginn des nächsten Tages interpretiert. 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 Zeitzonenversatz, der entweder der wörtliche Charakter Z (der UTC anzeigt) oder + oder - gefolgt von HH:mm sein kann, der Versatz in Stunden und Minuten von UTC.

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

• Nur-Datum-Form: YYYY, YYYY-MM, YYYY-MM-DD
• Datumszeit-Form: eine der oben genannten Nur-Datumsformen, gefolgt von T, gefolgt von HH:mm, HH:mm:ss oder HH:mm:ss.sss. Jede Kombination kann von einem Zeitzonenversatz gefolgt werden.

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

Wenn der Zeitzonenversatz fehlt, werden Nur-Datum-Formen als UTC-Zeit und Datumszeit-Formen als Ortszeit 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 Defekter Parser – Ein Web-Realitäts-Problem.

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

Die Methode toISOString() gibt eine Zeichenfolgenrepräsentation des Datums im Datumszeit-Zeichenfolgenformat zurück, wobei der Zeitzonenversatz immer auf Z (UTC) gesetzt ist.

Nicht standardmäßige Zeichenfolgen können in jeder gewünschten Weise von der Implementierung geparst werden, einschließlich der Zeitzone — die meisten Implementierungen verwenden standardmäßig die lokale Zeitzone. Implementierungen sind nicht verpflichtet, ein ungültiges Datum für Positionen außerhalb der Grenzen zurückzugeben, auch wenn sie dies normalerweise tun. Eine Zeichenfolge kann Positionen innerhalb der Grenzen haben (mit den oben definierten Grenzen), aber keinen tatsächlichen realen Tag darstellen (zum Beispiel "Februar 30"). Implementierungen verhalten sich in diesem Fall inkonsistent. Die Seite Date.parse() bietet weitere Beispiele zu diesen nicht-standardmäßigen Fällen.

• toISOString() gibt eine Zeichenfolge im Format 1970-01-01T00:00:00.000Z zurück (das oben eingeführte Datumszeit-Zeichenfolgenformat, 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() den Datums- bzw. den Zeitteil 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 (verallgemeinertes RFC 7231).
• toLocaleDateString(), toLocaleTimeString(), und toLocaleString() verwenden lokalspezifische Datums- und Zeitformate, die in der Regel von der Intl-API bereitgestellt werden.

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

Date()

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

Date.now()

Gibt den Zahlenwert 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 Zeichenfolgenrepräsentation eines Datums und gibt die Anzahl der Millisekunden seit dem 1. Januar 1970 00:00:00 UTC zurück, wobei Schaltsekunden ignoriert werden.

Date.UTC()

Akzeptiert dieselben 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 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 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äß 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 Zahlenwert des angegebenen Datums als die Anzahl der Millisekunden seit dem 1. Januar 1970 00:00:00 UTC zurück. (Für frühere Zeiten werden negative Werte zurückgegeben.)

Date.prototype.getTimezoneOffset()

Gibt den Zeitzonenversatz in Minuten für das aktuelle Gebietsschema zurück.

Date.prototype.getUTCDate()

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

Date.prototype.getUTCDay()

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

Date.prototype.getUTCFullYear()

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

Date.prototype.getUTCHours()

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

Date.prototype.getUTCMilliseconds()

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

Date.prototype.getUTCMinutes()

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

Date.prototype.getUTCMonth()

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

Date.prototype.getUTCSeconds()

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

Date.prototype.getYear() Veraltet

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

Date.prototype.setDate()

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

Date.prototype.setFullYear()

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

Date.prototype.setHours()

Legt die Stunden für ein angegebenes Datum gemäß der lokalen Zeit fest.

Date.prototype.setMilliseconds()

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

Date.prototype.setMinutes()

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

Date.prototype.setMonth()

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

Date.prototype.setSeconds()

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

Date.prototype.setTime()

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

Date.prototype.setUTCDate()

Legt den Tag des Monats für ein angegebenes Datum gemäß der Weltzeit fest.

Date.prototype.setUTCFullYear()

Legt das volle Jahr (z. B. 4 Ziffern für 4-stellige Jahre) für ein angegebenes Datum gemäß der Weltzeit fest.

Date.prototype.setUTCHours()

Legt die Stunden für ein angegebenes Datum gemäß der Weltzeit fest.

Date.prototype.setUTCMilliseconds()

Legt die Millisekunden für ein angegebenes Datum gemäß der Weltzeit fest.

Date.prototype.setUTCMinutes()

Legt die Minuten für ein angegebenes Datum gemäß der Weltzeit fest.

Date.prototype.setUTCMonth()

Legt den Monat für ein angegebenes Datum gemäß der Weltzeit fest.

Date.prototype.setUTCSeconds()

Legt die Sekunden für ein angegebenes Datum gemäß der Weltzeit fest.

Date.prototype.setYear() Veraltet

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

Date.prototype.toDateString()

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

Date.prototype.toISOString()

Konvertiert ein Datum in eine Zeichenfolge gemäß dem ISO 8601-Erweiterten Format.

Date.prototype.toJSON()

Gibt eine Zeichenfolge zurück, die das Date mit toISOString() darstellt. Soll implizit von JSON.stringify() aufgerufen werden.

Date.prototype.toLocaleDateString()

Gibt eine Zeichenfolge mit einer gebietsschemasensitiven Darstellung des Datumsbereichs dieses Datums basierend auf Systemeinstellungen zurück.

Date.prototype.toLocaleString()

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

Date.prototype.toLocaleTimeString()

Gibt eine Zeichenfolge mit einer gebietsschemasensitiven Darstellung des Zeitbereichs dieses Datums basierend auf Systemeinstellungen zurück.

Date.prototype.toString()

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

Date.prototype.toTemporalInstant() Experimentell

Gibt ein neues Temporal.Instant-Objekt mit dem gleichen epochMilliseconds-Wert wie der Zeitstempel dieses Datums zurück.

Date.prototype.toTimeString()

Gibt den "Zeit"-Teil des Date als eine 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 mehrere 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 ein unerwünschtes, inkonsistentes Verhalten mit zweistelligen Jahreswerten; insbesondere, wenn einem Aufruf von new Date() ein zweistelliger Jahreswert übergeben wird, wird dieser Jahreswert nicht als wörtliches Jahr und verwendet wie eingegeben behandelt, sondern stattdessen als relativer Versatz interpretiert — in einigen Fällen als Versatz vom Jahr 1900, aber in anderen Fällen als Versatz 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 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 wird.

Aufgrund der unterschiedlichen Längen von Tagen (aufgrund der Sommerzeitumstellung), Monaten und Jahren erfordert die Ausdruck der verstrichenen Zeit in Einheiten größer als Stunden, Minuten und Sekunden die Behandlung 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 — daher ist eine einfache Division nicht ausreichend. Es ist auch wichtig, nur tatsächlich verstrichene Sekunden zurückzugeben. (Deshalb verwendet dieser Code Math.floor(), und nicht Math.round().)

• Date()