Kapitel 20. Datum

Der Date-Konstruktor von JavaScript hilft beim Parsen, Verwalten und Anzeigen von Daten. Dieses Kapitel beschreibt, wie er funktioniert.

Die Datum-API verwendet den Begriff UTC (Coordinated Universal Time). Für die meisten Zwecke ist UTC ein Synonym für GMT (Greenwich Mean Time) und bedeutet ungefähr die Zeitzone von London, UK.

Der Date-Konstruktor

Es gibt vier Möglichkeiten, den Konstruktor von Date aufzurufen:

new Date(year, month, date?, hours?, minutes?, seconds?, milliseconds?)

Konstruiert ein neues Datum aus den angegebenen Daten. Die Zeit wird relativ zur aktuellen Zeitzone interpretiert. Date.UTC() bietet eine ähnliche Funktionalität, jedoch relativ zu UTC. Die Parameter haben die folgenden Bereiche:

year: Für 0 ≤ year ≤ 99 wird 1900 addiert.
month: 0–11 (0 ist Januar, 1 ist Februar usw.)
date: 1–31
hours: 0–23
minutes: 0–59
seconds: 0–59
milliseconds: 0–999

Hier sind einige Beispiele

> new Date(2001, 1, 27, 14, 55)
Date {Tue Feb 27 2001 14:55:00 GMT+0100 (CET)}
> new Date(01, 1, 27, 14, 55)
Date {Wed Feb 27 1901 14:55:00 GMT+0100 (CET)}

Am Rande sei angemerkt, dass JavaScript die leicht eigenartige Konvention geerbt hat, 0 als Januar, 1 als Februar usw. zu interpretieren, von Java.

new Date(dateTimeStr)

Dies ist ein Datums-Zeit-String, der in eine Zahl umgewandelt wird, mit der new Date(number) aufgerufen wird. Datums-Zeit-Formate erklärt die Datums-Zeit-Formate. Zum Beispiel:

> new Date('2004-08-29')
Date {Sun Aug 29 2004 02:00:00 GMT+0200 (CEST)}

Ungültige Datums-Zeit-Strings führen dazu, dass NaN an new Date(number) übergeben wird.

new Date(timeValue)

Erstellt ein Datum, das in der Anzahl der Millisekunden seit dem 1. Januar 1970 00:00:00 UTC angegeben ist. Zum Beispiel:

> new Date(0)
Date {Thu Jan 01 1970 01:00:00 GMT+0100 (CET)}

Die Umkehrung dieses Konstruktors ist die Methode getTime(), die die Millisekunden zurückgibt.

> new Date(123).getTime()
123

Sie können NaN als Argument verwenden, was eine spezielle Instanz von Date erzeugt, ein „ungültiges Datum“.

> var d = new Date(NaN);
> d.toString()
'Invalid Date'
> d.toJSON()
null
> d.getTime()
NaN
> d.getYear()
NaN

new Date()

Erstellt ein Objekt für das aktuelle Datum und die aktuelle Uhrzeit; es funktioniert genauso wie new Date(Date.now()).

Date-Konstruktor-Methoden

Der Konstruktor Date hat die folgenden Methoden:

Date.now()

Gibt das aktuelle Datum und die aktuelle Uhrzeit in Millisekunden zurück (seit dem 1. Januar 1970, 00:00:00 UTC). Er liefert dasselbe Ergebnis wie new Date().getTime().

Date.parse(dateTimeString)

Konvertiert dateTimeString in Millisekunden seit dem 1. Januar 1970, 00:00:00 UTC. Datums-Zeit-Formate erklärt das Format von dateTimeString. Das Ergebnis kann verwendet werden, um new Date(number) aufzurufen. Hier sind einige Beispiele:

> Date.parse('1970-01-01')
0
> Date.parse('1970-01-02')
86400000

Wenn eine Zeichenkette nicht geparst werden kann, gibt diese Methode NaN zurück.

> Date.parse('abc')
NaN

Date.UTC(year, month, date?, hours?, minutes?, seconds?, milliseconds?)

Konvertiert die gegebenen Daten in Millisekunden seit dem 1. Januar 1970 00:00:00 UTC. Sie unterscheidet sich vom Date-Konstruktor mit denselben Argumenten in zweierlei Hinsicht:

