Datum

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

Der maximale Zeitstempel, der durch ein 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 ein Maximum von ±8.640.000.000.000.000 Millisekunden oder ±100.000.000 (einhundert Millionen) Tage relativ zur Epoche repräsentieren. 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 in der Datumsangabe gespeicherten Zeitstempel zu interagieren:

• Sie können direkt mit dem Zeitstempelwert unter Verwendung der Methoden getTime() und setTime() interagieren.
• Die Methoden valueOf() und [Symbol.toPrimitive]() (wenn "number" übergeben wird) — die automatisch bei Zahlentyp-Umwandlung aufgerufen werden — geben den Zeitstempel zurück, wodurch Date-Objekte sich wie ihre Zeitstempel verhalten, wenn sie in Zahl-Kontexten 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 einzige Zahl, der Zeitstempel, dargestellt. Bei der Interaktion mit ihm muss der Zeitstempel als strukturierte Datums- und Zeitdarstellung interpretiert werden. Es gibt immer zwei Möglichkeiten, einen Zeitstempel zu interpretieren: als Lokalzeit oder als Koordinierte Weltzeit (UTC), die globale Standardzeit, die von der Weltzeitnorm definiert ist. Die lokale Zeitzone ist im Datumsobjekt nicht gespeichert, sondern wird von der Host-Umgebung (dem Gerät des Benutzers) bestimmt.

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

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

Die Methode getTimezoneOffset() gibt den Unterschied zwischen UTC und der Lokalzeit in Minuten zurück. Beachten Sie, dass der Zeitzonenoffset nicht nur von der aktuellen Zeitzone abhängt, sondern auch von der Zeit, die durch das Date-Objekt darstellt wird, aufgrund der Sommerzeit und historischer Änderungen. Im Wesentlichen ist der Zeitzonenoffset die Abweichung von der UTC-Zeit zu der durch das Date-Objekt darstellten Zeit und der Position der Host-Umgebung.

Es gibt zwei Gruppen von Date-Methoden: Eine Gruppe liest und setzt verschiedene Datumskomponenten, indem der Zeitstempel als Lokalzeit 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 in Lokalzeit interpretiert. Date.UTC() funktioniert ähnlich, interpretiert aber die Komponenten als UTC-Zeit und akzeptiert auch ein einziges Argument, das das Jahr darstellt.

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

Es gibt viele Möglichkeiten, ein Datum als String zu formatieren. Die JavaScript-Spezifikation gibt nur ein Format an, das universell unterstützt wird: das Datum-Zeit-String-Format, eine Vereinfachung des ISO 8601-Kalenderdatums-Erweiterungsformats. Das Format lautet wie folgt:

YYYY-MM-DDTHH:mm:ss.sssZ

• YYYY ist das Jahr, mit vier Ziffern (0000 bis 9999), oder als erweitertes Jahr mit + 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). Standardmäßig 01.
• DD ist der Tag des Monats, mit zwei Ziffern (01 bis 31). Standardmäßig 01.
• T ist ein literales Zeichen, das den Beginn des Zeit-Teils des Strings 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 zu Beginn des nächsten Tages interpretiert. Standardmäßig 00.
• mm ist die Minute, mit zwei Ziffern (00 bis 59). Standardmäßig 00.
• ss ist die Sekunde, mit zwei Ziffern (00 bis 59). Standardmäßig 00.
• sss ist die Millisekunde, mit drei Ziffern (000 bis 999). Standardmäßig 000.
• Z ist der Zeitzonenoffset, der entweder das literale Zeichen Z (indiziert UTC) sein kann oder + oder - gefolgt von HH:mm, der Abweichung in Stunden und Minuten von UTC.

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

