Date

Beschreibung

Die Epoche, Zeitstempel und ungültige Daten

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

Der maximale Zeitstempel, der von einem Date-Objekt darstellbar ist, ist etwas kleiner als die maximale sichere ganze Zahl (Number.MAX_SAFE_INTEGER, also 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 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 Zeitstempel 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 es Ihnen ermöglichen, mit dem im Datum 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 Zahlenumwandlung aufgerufen werden — geben den Zeitstempel zurück, wodurch sich Date-Objekte wie ihre Zeitstempel verhalten, wenn sie in Zahlkontexten verwendet werden.
• Alle statischen Methoden (Date.now(), Date.parse(), und Date.UTC()) geben Zeitstempel anstelle von Date-Objekten zurück.
• Der Date()-Konstruktor kann mit einem Zeitstempel als einzigem Argument aufgerufen werden.

Datumsbestandteile und Zeitzonen

Ein Datum wird intern als eine einzelne Zahl, der Zeitstempel, dargestellt. Beim Umgang damit muss der Zeitstempel als strukturierte Datum-Uhrzeit-Darstellung interpretiert werden. Es gibt immer zwei Möglichkeiten, einen Zeitstempel zu interpretieren: als lokale Zeit oder als Koordinierte Weltzeit (UTC), die globale Standardzeit, die durch den Weltzeitstandard definiert ist. Die lokale Zeitzone wird nicht im Date-Objekt gespeichert, sondern wird durch die Host-Umgebung (das Gerät des Benutzers) bestimmt.

Beispielsweise stellt der Zeitstempel 0 einen einzigartigen Moment in der Geschichte dar, kann aber 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 die Zeitzonenverschiebung nicht nur von der aktuellen Zeitzone abhängt, sondern auch von der durch das Date-Objekt dargestellten Zeit, aufgrund von Sommerzeitumstellungen und historischen Änderungen. Im Wesentlichen ist die Zeitzonenverschiebung die Verschiebung von der UTC-Zeit zum Zeitpunkt, der durch das Date-Objekt und am Standort der Host-Umgebung repräsentiert wird.

Es gibt zwei Gruppen von Date-Methoden: eine Gruppe erhält und setzt verschiedene Datumsbestandteile, 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 in lokaler Zeit. Date.UTC() funktioniert ähnlich, interpretiert die Komponenten jedoch als UTC-Zeit und akzeptiert auch ein einzelnes Argument, das das Jahr darstellt.

Wenn ein Segment seinen erwarteten Bereich über- oder unterschreitet, "trägt es normalerweise zum höherwertigen Segment über" oder "leiht sich davon". Beispielsweise wird, wenn der Monat auf 12 gesetzt wird (Monate sind nullbasiert, daher ist Dezember 11), daraus der Januar des nächsten Jahres. Wenn auf den 0. Tag des Monats gesetzt wird, wird daraus der letzte Tag des vorherigen Monats. Dies gilt auch für Daten, die mit dem Zeitstempelformat angegeben werden.

Wenn versucht wird, die lokale Zeit auf eine Zeit innerhalb einer Verschiebungstransition (normalerweise Sommerzeit) zu setzen, wird die genaue Zeit unter Verwendung des gleichen Verhaltens wie Temporal's disambiguation: "compatible" Option abgeleitet. Das bedeutet, dass, wenn die lokale Zeit zwei Momenten entspricht, der frühere gewählt wird; wenn die lokale Zeit nicht existiert (es gibt eine Lücke), wird die Lückendauer nach vorne gegangen.

// 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)

Zeitstempelformat

Es gibt viele Möglichkeiten, ein Datum als Zeichenkette zu formatieren. Die JavaScript-Spezifikation legt nur ein Format fest, das universell unterstützt wird: das Zeitstempelformat, eine Vereinfachung des ISO 8601-Kalenderdatums im erweiterten Format. 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 mit + oder -, gefolgt von sechs Ziffern. Das Vorzeichen ist für erweiterte Jahre erforderlich. -000000 ist explizit 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 literaler 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 zu 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 die Zeitzonenverschiebung, die entweder der buchstäbliche Charakter Z (anzeigend UTC) oder + oder -, gefolgt von HH:mm, der Verschiebung in Stunden und Minuten von UTC, sein kann.

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

• 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 mit einer Zeitzonenverschiebung folgen.

Beispielsweise 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 Datumzeit-Strings.

Wenn die Zeitzonenverschiebung 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 übereinstimmte, aber aufgrund von Webkompatibilität nicht geändert werden konnte. Siehe Broken Parser – A Web Reality Issue.

Date.parse() und der Date()-Konstruktor akzeptieren beide Zeichenfolgen im Zeitstempelformat als Eingabe. Darüber hinaus können Implementierungen andere Datumsformate unterstützen, wenn die Eingabe diesem Format nicht entspricht.

Die Methode toISOString() gibt eine Zeichenfolgendarstellung des Datums im Zeitstempelformat zurück, wobei die Zeitzonenverschiebung immer auf Z (UTC) gesetzt ist.

Nicht standardisierte Zeichenfolgen können beliebig von der Implementierung geparst werden, einschließlich der Zeitzone — die meisten Implementierungen verwenden standardmäßig die lokale Zeitzone. Implementierungen sind nicht verpflichtet, ungültige Daten für außerhalb der gültigen Bereiche liegende Datumsbestandteile zurückzugeben, obwohl sie dies normalerweise tun. Eine Zeichenfolge kann Datumsbestandteile innerhalb des gültigen Bereichs aufweisen (mit den oben definierten Grenzen), jedoch nicht tatsächlich ein Datum in der Realität darstellen (zum Beispiel "30. Februar"). In solchen Fällen verhalten sich Implementierungen inkonsistent. Die Seite Date.parse() bietet mehr Beispiele zu diesen nicht standardisierten Fällen.

Andere Wege, ein Datum zu formatieren

• toISOString() gibt eine Zeichenkette im Format 1970-01-01T00:00:00.000Z zurück (das oben eingeführte Zeitstempelformat, das eine vereinfachte ISO 8601 darstellt). toJSON() ruft toISOString() auf und gibt das Ergebnis zurück.
• toString() gibt eine Zeichenkette im Format Thu Jan 01 1970 00:00:00 GMT+0000 (Coordinated Universal Time) zurück, während toDateString() und toTimeString() die Datum- bzw. Uhrzeit-Teile der Zeichenkette zurückgeben. [Symbol.toPrimitive]() (wenn "string" oder "default" übergeben wird) ruft toString() auf und gibt das Ergebnis zurück.
• toUTCString() gibt eine Zeichenkette im Format Thu, 01 Jan 1970 00:00:00 GMT zurück (generalisierte RFC 7231).
• toLocaleDateString(), toLocaleTimeString(), und toLocaleString() verwenden ortsspezifische Datums- und Zeitformate, die normalerweise von der Intl API bereitgestellt werden.

Beispielen siehe den Abschnitt Formate der Rückgabewerte der toString-Methode.

Konstruktor

Date()

Bei Aufruf als Konstruktor wird ein neues Date-Objekt zurückgegeben. Bei Aufruf als Funktion wird eine Zeichenfolgendarstellung des aktuellen Datums und der aktuellen Uhrzeit zurückgegeben.

Statische Methoden

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()

Interpretiert eine Zeichenfolgendarstellung 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.

Instanz-Eigenschaften

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

Date.prototype.constructor

Die Konstrukturfunktion, die das Instanzobjekt erstellt hat. Für Date-Instanzen ist der initiale Wert der Date-Konstruktor.

Instanz-Methoden

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 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 die Zeitzonenverschiebung in Minuten für die aktuelle Lokalität 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 ganze 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äß universeller Zeit.

Date.prototype.setUTCFullYear()

Setzt das ganze 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äß lokaler Zeit. Verwenden Sie stattdessen setFullYear().

Date.prototype.toDateString()

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

Date.prototype.toISOString()

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

Date.prototype.toJSON()

Gibt eine Zeichenkette zurück, die das Date unter Verwendung von toISOString() darstellt. Soll implizit durch JSON.stringify() aufgerufen werden.

Date.prototype.toLocaleDateString()

Gibt eine Zeichenkette mit einer ortsspezifischen Repräsentation des Datumsteils dieses Datums basierend auf den Systemeinstellungen zurück.

Date.prototype.toLocaleString()

Gibt eine Zeichenkette mit einer ortsspezifischen Repräsentation dieses Datums zurück. Überschreibt die Methode Object.prototype.toLocaleString().

Date.prototype.toLocaleTimeString()

Gibt eine Zeichenkette mit einer ortsspezifischen Repräsentation des Uhrzeitteils dieses Datums basierend auf den Systemeinstellungen zurück.

Date.prototype.toString()

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

Date.prototype.toTemporalInstant()

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

Date.prototype.toTimeString()

Gibt den "Uhrzeit"-Teil des Date als menschenlesbare Zeichenkette 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.

Beispiele

Mehrere Möglichkeiten, ein Date-Objekt zu erstellen

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

Formate der Rückgabewerte der toString-Methode

const date = new Date("2020-05-12T23:50:21.817Z");
date.toString(); // Tue May 12 2020 18:50:21 GMT-0500 (Central Daylight Time)
date.toDateString(); // Tue May 12 2020
date.toTimeString(); // 18:50:21 GMT-0500 (Central Daylight Time)
date[Symbol.toPrimitive]("string"); // Tue May 12 2020 18:50:21 GMT-0500 (Central Daylight Time)

date.toISOString(); // 2020-05-12T23:50:21.817Z
date.toJSON(); // 2020-05-12T23:50:21.817Z

date.toUTCString(); // Tue, 12 May 2020 23:50:21 GMT

date.toLocaleString(); // 5/12/2020, 6:50:21 PM
date.toLocaleDateString(); // 5/12/2020
date.toLocaleTimeString(); // 6:50:21 PM

So erhalten Sie Datum, Monat und Jahr oder Zeit

const date = new Date("2000-01-17T16:45:30");
const [month, day, year] = [
  date.getMonth(),
  date.getDate(),
  date.getFullYear(),
];
// [0, 17, 2000] as month are 0-indexed
const [hour, minutes, seconds] = [
  date.getHours(),
  date.getMinutes(),
  date.getSeconds(),
];
// [16, 45, 30]

Interpretation von zweistelligen Jahreszahlen

new Date() zeigt ein veraltetes, unerwünschtes und inkonsistentes Verhalten mit zweistelligen Jahreszahlen; insbesondere wird, wenn ein new Date()-Aufruf mit einem zweistelligen Jahrwert erfolgt, dieser Jahrwert nicht als wörtliches Jahr verwendet, sondern 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)

Berechnung der verstrichenen Zeit

Die folgenden Beispiele zeigen, wie man die verstrichene Zeit zwischen zwei JavaScript-Daten in Millisekunden bestimmt.

Aufgrund der unterschiedlichen Längen von Tagen (durch Sommerzeitumstellung), Monaten und Jahren erfordert die Angabe der verstrichenen Zeit in Einheiten größer als Stunden, Minuten und Sekunden die Berücksichtigung vieler Faktoren 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);

Erhalten Sie die Anzahl der Sekunden seit der ECMAScript-Epoche

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

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

Spezifikationen

Browser-Kompatibilität

Siehe auch

• Date()