Sie gibt eine Zahl und kein neues Datumsobjekt zurück.
Sie interpretiert die Argumente als UTC und nicht als lokale Zeit.

Date-Prototyp-Methoden

Dieser Abschnitt behandelt die Methoden von Date.prototype.

Zeit-Einheit-Getter und -Setter

Zeit-Einheit- Getter und Setter sind mit den folgenden Signaturen verfügbar:

Lokale Zeit
- Date.prototype.get«Unit»() gibt Unit gemäß lokaler Zeit zurück.
- Date.prototype.set«Unit»(number) setzt Unit gemäß lokaler Zeit.
Universelle Zeit
- Date.prototype.getUTC«Unit»() gibt Unit gemäß universeller Zeit zurück.
- Date.prototype.setUTC«Unit»(number) setzt Unit gemäß universeller Zeit.

Unit ist eines der folgenden Wörter:

FullYear: Normalerweise vier Ziffern
Month: Monat (0–11)
Date: Tag des Monats (1–31)
Day (nur Getter): Tag der Woche (0–6); 0 ist Sonntag
Hours: Stunde (0–23)
Minutes: Minuten (0–59)
Seconds: Sekunden (0–59)
Milliseconds: Millisekunden (0–999)

Zum Beispiel

> var d = new Date('1968-11-25');
Date {Mon Nov 25 1968 01:00:00 GMT+0100 (CET)}
> d.getDate()
25
> d.getDay()
1

Verschiedene Getter und Setter

Die folgenden Methoden ermöglichen es Ihnen, die Zeit in Millisekunden seit dem 1. Januar 1970 abzurufen und festzulegen und mehr:

Date.prototype.getTime() gibt die Millisekunden seit dem 1. Januar 1970 00:00:00 UTC zurück (siehe Zeitwerte: Daten als Millisekunden seit 1970-01-01).
Date.prototype.setTime(timeValue) setzt das Datum, wie in Millisekunden seit dem 1. Januar 1970 00:00:00 UTC angegeben (siehe Zeitwerte: Daten als Millisekunden seit 1970-01-01).
Date.prototype.valueOf() ist dasselbe wie getTime(). Diese Methode wird aufgerufen, wenn ein Datum in eine Zahl konvertiert wird.
Date.prototype.getTimezoneOffset() gibt die Differenz zwischen lokaler Zeit und UTC-Zeit in Minuten zurück.

Die Einheit Year wurde zugunsten von FullYear als veraltet eingestuft.

Date.prototype.getYear() ist veraltet; verwenden Sie stattdessen getFullYear().
Date.prototype.setYear(number) ist veraltet; verwenden Sie stattdessen setFullYear().

Datum in eine Zeichenkette konvertieren

Beachten Sie, dass die Konvertierung in eine Zeichenkette stark implementierungsabhängig ist. Das folgende Datum wird verwendet, um die Ausgabe in den folgenden Beispielen zu berechnen (in Firefox, das die vollständigste Unterstützung hatte, als dieses Buch geschrieben wurde):

new Date(2001,9,30, 17,43,7, 856);

Zeit (menschenlesbar)

Date.prototype.toTimeString():
```
17:43:07 GMT+0100 (CET)
```
Die Zeit in der aktuellen Zeitzone.
Date.prototype.toLocaleTimeString():
```
17:43:07
```
Die Zeit in einem gebietsschema-spezifischen Format. Diese Methode wird von der ECMAScript Internationalization API bereitgestellt (siehe Die ECMAScript Internationalization API) und ergibt ohne diese nicht viel Sinn.

Datum (menschenlesbar)

Date.prototype.toDateString():
```
Tue Oct 30 2001
```
Das Datum.
Date.prototype.toLocaleDateString():
```
10/30/2001
```
Das Datum in einem gebietsschema-spezifischen Format. Diese Methode wird von der ECMAScript Internationalization API bereitgestellt (siehe Die ECMAScript Internationalization API) und ergibt ohne diese nicht viel Sinn.

Datum und Uhrzeit (menschenlesbar)