• Nur-Datum-Form: YYYY, YYYY-MM, YYYY-MM-DD
• Datum-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 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 Lokalzeit interpretiert. Die Interpretation als UTC-Zeit ist auf einen historischen Spezifikationsfehler zurückzuführen, der nicht mit ISO 8601 konsistent war, aber aufgrund der Webkompatibilität nicht geändert werden konnte. Siehe Broken Parser – A Web Reality Issue.

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 Zeichenfolgenrepräsentation des Datums im Datum-Zeit-String-Format zurück, wobei der Zeitzonenoffset immer auf Z (UTC) gesetzt ist.

Nicht-standardisierte Zeichenfolgen können nach Belieben von der Implementierung analysiert werden, einschließlich der Zeitzone — die meisten Implementierungen verwenden standardmäßig die lokale Zeitzone. Implementierungen sind nicht verpflichtet, für nicht im Bereich befindliche Datumsbestandteile ein ungültiges Datum zurückzugeben, obwohl sie das normalerweise tun. Eine Zeichenfolge kann aus Bestandteilen innerhalb des Bereichs bestehen (mit den oben definierten Grenzen), aber 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 einen String im Format 1970-01-01T00:00:00.000Z zurück (das oben eingeführte Datum-Zeit-String-Format, das eine vereinfachte 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 Datum- bzw. den Zeitteil des Strings 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 lokalisierungsspezifische Datums- und Zeitformate, die normalerweise 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 er ein neues Date-Objekt zurück. Wenn als Funktion aufgerufen, gibt er eine Zeichenfolgenrepräsentation 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()

Analysiert 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 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 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 anfängliche Wert 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 vierstellige 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 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 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 vierstellige 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 vollständige Jahr (z. B. 4 Ziffern für vierstellige 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 vollständige Jahr (z. B. 4 Ziffern für vierstellige Jahre) für ein angegebenes Datum gemäß der Weltzeit fest.

Date.prototype.setUTCHours()

Legt die Stunde 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"-Abschnitt des Date als einen menschenlesbaren String wie 'Thu Apr 12 2018' zurück.

Date.prototype.toISOString()

Konvertiert ein Datum in eine Stringdarstellung im ISO 8601 erweiterten Format.

Date.prototype.toJSON()

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

Date.prototype.toLocaleDateString()

Gibt eine Zeichenfolge mit einer lokalitätsempfindlichen Darstellung des Datumsabschnitts dieses Datums basierend auf Systemeinstellungen zurück.

Date.prototype.toLocaleString()

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

Date.prototype.toLocaleTimeString()

Gibt eine Zeichenfolge mit einer lokalitätsempfindlichen Darstellung des Zeitabschnitts dieses Datums basierend auf Systemeinstellungen zurück.

Date.prototype.toString()

Gibt eine Zeichenfolgenrepräsentation des angegebenen Date-Objekts zurück. Überschreibt die Methode Object.prototype.toString().

Date.prototype.toTemporalInstant() Experimentell

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

Date.prototype.toTimeString()

Gibt den "Zeit"-Abschnitt des Date als einen menschenlesbaren String 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 Methode Object.prototype.valueOf().

Date.prototype[Symbol.toPrimitive]()

Konvertiert dieses Date-Objekt in einen primitiven Wert.

Die folgenden Beispiele zeigen verschiedene Wege, 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ünschtes, inkonsistentes Verhalten mit zweistelligen Jahreswerten; speziell, wenn ein new Date()-Aufruf einen zweistelligen Jahreswert erhält, wird dieser nicht als buchstäbliches Jahr behandelt und wie angegeben verwendet, sondern als relativer Offset interpretiert — in manchen 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 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 ermittelt werden kann.

Aufgrund der unterschiedlichen Längen von Tagen (aufgrund von Zeitumstellungen), Monaten und Jahren erfordert die Angabe verstrichener Zeit in Einheiten größer als Stunden, Minuten und Sekunden die Adressierung zahlreicher Probleme und sollte gründlich erforscht 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 Ganzzahl zurückzugeben, daher reicht eine einfache Division nicht aus. Es ist auch wichtig, nur tatsächlich verstrichene Sekunden zurückzugeben. (Deshalb verwendet dieser Code Math.floor(), und nicht Math.round().)

• Date()