Date.prototype.toString():
```
Tue Oct 30 2001 17:43:07 GMT+0100 (CET)
```
Datum und Uhrzeit in der aktuellen Zeitzone. Für jede Date-Instanz, die keine Millisekunden hat (d.h. die Sekunde ist voll), ist der folgende Ausdruck wahr:
```
Date.parse(d.toString()) === d.valueOf()
```
Date.prototype.toLocaleString():
```
Tue Oct 30 17:43:07 2001
```
Datum und Uhrzeit in einem gebietsschema-spezifischen Format. Diese Methode wird von der ECMAScript Internationalization API bereitgestellt (siehe Die ECMAScript Internationalization API) und ergibt ohne diese nicht viel Sinn.
Date.prototype.toUTCString():
```
Tue, 30 Oct 2001 16:43:07 GMT
```
Datum und Uhrzeit in UTC.
Date.prototype.toGMTString():
Veraltet; verwenden Sie stattdessen toUTCString().

Datum und Uhrzeit (maschinenlesbar)

Date.prototype.toISOString():
```
2001-10-30T16:43:07.856Z
```
Alle internen Eigenschaften werden in der zurückgegebenen Zeichenkette angezeigt. Das Format entspricht Datums-Zeit-Formate; die Zeitzone ist immer Z.
Date.prototype.toJSON():
Diese Methode ruft intern toISOString() auf. Sie wird von JSON.stringify() verwendet (siehe JSON.stringify(value, replacer?, space?)), um Datumsobjekte in JSON-Zeichenketten zu konvertieren.

Datums-Zeit-Formate

Dieser Abschnitt beschreibt Formate für die Angabe von Zeitpunkten als Zeichenketten. Es gibt viele Möglichkeiten, dies zu tun: nur das Datum angeben, eine Tageszeit einschließen, die Zeitzone weglassen, die Zeitzone angeben und mehr. Bei der Unterstützung von Datums-Zeit-Formaten folgt ECMAScript 5 eng dem Standard ISO 8601 Extended Format. JavaScript-Engines implementieren die ECMAScript-Spezifikation relativ vollständig, aber es gibt immer noch einige Abweichungen, daher müssen Sie wachsam sein.

Das längste Datums-Zeit-Format ist

YYYY-MM-DDTHH:mm:ss.sssZ

Jeder Teil steht für mehrere Dezimalziffern von Datums-Zeit-Daten. Zum Beispiel bedeutet YYYY, dass das Format mit einem vierstelligen Jahr beginnt. Die folgenden Unterabschnitte erklären, was jeder Teil bedeutet. Formate sind relevant für die folgenden Methoden:

Date.parse() kann die Formate parsen.
new Date() kann die Formate parsen.
Date.prototype.toISOString() erstellt eine Zeichenkette im oben genannten „vollständigen“ Format.
```
> new Date().toISOString()
'2014-09-12T23:05:07.414Z'
```

Datumsformate (keine Uhrzeit)

Die folgenden Datumsformate sind verfügbar:

YYYY-MM-DD
YYYY-MM
YYYY

Sie umfassen die folgenden Teile:

YYYY bezieht sich auf das Jahr (gregorianischer Kalender).
MM bezieht sich auf den Monat, von 01 bis 12.
DD bezieht sich auf den Tag, von 01 bis 31.

Zum Beispiel

> new Date('2001-02-22')
Date {Thu Feb 22 2001 01:00:00 GMT+0100 (CET)}

Zeitformate (kein Datum)

Die folgenden Zeitformate sind verfügbar. Wie Sie sehen können, ist die Zeitzoneninformation Z optional:

THH:mm:ss.sss
THH:mm:ss.sssZ

THH:mm:ss
THH:mm:ssZ

THH:mm
THH:mmZ

Sie umfassen die folgenden Teile:

T ist das Präfix des Zeitteils eines Formats (ein literales T, keine Ziffer).
HH bezieht sich auf die Stunde, von 00 bis 23. Sie können 24 als Wert für HH verwenden (was sich auf Stunde 00 des folgenden Tages bezieht), aber dann müssen alle verbleibenden Teile 0 sein.
mm gibt die Minute an, von 00 bis 59.
ss gibt die Sekunde an, von 00 bis 59.
sss gibt die Millisekunde an, von 000 bis 999.
Z bezieht sich auf die Zeitzone, eine der folgenden beiden:
- „Z“ für UTC
- „+“ oder „-“ gefolgt von einer Zeit „hh:mm“

Einige JavaScript-Engines erlauben die Angabe nur einer Zeit (andere erfordern ein Datum).

> new Date('T13:17')
Date {Thu Jan 01 1970 13:17:00 GMT+0100 (CET)}

Datums-Zeit-Formate

Datumsformate und Zeitformate können auch kombiniert werden. In Datums-Zeit-Formaten können Sie ein Datum oder ein Datum und eine Uhrzeit (oder in einigen Engines nur die Uhrzeit) verwenden. Zum Beispiel:

> new Date('2001-02-22T13:17')
Date {Thu Feb 22 2001 13:17:00 GMT+0100 (CET)}

Zeitwerte: Daten als Millisekunden seit 1970-01-01

Was die Datum-API als time bezeichnet, wird von der ECMAScript-Spezifikation als time value bezeichnet. Es ist eine primitive Zahl, die ein Datum als Millisekunden seit dem 1. Januar 1970 00:00:00 UTC kodiert. Jedes Datumsobjekt speichert seinen Zustand als Zeitwert im internen Property [[PrimitiveValue]] (dasselbe Property, das Instanzen der Wrapper-Konstruktoren Boolean, Number und String zum Speichern ihrer eingewickelten primitiven Werte verwenden).

Warnung

Schaltsekunden werden in Zeitwerten ignoriert.

Die folgenden Methoden arbeiten mit Zeitwerten:

new Date(timeValue) verwendet einen Zeitwert, um ein Datum zu erstellen.
Date.parse(dateTimeString) parst eine Zeichenkette mit einer Datums-Zeit-Zeichenkette und gibt einen Zeitwert zurück.
Date.now() gibt das aktuelle Datum und die aktuelle Uhrzeit als Zeitwert zurück.
Date.UTC(year, month, date?, hours?, minutes?, seconds?, milliseconds?) interpretiert die Parameter relativ zu UTC und gibt einen Zeitwert zurück.
Date.prototype.getTime() gibt den im Empfänger gespeicherten Zeitwert zurück.
Date.prototype.setTime(timeValue) ändert das Datum, wie es über einen Zeitwert angegeben ist.
Date.prototype.valueOf() gibt den im Empfänger gespeicherten Zeitwert zurück. Diese Methode bestimmt, wie Daten in Primitive konvertiert werden, wie im nächsten Unterabschnitt erklärt.

Der Bereich der JavaScript-Integer (53 Bits plus Vorzeichen) ist groß genug, dass ein Zeitspanne dargestellt werden kann, die etwa 285.616 Jahre vor 1970 beginnt und etwa 285.616 Jahre nach 1970 endet.

Hier sind einige Beispiele für die Konvertierung von Daten in Zeitwerte:

> new Date('1970-01-01').getTime()
0
> new Date('1970-01-02').getTime()
86400000
> new Date('1960-01-02').getTime()
-315532800000

Der Date-Konstruktor ermöglicht die Konvertierung von Zeitwerten in Daten.

> new Date(0)
Date {Thu Jan 01 1970 01:00:00 GMT+0100 (CET)}
> new Date(24 * 60 * 60 * 1000)  // 1 day in ms
Date {Fri Jan 02 1970 01:00:00 GMT+0100 (CET)}
> new Date(-315532800000)
Date {Sat Jan 02 1960 01:00:00 GMT+0100 (CET)}

Datum in eine Zahl konvertieren

Ein Datum wird über Date.prototype.valueOf() in eine Zahl konvertiert, die einen Zeitwert zurückgibt. Dies ermöglicht Ihnen den Vergleich von Daten:

> new Date('1980-05-21') > new Date('1980-05-20')
true

Sie können auch Arithmetik durchführen, aber Vorsicht: Schaltsekunden werden ignoriert.

> new Date('1980-05-21') - new Date('1980-05-20')
86400000

Warnung

Die Verwendung des Plus-Operators (+), um ein Datum zu einem anderen Datum oder einer Zahl zu addieren, ergibt eine Zeichenkette, da die Standardkonvertierung in primitive Werte dazu führt, dass Daten in Zeichenketten konvertiert werden (siehe Der Plus-Operator (+) für eine Erklärung, wie der Plus-Operator funktioniert).

> new Date('2024-10-03') + 86400000
'Thu Oct 03 2024 02:00:00 GMT+0200 (CEST)86400000'
> new Date(Number(new Date('2024-10-03')) + 86400000)
Fri Oct 04 2024 02:00:00 GMT+0200 (CEST)

Weiter: 21. Math