diff --git a/1-js/05-data-types/11-date/1-new-date/solution.md b/1-js/05-data-types/11-date/1-new-date/solution.md
index 18286c336..817f011f9 100644
--- a/1-js/05-data-types/11-date/1-new-date/solution.md
+++ b/1-js/05-data-types/11-date/1-new-date/solution.md
@@ -1,18 +1,18 @@
-The `new Date` constructor uses the local time zone. So the only important thing to remember is that months start from zero.
+Der `new Date` Konstruktor verwendet die lokale Zeitzone. Das Einzige, woran du dich erinnern musst, ist, dass die Zählung der Monate bei Null beginnt.
 
-So February has number 1.
+Also hat der Februar die Nummer 1.
 
-Here's an example with numbers as date components:
+Hier ist ein Beispiel mit Zahlen als Datumskomponenten:
 
 ```js run
-//new Date(year, month, date, hour, minute, second, millisecond)
+// new Date(Jahr, Monat, Tag, Stunde, Minute, Sekunde, Millisekunde)
 let d1 = new Date(2012, 1, 20, 3, 12);
 alert( d1 );
 ```
-We could also create a date from a string, like this:
+Wir könnten auch ein Datum aus einem String erstellen, so wie hier:
 
 ```js run
-//new Date(datastring)
+//new Date(Datenstring)
 let d2 = new Date("2012-02-20T03:12");
 alert( d2 );
 ```
diff --git a/1-js/05-data-types/11-date/1-new-date/task.md b/1-js/05-data-types/11-date/1-new-date/task.md
index 1b40d5ac0..99b1dc587 100644
--- a/1-js/05-data-types/11-date/1-new-date/task.md
+++ b/1-js/05-data-types/11-date/1-new-date/task.md
@@ -2,8 +2,8 @@ importance: 5
 
 ---
 
-# Create a date
+# Erstelle ein Datum
 
-Create a `Date` object for the date: Feb 20, 2012, 3:12am. The time zone is local.
+Erstelle ein `Date`-Objekt für das Datum: 20. Feb. 2012, 3:12 Uhr morgens. Die Zeitzone ist lokal.
 
-Show it using `alert`.
+Zeige es mit `alert` an.
diff --git a/1-js/05-data-types/11-date/2-get-week-day/solution.md b/1-js/05-data-types/11-date/2-get-week-day/solution.md
index 58d75c1c3..fe8af0dd1 100644
--- a/1-js/05-data-types/11-date/2-get-week-day/solution.md
+++ b/1-js/05-data-types/11-date/2-get-week-day/solution.md
@@ -1,14 +1,14 @@
-The method `date.getDay()` returns the number of the weekday, starting from sunday.
+Die Methode `date.getDay()` gibt die Zahl des Wochentags zurück, beginnend mit Sonntag.
 
-Let's make an array of weekdays, so that we can get the proper day name by its number:
+Lass uns ein Array von Wochentagen erstellen, damit wir den richtigen Namen des Tages anhand seiner Nummer erhalten können:
 
 ```js run demo
 function getWeekDay(date) {
-  let days = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'];
+  let days = ['SO', 'MO', 'DI', 'MI', 'DO', 'FR', 'SA'];
 
   return days[date.getDay()];
 }
 
-let date = new Date(2014, 0, 3); // 3 Jan 2014
+let date = new Date(2014, 0, 3); // 3. Jan 2014
 alert( getWeekDay(date) ); // FR
 ```
diff --git a/1-js/05-data-types/11-date/2-get-week-day/task.md b/1-js/05-data-types/11-date/2-get-week-day/task.md
index 5cf31565d..48b6ece8d 100644
--- a/1-js/05-data-types/11-date/2-get-week-day/task.md
+++ b/1-js/05-data-types/11-date/2-get-week-day/task.md
@@ -2,13 +2,13 @@ importance: 5
 
 ---
 
-# Show a weekday
+# Zeige einen Wochentag
 
-Write a function `getWeekDay(date)` to show the weekday in short format: 'MO', 'TU', 'WE', 'TH', 'FR', 'SA', 'SU'.
+Schreibe eine Funktion `getWeekDay(date)`, um den Wochentag in Kurzform anzuzeigen: 'MO', 'DI', 'MI', 'DO', 'FR', 'SA', 'SO'.
 
-For instance:
+Zum Beispiel:
 
 ```js no-beautify
-let date = new Date(2012, 0, 3);  // 3 Jan 2012
-alert( getWeekDay(date) );        // should output "TU"
+let date = new Date(2012, 0, 3);  // 3. Jan 2012
+alert( getWeekDay(date) );        // sollte "DI" ausgeben
 ```
diff --git a/1-js/05-data-types/11-date/3-weekday/_js.view/solution.js b/1-js/05-data-types/11-date/3-weekday/_js.view/solution.js
index fb9e3d2a4..79ae6250b 100644
--- a/1-js/05-data-types/11-date/3-weekday/_js.view/solution.js
+++ b/1-js/05-data-types/11-date/3-weekday/_js.view/solution.js
@@ -2,7 +2,7 @@ function getLocalDay(date) {
 
   let day = date.getDay();
 
-  if (day == 0) { // weekday 0 (sunday) is 7 in european
+  if (day == 0) { // Wochentag 0 (Sonntag) ist 7 im europäischen Format
     day = 7;
   }
 
diff --git a/1-js/05-data-types/11-date/3-weekday/task.md b/1-js/05-data-types/11-date/3-weekday/task.md
index ba62790cf..87a0421b8 100644
--- a/1-js/05-data-types/11-date/3-weekday/task.md
+++ b/1-js/05-data-types/11-date/3-weekday/task.md
@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# European weekday
+# Europäischer Wochentag
 
-European countries have days of week starting with Monday (number 1), then Tuesday (number 2) and till Sunday (number 7). Write a function `getLocalDay(date)` that returns the "European" day of week for `date`.
+Europäische Länder beginnen die Woche mit Montag (Nummer 1), gefolgt von Dienstag (Nummer 2) bis hin zum Sonntag (Nummer 7). Schreibe eine Funktion `getLocalDay(date)`, die den "europäischen" Wochentag für `date` zurückgibt.
 
 ```js no-beautify
-let date = new Date(2012, 0, 3);  // 3 Jan 2012
-alert( getLocalDay(date) );       // tuesday, should show 2
+let date = new Date(2012, 0, 3);  // 3. Jan 2012
+alert( getLocalDay(date) );       // Dienstag, sollte 2 anzeigen
 ```
diff --git a/1-js/05-data-types/11-date/4-get-date-ago/solution.md b/1-js/05-data-types/11-date/4-get-date-ago/solution.md
index 5c394c100..e63427843 100644
--- a/1-js/05-data-types/11-date/4-get-date-ago/solution.md
+++ b/1-js/05-data-types/11-date/4-get-date-ago/solution.md
@@ -1,4 +1,4 @@
-The idea is simple: to substract given number of days from `date`:
+Die Idee ist einfach: eine gegebene Anzahl von Tagen von `date` abzuziehen:
 
 ```js
 function getDateAgo(date, days) {
@@ -7,9 +7,9 @@ function getDateAgo(date, days) {
 }
 ```
 
-...But the function should not change `date`. That's an important thing, because the outer code which gives us the date does not expect it to change.
+...Aber die Funktion sollte `date` nicht ändern. Das ist eine wichtige Sache, denn der äußere Code, der uns das Datum bereitstellt, erwartet nicht, dass es sich ändert.
 
-To implement it let's clone the date, like this:
+Um das zu implementieren, sollten wir das Datum klonen, so wie hier:
 
 ```js run demo
 function getDateAgo(date, days) {
@@ -21,7 +21,7 @@ function getDateAgo(date, days) {
 
 let date = new Date(2015, 0, 2);
 
-alert( getDateAgo(date, 1) ); // 1, (1 Jan 2015)
-alert( getDateAgo(date, 2) ); // 31, (31 Dec 2014)
-alert( getDateAgo(date, 365) ); // 2, (2 Jan 2014)
+alert( getDateAgo(date, 1) ); // 1, (1. Jan 2015)
+alert( getDateAgo(date, 2) ); // 31, (31. Dez 2014)
+alert( getDateAgo(date, 365) ); // 2, (2. Jan 2014)
 ```
diff --git a/1-js/05-data-types/11-date/4-get-date-ago/task.md b/1-js/05-data-types/11-date/4-get-date-ago/task.md
index 058d39c7e..6a190c8b4 100644
--- a/1-js/05-data-types/11-date/4-get-date-ago/task.md
+++ b/1-js/05-data-types/11-date/4-get-date-ago/task.md
@@ -2,20 +2,20 @@ importance: 4
 
 ---
 
-# Which day of month was many days ago?
+# Welcher Tag des Monats war vor vielen Tagen?
 
-Create a function `getDateAgo(date, days)` to return the day of month `days` ago from the `date`.
+Erstelle eine Funktion `getDateAgo(date, days)`, um den Tag des Monats vor `days` Tagen ab dem Datum `date` zu ermitteln.
 
-For instance, if today is 20th, then `getDateAgo(new Date(), 1)` should be 19th and `getDateAgo(new Date(), 2)` should be 18th.
+Beispiel: Wenn heute der 20. ist, dann sollte `getDateAgo(new Date(), 1)` den 19. zurückgeben und `getDateAgo(new Date(), 2)` den 18.
 
-Should work reliably for `days=365` or more:
+Die Funktion sollte auch zuverlässig für `days=365` oder mehr funktionieren:
 
 ```js
 let date = new Date(2015, 0, 2);
 
-alert( getDateAgo(date, 1) ); // 1, (1 Jan 2015)
-alert( getDateAgo(date, 2) ); // 31, (31 Dec 2014)
-alert( getDateAgo(date, 365) ); // 2, (2 Jan 2014)
+alert( getDateAgo(date, 1) ); // 1, (1. Jan 2015)
+alert( getDateAgo(date, 2) ); // 31, (31. Dez 2014)
+alert( getDateAgo(date, 365) ); // 2, (2. Jan 2014)
 ```
 
-P.S. The function should not modify the given `date`.
+P.S. Die Funktion sollte das übergebene `date` nicht verändern.
diff --git a/1-js/05-data-types/11-date/5-last-day-of-month/solution.md b/1-js/05-data-types/11-date/5-last-day-of-month/solution.md
index 4f642536e..463fd6b3e 100644
--- a/1-js/05-data-types/11-date/5-last-day-of-month/solution.md
+++ b/1-js/05-data-types/11-date/5-last-day-of-month/solution.md
@@ -1,4 +1,4 @@
-Let's create a date using the next month, but pass zero as the day:
+Lass uns ein Datum erstellen, indem wir den nächsten Monat nehmen, aber als Tag eine Null übergeben:
 ```js run demo
 function getLastDayOfMonth(year, month) {
   let date = new Date(year, month + 1, 0);
@@ -10,4 +10,4 @@ alert( getLastDayOfMonth(2012, 1) ); // 29
 alert( getLastDayOfMonth(2013, 1) ); // 28
 ```
 
-Normally, dates start from 1, but technically we can pass any number, the date will autoadjust itself. So when we pass 0, then it means "one day before 1st day of the month", in other words: "the last day of the previous month".
+Normalerweise beginnen Daten ab der Zahl 1, technisch gesehen können wir aber jede Zahl übergeben, das Datum wird sich selbst automatisch anpassen. Also, wenn wir 0 übergeben, dann bedeutet das "ein Tag vor dem ersten Tag des Monats", anders ausgedrückt: "der letzte Tag des vorherigen Monats".
diff --git a/1-js/05-data-types/11-date/5-last-day-of-month/task.md b/1-js/05-data-types/11-date/5-last-day-of-month/task.md
index 10dfb7a7a..c2d148510 100644
--- a/1-js/05-data-types/11-date/5-last-day-of-month/task.md
+++ b/1-js/05-data-types/11-date/5-last-day-of-month/task.md
@@ -2,13 +2,13 @@ importance: 5
 
 ---
 
-# Last day of month?
+# Letzter Tag des Monats?
 
-Write a function `getLastDayOfMonth(year, month)` that returns the last day of month. Sometimes it is 30th, 31st or even 28/29th for Feb.
+Schreibe eine Funktion `getLastDayOfMonth(year, month)`, die den letzten Tag des Monats zurückgibt. Manchmal ist es der 30., der 31. oder sogar der 28./29. für Februar.
 
-Parameters:
+Parameter:
 
-- `year` -- four-digits year, for instance 2012.
-- `month` -- month, from 0 to 11.
+- `year` -- vierstelliges Jahr, zum Beispiel 2012.
+- `month` -- Monat, von 0 bis 11.
 
-For instance, `getLastDayOfMonth(2012, 1) = 29` (leap year, Feb).
+Zum Beispiel `getLastDayOfMonth(2012, 1) = 29` (Schaltjahr, Feb).
diff --git a/1-js/05-data-types/11-date/6-get-seconds-today/solution.md b/1-js/05-data-types/11-date/6-get-seconds-today/solution.md
index 8f8e52b68..4a1f9ac00 100644
--- a/1-js/05-data-types/11-date/6-get-seconds-today/solution.md
+++ b/1-js/05-data-types/11-date/6-get-seconds-today/solution.md
@@ -1,22 +1,22 @@
-To get the number of seconds, we can generate a date using the current day and time 00:00:00, then substract it from "now".
+Um die Anzahl der Sekunden zu ermitteln, können wir ein Datum unter Verwendung des aktuellen Tages und der Uhrzeit 00:00:00 generieren und dieses von "jetzt" subtrahieren.
 
-The difference is the number of milliseconds from the beginning of the day, that we should divide by 1000 to get seconds:
+Die Differenz ist die Anzahl der Millisekunden seit Beginn des Tages, die wir durch 1000 teilen sollten, um Sekunden zu erhalten:
 
 ```js run
 function getSecondsToday() {
   let now = new Date();
 
-  // create an object using the current day/month/year
+  // erstelle ein Objekt mit dem aktuellen Tag/Monat/Jahr
   let today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
 
-  let diff = now - today; // ms difference
-  return Math.round(diff / 1000); // make seconds
+  let diff = now - today; // ms Differenz
+  return Math.round(diff / 1000); // mache Sekunden
 }
 
 alert( getSecondsToday() );
 ```
 
-An alternative solution would be to get hours/minutes/seconds and convert them to seconds:
+Eine alternative Lösung wäre, Stunden/Minuten/Sekunden zu ermitteln und diese in Sekunden umzurechnen:
 
 ```js run
 function getSecondsToday() {
diff --git a/1-js/05-data-types/11-date/6-get-seconds-today/task.md b/1-js/05-data-types/11-date/6-get-seconds-today/task.md
index 456790928..beee601d6 100644
--- a/1-js/05-data-types/11-date/6-get-seconds-today/task.md
+++ b/1-js/05-data-types/11-date/6-get-seconds-today/task.md
@@ -2,14 +2,14 @@ importance: 5
 
 ---
 
-# How many seconds have passed today?
+# Wie viele Sekunden sind heute bereits vergangen?
 
-Write a function `getSecondsToday()` that returns the number of seconds from the beginning of today.
+Schreibe eine Funktion `getSecondsToday()`, die die Anzahl der Sekunden seit Beginn des heutigen Tages zurückgibt.
 
-For instance, if now were `10:00 am`, and there was no daylight savings shift, then:
+Wenn es zum Beispiel jetzt `10:00 Uhr vormittags` wäre und es keine Umstellung auf Sommerzeit gäbe, dann:
 
 ```js
 getSecondsToday() == 36000 // (3600 * 10)
 ```
 
-The function should work in any day. That is, it should not have a hard-coded value of "today".
+Die Funktion sollte an jedem Tag funktionieren. Das heißt, sie sollte keinen fest einprogrammierten Wert von "heute" haben.
diff --git a/1-js/05-data-types/11-date/7-get-seconds-to-tomorrow/solution.md b/1-js/05-data-types/11-date/7-get-seconds-to-tomorrow/solution.md
index c337d1199..cf1270cae 100644
--- a/1-js/05-data-types/11-date/7-get-seconds-to-tomorrow/solution.md
+++ b/1-js/05-data-types/11-date/7-get-seconds-to-tomorrow/solution.md
@@ -1,20 +1,20 @@
-To get the number of milliseconds till tomorrow, we can from "tomorrow 00:00:00" substract the current date.
+Um die Anzahl der Millisekunden bis zum morgigen Tag zu berechnen, können wir vom "morgigen Tag, 00:00:00" das aktuelle Datum subtrahieren.
 
-First, we generate that "tomorrow", and then do it:
+Zuerst erzeugen wir das "morgige" Datum, und dann tun wir Folgendes:
 
 ```js run
 function getSecondsToTomorrow() {
   let now = new Date();
 
-  // tomorrow date
+  // morgiges Datum
   let tomorrow = new Date(now.getFullYear(), now.getMonth(), *!*now.getDate()+1*/!*);
 
-  let diff = tomorrow - now; // difference in ms
-  return Math.round(diff / 1000); // convert to seconds
+  let diff = tomorrow - now; // Differenz in ms
+  return Math.round(diff / 1000); // umrechnen in Sekunden
 }
 ```
 
-Alternative solution:
+Alternative Lösung:
 
 ```js run
 function getSecondsToTomorrow() {
@@ -29,4 +29,4 @@ function getSecondsToTomorrow() {
 }
 ```
 
-Please note that many countries have Daylight Savings Time (DST), so there may be days with 23 or 25 hours. We may want to treat such days separately.
+Bitte beachte, dass viele Länder die Sommerzeit (DST) einführen, daher kann es Tage mit 23 oder 25 Stunden geben. Wir möchten solche Tage möglicherweise gesondert behandeln.
diff --git a/1-js/05-data-types/11-date/7-get-seconds-to-tomorrow/task.md b/1-js/05-data-types/11-date/7-get-seconds-to-tomorrow/task.md
index e05903026..af94a3384 100644
--- a/1-js/05-data-types/11-date/7-get-seconds-to-tomorrow/task.md
+++ b/1-js/05-data-types/11-date/7-get-seconds-to-tomorrow/task.md
@@ -2,14 +2,14 @@ importance: 5
 
 ---
 
-# How many seconds till tomorrow?
+# Wie viele Sekunden bis morgen?
 
-Create a function `getSecondsToTomorrow()` that returns the number of seconds till tomorrow.
+Erstelle eine Funktion `getSecondsToTomorrow()`, die die Anzahl der Sekunden bis morgen zurückgibt.
 
-For instance, if now is `23:00`, then:
+Zum Beispiel, wenn es jetzt `23:00` ist, dann:
 
 ```js
 getSecondsToTomorrow() == 3600
 ```
 
-P.S. The function should work at any day, the "today" is not hardcoded.
+P.S. Die Funktion sollte an jedem Tag funktionieren, das "heute" ist nicht fest einprogrammiert.
diff --git a/1-js/05-data-types/11-date/8-format-date-relative/solution.md b/1-js/05-data-types/11-date/8-format-date-relative/solution.md
index 372485685..1a1d150e9 100644
--- a/1-js/05-data-types/11-date/8-format-date-relative/solution.md
+++ b/1-js/05-data-types/11-date/8-format-date-relative/solution.md
@@ -1,26 +1,26 @@
-To get the time from `date` till now -- let's substract the dates.
+Um die Zeit von `date` bis jetzt zu bekommen -- lass uns die Daten subtrahieren.
 
 ```js run demo
 function formatDate(date) {
-  let diff = new Date() - date; // the difference in milliseconds
+  let diff = new Date() - date; // der Unterschied in Millisekunden
 
-  if (diff < 1000) { // less than 1 second
+  if (diff < 1000) { // weniger als 1 Sekunde
     return 'right now';
   }
 
-  let sec = Math.floor(diff / 1000); // convert diff to seconds
+  let sec = Math.floor(diff / 1000); // diff in Sekunden umwandeln
 
   if (sec < 60) {
     return sec + ' sec. ago';
   }
 
-  let min = Math.floor(diff / 60000); // convert diff to minutes
+  let min = Math.floor(diff / 60000); // diff in Minuten umwandeln
   if (min < 60) {
     return min + ' min. ago';
   }
 
-  // format the date
-  // add leading zeroes to single-digit day/month/hours/minutes
+  // das Datum formatieren
+  // führende Nullen zu einstelligen Tagen/Monaten/Stunden/Minuten hinzufügen
   let d = date;
   d = [
     '0' + d.getDate(),
@@ -28,9 +28,9 @@ function formatDate(date) {
     '' + d.getFullYear(),
     '0' + d.getHours(),
     '0' + d.getMinutes()
-  ].map(component => component.slice(-2)); // take last 2 digits of every component
+  ].map(component => component.slice(-2)); // die letzten 2 Ziffern jeder Komponente nehmen
 
-  // join the components into date
+  // die Komponenten zu einem Datum zusammenfügen
   return d.slice(0, 3).join('.') + ' ' + d.slice(3).join(':');
 }
 
@@ -40,11 +40,11 @@ alert( formatDate(new Date(new Date - 30 * 1000)) ); // "30 sec. ago"
 
 alert( formatDate(new Date(new Date - 5 * 60 * 1000)) ); // "5 min. ago"
 
-// yesterday's date like 31.12.2016 20:00
+// das gestrige Datum wie 31.12.2016 20:00
 alert( formatDate(new Date(new Date - 86400 * 1000)) );
 ```
 
-Alternative solution:
+Alternative Lösung:
 
 ```js run
 function formatDate(date) {
@@ -58,7 +58,7 @@ function formatDate(date) {
   let diffMin = diffSec / 60;
   let diffHour = diffMin / 60;
 
-  // formatting
+  // Formatierung
   year = year.toString().slice(-2);
   month = month < 10 ? '0' + month : month;
   dayOfMonth = dayOfMonth < 10 ? '0' + dayOfMonth : dayOfMonth;
@@ -76,3 +76,4 @@ function formatDate(date) {
   }
 }
 ```
+
diff --git a/1-js/05-data-types/11-date/8-format-date-relative/task.md b/1-js/05-data-types/11-date/8-format-date-relative/task.md
index 9651b305f..ee9290f1a 100644
--- a/1-js/05-data-types/11-date/8-format-date-relative/task.md
+++ b/1-js/05-data-types/11-date/8-format-date-relative/task.md
@@ -2,16 +2,16 @@ importance: 4
 
 ---
 
-# Format the relative date
+# Das relative Datum formatieren
 
-Write a function `formatDate(date)` that should format `date` as follows:
+Schreibe eine Funktion `formatDate(date)`, die das Datum `date` wie folgt formatieren soll:
 
-- If since `date` passed less than 1 second, then `"right now"`.
-- Otherwise, if since `date` passed less than 1 minute, then `"n sec. ago"`.
-- Otherwise, if less than an hour, then `"m min. ago"`.
-- Otherwise, the full date in the format `"DD.MM.YY HH:mm"`. That is: `"day.month.year hours:minutes"`, all in 2-digit format, e.g. `31.12.16 10:00`.
+- Wenn seit `date` weniger als 1 Sekunde vergangen ist, dann `"right now"`.
+- Ansonsten, wenn seit `date` weniger als 1 Minute vergangen ist, dann `"n sec. ago"`.
+- Ansonsten, wenn weniger als eine Stunde vergangen ist, dann `"m min. ago"`.
+- Andernfalls das vollständige Datum im Format `"TT.MM.JJ HH:mm"`. Das heißt: `"Tag.Monat.Jahr Stunden:Minuten"`, alles im 2-Ziffern-Format, z.B. `31.12.16 10:00`.
 
-For instance:
+Zum Beispiel:
 
 ```js
 alert( formatDate(new Date(new Date - 1)) ); // "right now"
@@ -20,6 +20,6 @@ alert( formatDate(new Date(new Date - 30 * 1000)) ); // "30 sec. ago"
 
 alert( formatDate(new Date(new Date - 5 * 60 * 1000)) ); // "5 min. ago"
 
-// yesterday's date like 31.12.16 20:00
+// Das Datum von gestern wie 31.12.16 20:00
 alert( formatDate(new Date(new Date - 86400 * 1000)) );
 ```
diff --git a/1-js/05-data-types/11-date/article.md b/1-js/05-data-types/11-date/article.md
index 6958a3a97..2e5ac559c 100644
--- a/1-js/05-data-types/11-date/article.md
+++ b/1-js/05-data-types/11-date/article.md
@@ -1,141 +1,141 @@
-# Date and time
+# Datum und Uhrzeit
 
-Let's meet a new built-in object: [Date](mdn:js/Date). It stores the date, time and provides methods for date/time management.
+Lass uns ein neues eingebautes Objekt kennenlernen: [Date](mdn:js/Date). Es speichert das Datum, die Uhrzeit und bietet Methoden zur Verwaltung von Datum/Uhrzeit.
 
-For instance, we can use it to store creation/modification times, to measure time, or just to print out the current date.
+Zum Beispiel können wir es verwenden, um Erstellungs-/Änderungszeiten zu speichern, die Zeit zu messen oder einfach nur das aktuelle Datum auszugeben.
 
-## Creation
+## Erstellung
 
-To create a new `Date` object call `new Date()` with one of the following arguments:
+Um ein neues `Date`-Objekt zu erstellen, rufe `new Date()` mit einem der folgenden Argumente auf:
 
 `new Date()`
-: Without arguments -- create a `Date` object for the current date and time:
+: Ohne Argumente – erstellt ein `Date`-Objekt für das aktuelle Datum und die aktuelle Uhrzeit:
 
     ```js run
     let now = new Date();
-    alert( now ); // shows current date/time
+    alert( now ); // zeigt aktuelles Datum/Uhrzeit
     ```
 
 `new Date(milliseconds)`
-: Create a `Date` object with the time equal to number of milliseconds (1/1000 of a second) passed after the Jan 1st of 1970 UTC+0.
+: Erstelle ein `Date`-Objekt mit der Zeit gleich der Anzahl von Millisekunden (1/1000 einer Sekunde), die seit dem 1. Januar 1970 UTC+0 vergangen sind.
 
     ```js run
-    // 0 means 01.01.1970 UTC+0
+    // 0 bedeutet 01.01.1970 UTC+0
     let Jan01_1970 = new Date(0);
     alert( Jan01_1970 );
 
-    // now add 24 hours, get 02.01.1970 UTC+0
+    // nun 24 Stunden hinzufügen, ergibt 02.01.1970 UTC+0
     let Jan02_1970 = new Date(24 * 3600 * 1000);
     alert( Jan02_1970 );
     ```
 
-    An integer number representing the number of milliseconds that has passed since the beginning of 1970 is called a *timestamp*.
+    Eine ganze Zahl, die die Anzahl der Millisekunden darstellt, die seit Beginn des Jahres 1970 vergangen sind, wird als *Zeitstempel* bezeichnet.
 
-    It's a lightweight numeric representation of a date. We can always create a date from a timestamp using `new Date(timestamp)` and convert the existing `Date` object to a timestamp using the `date.getTime()` method (see below).
+    Es ist eine leichtgewichtige numerische Darstellung eines Datums. Wir können immer ein Datum aus einem Zeitstempel erstellen mit `new Date(timestamp)` und das bestehende `Date`-Objekt in einen Zeitstempel umwandeln mit der Methode `date.getTime()` (siehe unten).
 
-    Dates before 01.01.1970 have negative timestamps, e.g.:
+    Daten vor dem 01.01.1970 haben negative Zeitstempel, zum Beispiel:
     ```js run
-    // 31 Dec 1969
+    // 31. Dez 1969
     let Dec31_1969 = new Date(-24 * 3600 * 1000);
     alert( Dec31_1969 );
     ```
 
 `new Date(datestring)`
-: If there is a single argument, and it's a string, then it is parsed automatically. The algorithm is the same as `Date.parse` uses, we'll cover it later.
+: Wenn es ein einzelnes Argument gibt und es ist ein String, dann wird es automatisch geparst. Der Algorithmus ist derselbe, den `Date.parse` verwendet, was wir später behandeln werden.
 
     ```js run
     let date = new Date("2017-01-26");
     alert(date);
-    // The time is not set, so it's assumed to be midnight GMT and
-    // is adjusted according to the timezone the code is run in
-    // So the result could be
-    // Thu Jan 26 2017 11:00:00 GMT+1100 (Australian Eastern Daylight Time)
-    // or
-    // Wed Jan 25 2017 16:00:00 GMT-0800 (Pacific Standard Time)
+    // Die Zeit ist nicht gesetzt, daher wird angenommen, dass es Mitternacht GMT ist
+    // und sie wird entsprechend der Zeitzone angepasst, in der der Code ausgeführt wird
+    // Das Ergebnis könnte also sein
+    // Do., 26. Jan. 2017 11:00:00 GMT+1100 (Australian Eastern Daylight Time)
+    // oder
+    // Mi., 25. Jan. 2017 16:00:00 GMT-0800 (Pacific Standard Time)
     ```
 
 `new Date(year, month, date, hours, minutes, seconds, ms)`
-: Create the date with the given components in the local time zone. Only the first two arguments are obligatory.
+: Erstelle das Datum mit den gegebenen Komponenten in der lokalen Zeitzone. Nur die ersten beiden Argumente sind obligatorisch.
 
-    - The `year` should have 4 digits. For compatibility, 2 digits are also accepted and considered `19xx`, e.g. `98` is the same as `1998` here, but always using 4 digits is strongly encouraged.
-    - The `month` count starts with `0` (Jan), up to `11` (Dec).
-    - The `date` parameter is actually the day of month, if absent then `1` is assumed.
-    - If `hours/minutes/seconds/ms` is absent, they are assumed to be equal `0`.
+    - `year` sollte 4 Ziffern haben. Aus Kompatibilitätsgründen werden auch 2 Ziffern akzeptiert und als `19xx` betrachtet, zum Beispiel entspricht `98` dem Wert `1998`, aber die Verwendung von 4 Ziffern wird dringend empfohlen.
+    - `month` zählt ab `0` (Januar), bis `11` (Dezember).
+    - Der `date`-Parameter ist tatsächlich der Tag des Monats, wenn weggelassen, dann wird `1` angenommen.
+    - Wenn `hours/minutes/seconds/ms` weggelassen werden, wird angenommen, dass diese `0` sind.
 
-    For instance:
+    Beispiel:
 
     ```js
-    new Date(2011, 0, 1, 0, 0, 0, 0); // 1 Jan 2011, 00:00:00
-    new Date(2011, 0, 1); // the same, hours etc are 0 by default
+    new Date(2011, 0, 1, 0, 0, 0, 0); // 1. Jan 2011, 00:00:00
+    new Date(2011, 0, 1); // das Gleiche, Stunden usw. sind standardmäßig 0
     ```
 
-    The maximal precision is 1 ms (1/1000 sec):
+    Die größtmögliche Genauigkeit ist 1 ms (1/1000 Sekunde):
 
     ```js run
     let date = new Date(2011, 0, 1, 2, 3, 4, 567);
     alert( date ); // 1.01.2011, 02:03:04.567
     ```
 
-## Access date components
+## Zugriff auf Datumskomponenten
 
-There are methods to access the year, month and so on from the `Date` object:
+Es gibt Methoden, um auf das Jahr, den Monat usw. des `Date`-Objekts zuzugreifen:
 
 [getFullYear()](mdn:js/Date/getFullYear)
-: Get the year (4 digits)
+: Zugriff auf das Jahr (4 Ziffern)
 
 [getMonth()](mdn:js/Date/getMonth)
-: Get the month, **from 0 to 11**.
+: Zugriff auf den Monat, **von 0 bis 11**.
 
 [getDate()](mdn:js/Date/getDate)
-: Get the day of month, from 1 to 31, the name of the method does look a little bit strange.
+: Zugriff auf den Tag des Monats, von 1 bis 31, der Name der Methode wirkt etwas seltsam.
 
 [getHours()](mdn:js/Date/getHours), [getMinutes()](mdn:js/Date/getMinutes), [getSeconds()](mdn:js/Date/getSeconds), [getMilliseconds()](mdn:js/Date/getMilliseconds)
-: Get the corresponding time components.
+: Zugriff auf die entsprechenden Zeitkomponenten.
 
-```warn header="Not `getYear()`, but `getFullYear()`"
-Many JavaScript engines implement a non-standard method `getYear()`. This method is deprecated. It returns 2-digit year sometimes. Please never use it. There is `getFullYear()` for the year.
+```warn header="Nicht `getYear()`, sondern `getFullYear()`"
+Viele JavaScript-Engines implementieren eine nicht-standardisierte Methode `getYear()`. Diese Methode ist veraltet. Sie gibt manchmal ein 2-stelliges Jahr zurück. Bitte verwende sie niemals. Es gibt `getFullYear()` für das Jahr.
 ```
 
-Additionally, we can get a day of week:
+Zusätzlich können wir den Wochentag bekommen:
 
 [getDay()](mdn:js/Date/getDay)
-: Get the day of week, from `0` (Sunday) to `6` (Saturday). The first day is always Sunday, in some countries that's not so, but can't be changed.
+: Zugriff auf den Wochentag, von `0` (Sonntag) bis `6` (Samstag). Der erste Tag ist immer Sonntag, in einigen Ländern ist das nicht so, aber das kann nicht geändert werden.
 
-**All the methods above return the components relative to the local time zone.**
+**Alle oben genannten Methoden geben die Komponenten relativ zur lokalen Zeitzone zurück.**
 
-There are also their UTC-counterparts, that return day, month, year and so on for the time zone UTC+0: [getUTCFullYear()](mdn:js/Date/getUTCFullYear), [getUTCMonth()](mdn:js/Date/getUTCMonth), [getUTCDay()](mdn:js/Date/getUTCDay). Just insert the `"UTC"` right after `"get"`.
+Es gibt auch ihre UTC-Gegenstücke, die Tag, Monat, Jahr usw. für die Zeitzone UTC+0 zurückgeben: [getUTCFullYear()](mdn:js/Date/getUTCFullYear), [getUTCMonth()](mdn:js/Date/getUTCMonth), [getUTCDay()](mdn:js/Date/getUTCDay). Füge einfach nach `"get"` das `"UTC"` ein.
 
-If your local time zone is shifted relative to UTC, then the code below shows different hours:
+Wenn deine lokale Zeitzone relativ zu UTC verschoben ist, dann zeigt der untenstehende Code unterschiedliche Stunden an:
 
 ```js run
-// current date
+// aktuelles Datum
 let date = new Date();
 
-// the hour in your current time zone
+// die Stunde in Ihrer aktuellen Zeitzone
 alert( date.getHours() );
 
-// the hour in UTC+0 time zone (London time without daylight savings)
+// die Stunde in der Zeitzone UTC+0 (Londoner Zeit ohne Sommerzeit)
 alert( date.getUTCHours() );
 ```
 
-Besides the given methods, there are two special ones that do not have a UTC-variant:
+Neben den gegebenen Methoden gibt es zwei spezielle, die keine UTC-Variante haben:
 
 [getTime()](mdn:js/Date/getTime)
-: Returns the timestamp for the date -- a number of milliseconds passed from the January 1st of 1970 UTC+0.
+: Gibt den Zeitstempel für das Datum zurück -- eine Anzahl von Millisekunden seit dem 1. Januar 1970 UTC+0.
 
 [getTimezoneOffset()](mdn:js/Date/getTimezoneOffset)
-: Returns the difference between UTC and the local time zone, in minutes:
+: Gibt den Unterschied zwischen UTC und der lokalen Zeitzone in Minuten zurück:
 
     ```js run
-    // if you are in timezone UTC-1, outputs 60
-    // if you are in timezone UTC+3, outputs -180
+    // Wenn du dich in der Zeitzone UTC-1 befindest, gibt es 60 aus
+    // Wenn du dich in der Zeitzone UTC+3 befindest, gibt es -180 aus
     alert( new Date().getTimezoneOffset() );
 
     ```
 
-## Setting date components
+## Datumskomponenten einstellen
 
-The following methods allow to set date/time components:
+Die folgenden Methoden erlauben es, Datum/Zeit-Komponenten festzulegen:
 
 - [`setFullYear(year, [month], [date])`](mdn:js/Date/setFullYear)
 - [`setMonth(month, [date])`](mdn:js/Date/setMonth)
@@ -144,38 +144,38 @@ The following methods allow to set date/time components:
 - [`setMinutes(min, [sec], [ms])`](mdn:js/Date/setMinutes)
 - [`setSeconds(sec, [ms])`](mdn:js/Date/setSeconds)
 - [`setMilliseconds(ms)`](mdn:js/Date/setMilliseconds)
-- [`setTime(milliseconds)`](mdn:js/Date/setTime) (sets the whole date by milliseconds since 01.01.1970 UTC)
+- [`setTime(milliseconds)`](mdn:js/Date/setTime) (setzt das ganze Datum auf Millisekunden seit dem 01.01.1970 UTC)
 
-Every one of them except `setTime()` has a UTC-variant, for instance: `setUTCHours()`.
+Jede dieser Methoden außer `setTime()` hat ein UTC-Gegenstück, wie zum Beispiel: `setUTCHours()`.
 
-As we can see, some methods can set multiple components at once, for example `setHours`. The components that are not mentioned are not modified.
+Wie wir sehen können, können einige Methoden gleichzeitig mehrere Komponenten anpassen, zum Beispiel `setHours`. Die Komponenten, die nicht erwähnt werden, werden nicht geändert.
 
-For instance:
+Beispiel:
 
 ```js run
-let today = new Date();
+let heute = new Date();
 
-today.setHours(0);
-alert(today); // still today, but the hour is changed to 0
+heute.setHours(0);
+alert(heute); // immer noch heute, aber die Stunde ist auf 0 geändert
 
-today.setHours(0, 0, 0, 0);
-alert(today); // still today, now 00:00:00 sharp.
+heute.setHours(0, 0, 0, 0);
+alert(heute); // immer noch heute, jetzt 00:00:00 genau.
 ```
 
-## Autocorrection
+## Autokorrektur
 
-The *autocorrection* is a very handy feature of `Date` objects. We can set out-of-range values, and it will auto-adjust itself.
+Die *Autokorrektur* ist eine sehr praktische Funktion von `Date`-Objekten. Wir können Werte außerhalb des Bereichs verwenden, und sie wird diese automatisch anpassen.
 
-For instance:
+Beispiel:
 
 ```js run
-let date = new Date(2013, 0, *!*32*/!*); // 32 Jan 2013 ?!?
-alert(date); // ...is 1st Feb 2013!
+let date = new Date(2013, 0, *!*32*/!*); // 32. Jan 2013 ?!?
+alert(date); // ...ist der 1. Feb 2013!
 ```
 
-Out-of-range date components are distributed automatically.
+Datumskomponenten außerhalb des Bereichs werden automatisch verteilt.
 
-Let's say we need to increase the date "28 Feb 2016" by 2 days. It may be "2 Mar" or "1 Mar" in case of a leap-year. We don't need to think about it. Just add 2 days. The `Date` object will do the rest:
+Angenommen, wir müssen das Datum "28. Feb 2016" um 2 Tage erhöhen. Es könnte der "2. März" oder der "1. März" im Falle eines Schaltjahres sein. Wir müssen nicht darüber nachdenken. Einfach 2 Tage hinzufügen. Das `Date`-Objekt erledigt den Rest:
 
 ```js run
 let date = new Date(2016, 1, 28);
@@ -183,112 +183,112 @@ let date = new Date(2016, 1, 28);
 date.setDate(date.getDate() + 2);
 */!*
 
-alert( date ); // 1 Mar 2016
+alert( date ); // 1. Mär 2016
 ```
 
-That feature is often used to get the date after the given period of time. For instance, let's get the date for "70 seconds after now":
+Diese Funktion wird oft verwendet, um das Datum nach einer bestimmten Zeitperiode zu erhalten. Zum Beispiel, lass uns das Datum für "70 Sekunden ab jetzt" erhalten:
 
 ```js run
 let date = new Date();
 date.setSeconds(date.getSeconds() + 70);
 
-alert( date ); // shows the correct date
+alert( date ); // zeigt das korrekte Datum
 ```
 
-We can also set zero or even negative values. For example:
+Wir können auch null oder sogar negative Werte verwenden. Zum Beispiel:
 
 ```js run
-let date = new Date(2016, 0, 2); // 2 Jan 2016
+let date = new Date(2016, 0, 2); // 2. Jan 2016
 
-date.setDate(1); // set day 1 of month
+date.setDate(1); // lege Tag 1 des Monats fest
 alert( date );
 
-date.setDate(0); // min day is 1, so the last day of the previous month is assumed
-alert( date ); // 31 Dec 2015
+date.setDate(0); // minimaler Tag ist 1, also wird der letzte Tag des Vormonats angenommen
+alert( date ); // 31. Dez 2015
 ```
 
-## Date to number, date diff
+## Datum in Zahl, Datumsunterschied
 
-When a `Date` object is converted to number, it becomes the timestamp same as `date.getTime()`:
+Wenn ein `Date`-Objekt in eine Zahl umgewandelt wird, wird es zum Zeitstempel genauso wie `date.getTime()`:
 
 ```js run
 let date = new Date();
-alert(+date); // the number of milliseconds, same as date.getTime()
+alert(+date); // die Anzahl der Millisekunden, genau wie date.getTime()
 ```
 
-The important side effect: dates can be subtracted, the result is their difference in ms.
+Die wichtige Seiteneffekt: Daten können subtrahiert werden, das Ergebnis ist ihr Unterschied in Millisekunden.
 
-That can be used for time measurements:
+Das kann für Zeitmessungen verwendet werden:
 
 ```js run
-let start = new Date(); // start measuring time
+let start = new Date(); // beginnen mit der Zeitmessung
 
-// do the job
+// verrichte Arbeit
 for (let i = 0; i < 100000; i++) {
   let doSomething = i * i * i;
 }
 
-let end = new Date(); // end measuring time
+let end = new Date(); // beenden der Zeitmessung
 
-alert( `The loop took ${end - start} ms` );
+alert( `Die Schleife dauerte ${end - start} ms` );
 ```
 
 ## Date.now()
 
-If we only want to measure time, we don't need the `Date` object.
+Wenn wir nur die Zeit messen wollen, benötigen wir kein `Date`-Objekt.
 
-There's a special method `Date.now()` that returns the current timestamp.
+Es gibt eine spezielle Methode `Date.now()`, die den aktuellen Zeitstempel zurückgibt.
 
-It is semantically equivalent to `new Date().getTime()`, but it doesn't create an intermediate `Date` object. So it's faster and doesn't put pressure on garbage collection.
+Sie ist semantisch gleichbedeutend mit `new Date().getTime()`, aber sie erstellt kein Zwischen-`Date`-Objekt. Daher ist sie schneller und belastet die Garbage-Kollektion nicht.
 
-It is used mostly for convenience or when performance matters, like in games in JavaScript or other specialized applications.
+Sie wird meistens aus Bequemlichkeit oder wenn Performance wichtig ist verwendet, wie in JavaScript-Spielen oder anderen spezialisierten Anwendungen.
 
-So this is probably better:
+Also ist das vermutlich besser:
 
 ```js run
 *!*
-let start = Date.now(); // milliseconds count from 1 Jan 1970
+let start = Date.now(); // Millisekunden seit 1. Jan 1970
 */!*
 
-// do the job
+// verrichte Arbeit
 for (let i = 0; i < 100000; i++) {
   let doSomething = i * i * i;
 }
 
 *!*
-let end = Date.now(); // done
+let end = Date.now(); // fertig
 */!*
 
-alert( `The loop took ${end - start} ms` ); // subtract numbers, not dates
+alert( `Die Schleife dauerte ${end - start} ms` ); // subtrahiere Zahlen, nicht Daten
 ```
 
 ## Benchmarking
 
-If we want a reliable benchmark of CPU-hungry function, we should be careful.
+Wenn wir einen verlässlichen Benchmark für eine CPU-intensive Funktion haben wollen, sollten wir vorsichtig sein.
 
-For instance, let's measure two functions that calculate the difference between two dates: which one is faster?
+Zum Beispiel, lass uns zwei Funktionen messen, die den Unterschied zwischen zwei Daten berechnen: welche ist schneller?
 
-Such performance measurements are often called "benchmarks".
+Solche Leistungsmessungen werden oft "Benchmarks" genannt.
 
 ```js
-// we have date1 and date2, which function faster returns their difference in ms?
+// wir haben date1 und date2, welche Funktion gibt schneller deren Unterschied in ms zurück?
 function diffSubtract(date1, date2) {
   return date2 - date1;
 }
 
-// or
+// oder
 function diffGetTime(date1, date2) {
   return date2.getTime() - date1.getTime();
 }
 ```
 
-These two do exactly the same thing, but one of them uses an explicit `date.getTime()` to get the date in ms, and the other one relies on a date-to-number transform. Their result is always the same.
+Diese beiden machen genau dasselbe, aber eine benutzt ein explizites `date.getTime()`, um das Datum in Millisekunden zu erhalten, und die andere verlässt sich auf eine Datum-zu-Zahl-Umwandlung. Das Ergebnis ist immer das Gleiche.
 
-So, which one is faster?
+Also, welche ist schneller?
 
-The first idea may be to run them many times in a row and measure the time difference. For our case, functions are very simple, so we have to do it at least 100000 times.
+Die erste Idee könnte sein, sie viele Male hintereinander auszuführen und den Zeitunterschied zu messen. In unserem Fall sind die Funktionen sehr einfach, also müssen wir das mindestens 100000 Mal machen.
 
-Let's measure:
+Lass uns messen:
 
 ```js run
 function diffSubtract(date1, date2) {
@@ -308,23 +308,23 @@ function bench(f) {
   return Date.now() - start;
 }
 
-alert( 'Time of diffSubtract: ' + bench(diffSubtract) + 'ms' );
-alert( 'Time of diffGetTime: ' + bench(diffGetTime) + 'ms' );
+alert( 'Zeit für diffSubtract: ' + bench(diffSubtract) + 'ms' );
+alert( 'Zeit für diffGetTime: ' + bench(diffGetTime) + 'ms' );
 ```
 
-Wow! Using `getTime()` is so much faster! That's because there's no type conversion, it is much easier for engines to optimize.
+Wow! Die Verwendung von `getTime()` ist so viel schneller! Das liegt daran, dass keine Typumwandlung stattfindet und es für die Engines viel einfacher ist, zu optimieren.
 
-Okay, we have something. But that's not a good benchmark yet.
+Okay, wir haben etwas. Aber das ist noch kein guter Benchmark.
 
-Imagine that at the time of running `bench(diffSubtract)` CPU was doing something in parallel, and it was taking resources. And by the time of running `bench(diffGetTime)` that work has finished.
+Stell dir vor, dass zur Zeit der Ausführung von `bench(diffSubtract)` die CPU parallel etwas anderes gemacht hat und Ressourcen verbraucht wurden. Und zum Zeitpunkt der Ausführung von `bench(diffGetTime)` war diese Arbeit beendet.
 
-A pretty real scenario for a modern multi-process OS.
+Ein ziemlich reales Szenario für ein modernes Multi-Prozess-Betriebssystem.
 
-As a result, the first benchmark will have less CPU resources than the second. That may lead to wrong results.
+Als Ergebnis könnte der erste Benchmark weniger CPU-Ressourcen als der zweite haben. Das könnte zu falschen Ergebnissen führen.
 
-**For more reliable benchmarking, the whole pack of benchmarks should be rerun multiple times.**
+**Für zuverlässigeres Benchmarking sollte das gesamte Paket an Benchmarks mehrmals wiederholt werden.**
 
-For example, like this:
+Zum Beispiel so:
 
 ```js run
 function diffSubtract(date1, date2) {
@@ -348,61 +348,61 @@ let time1 = 0;
 let time2 = 0;
 
 *!*
-// run bench(diffSubtract) and bench(diffGetTime) each 10 times alternating
+// führe bench(diffSubtract) und bench(diffGetTime) jeweils 10-mal abwechselnd aus
 for (let i = 0; i < 10; i++) {
   time1 += bench(diffSubtract);
   time2 += bench(diffGetTime);
 }
 */!*
 
-alert( 'Total time for diffSubtract: ' + time1 );
-alert( 'Total time for diffGetTime: ' + time2 );
+alert( 'Gesamtzeit für diffSubtract: ' + time1 );
+alert( 'Gesamtzeit für diffGetTime: ' + time2 );
 ```
 
-Modern JavaScript engines start applying advanced optimizations only to "hot code" that executes many times (no need to optimize rarely executed things). So, in the example above, first executions are not well-optimized. We may want to add a heat-up run:
+Moderne JavaScript-Engines beginnen damit, fortgeschrittene Optimierungen nur auf "heißen Code" anzuwenden, der viele Male ausgeführt wird (keine Notwendigkeit, selten ausgeführte Dinge zu optimieren). Deshalb sind in dem oben genannten Beispiel die ersten Ausführungen nicht gut optimiert. Wir möchten vielleicht einen Aufwärm-Durchlauf hinzufügen:
 
 ```js
-// added for "heating up" prior to the main loop
+// Hinzugefügt zum "Aufwärmen" vor der Hauptschleife
 bench(diffSubtract);
 bench(diffGetTime);
 
-// now benchmark
+// jetzt Benchmarking
 for (let i = 0; i < 10; i++) {
   time1 += bench(diffSubtract);
   time2 += bench(diffGetTime);
 }
 ```
 
-```warn header="Be careful doing microbenchmarking"
-Modern JavaScript engines perform many optimizations. They may tweak results of "artificial tests" compared to "normal usage", especially when we benchmark something very small, such as how an operator works, or a built-in function. So if you seriously want to understand performance, then please study how the JavaScript engine works. And then you probably won't need microbenchmarks at all.
+```warn header="Sei vorsichtig bei Mikrobenchmarking"
+Moderne JavaScript-Engines führen viele Optimierungen durch. Du kannst die Ergebnisse von "künstlichen Tests" im Vergleich zur "normalen Nutzung" verändern, insbesondere wenn wir etwas sehr Kleines benchmarken, wie die Funktionsweise eines Operators oder einer eingebauten Funktion. Wenn du also die Performance ernsthaft verstehen möchtest, dann studiere bitte, wie die JavaScript-Engine funktioniert. Und dann wirst du wahrscheinlich überhaupt keine Mikrobenchmarks brauchen.
 
-The great pack of articles about V8 can be found at <https://mrale.ph>.
+Eine großartige Sammlung von Artikeln über V8 findest Du unter <https://mrale.ph>.
 ```
 
-## Date.parse from a string
+## Date.parse aus einem String
 
-The method [Date.parse(str)](mdn:js/Date/parse) can read a date from a string.
+Die Methode [Date.parse(str)](mdn:js/Date/parse) kann ein Datum aus einem String auslesen.
 
-The string format should be: `YYYY-MM-DDTHH:mm:ss.sssZ`, where:
+Das String-Format sollte sein: `YYYY-MM-DDTHH:mm:ss.sssZ`, wobei:
 
-- `YYYY-MM-DD` -- is the date: year-month-day.
-- The character `"T"` is used as the delimiter.
-- `HH:mm:ss.sss` -- is the time: hours, minutes, seconds and milliseconds.
-- The optional `'Z'` part denotes the time zone in the format `+-hh:mm`. A single letter `Z` would mean UTC+0.
+- `YYYY-MM-DD` -- das Datum ist: Jahr-Monat-Tag.
+- Das Zeichen `"T"` wird als Trennzeichen verwendet.
+- `HH:mm:ss.sss` -- ist die Zeit: Stunden, Minuten, Sekunden und Millisekunden.
+- Der optionale Teil `'Z'` kennzeichnet die Zeitzone im Format `+-hh:mm`. Ein einzelner Buchstabe `Z` würde UTC+0 bedeuten.
 
-Shorter variants are also possible, like `YYYY-MM-DD` or `YYYY-MM` or even `YYYY`.
+Auch kürzere Varianten sind möglich, wie `YYYY-MM-DD` oder `YYYY-MM` oder sogar `YYYY`.
 
-The call to `Date.parse(str)` parses the string in the given format and returns the timestamp (number of milliseconds from 1 Jan 1970 UTC+0). If the format is invalid, returns `NaN`.
+Der Aufruf von `Date.parse(str)` parst den String im gegebenen Format und gibt den Zeitstempel zurück (Anzahl der Millisekunden ab dem 1. Januar 1970 UTC+0). Wenn das Format ungültig ist, gibt er `NaN` zurück.
 
-For instance:
+Zum Beispiel:
 
 ```js run
 let ms = Date.parse('2012-01-26T13:51:50.417-07:00');
 
-alert(ms); // 1327611110417  (timestamp)
+alert(ms); // 1327611110417  (Zeitstempel)
 ```
 
-We can instantly create a `new Date` object from the timestamp:
+Wir können sofort ein `new Date` Objekt aus dem Zeitstempel erstellen:
 
 ```js run
 let date = new Date( Date.parse('2012-01-26T13:51:50.417-07:00') );
@@ -410,24 +410,24 @@ let date = new Date( Date.parse('2012-01-26T13:51:50.417-07:00') );
 alert(date);
 ```
 
-## Summary
+## Zusammenfassung
 
-- Date and time in JavaScript are represented with the [Date](mdn:js/Date) object. We can't create "only date" or "only time": `Date` objects always carry both.
-- Months are counted from zero (yes, January is a zero month).
-- Days of week in `getDay()` are also counted from zero (that's Sunday).
-- `Date` auto-corrects itself when out-of-range components are set. Good for adding/subtracting days/months/hours.
-- Dates can be subtracted, giving their difference in milliseconds. That's because a `Date` becomes the timestamp when converted to a number.
-- Use `Date.now()` to get the current timestamp fast.
+- Datum und Uhrzeit in JavaScript werden mit dem [Date](mdn:js/Date)-Objekt dargestellt. Wir können nicht "nur Datum" oder "nur Zeit" erstellen: `Date`-Objekte tragen immer beides.
+- Monate werden von Null gezählt (ja, Januar ist der Null-Monat).
+- Wochentage in `getDay()` werden auch ab Null gezählt (das ist Sonntag).
+- `Date` korrigiert sich selbst, wenn Komponenten außerhalb des gültigen Bereichs gesetzt werden. Gut für das Hinzufügen/Subtrahieren von Tagen/Monaten/Stunden.
+- Daten können subtrahiert werden, was ihre Differenz in Millisekunden ergibt. Das liegt daran, dass ein `Date`, wenn es in eine Zahl umgewandelt wird, zum Zeitstempel wird.
+- Verwende `Date.now()`, um schnell den aktuellen Zeitstempel zu erhalten.
 
-Note that unlike many other systems, timestamps in JavaScript are in milliseconds, not in seconds.
+Beachte, dass anders als in vielen anderen Systemen, Zeitstempel in JavaScript in Millisekunden und nicht in Sekunden sind.
 
-Sometimes we need more precise time measurements. JavaScript itself does not have a way to measure time in microseconds (1 millionth of a second), but most environments provide it. For instance, browser has [performance.now()](mdn:api/Performance/now) that gives the number of milliseconds from the start of page loading with microsecond precision (3 digits after the point):
+Manchmal benötigen wir genauere Zeitmessungen. JavaScript selbst hat keine Möglichkeit, Zeit in Mikrosekunden zu messen (1 Millionstel einer Sekunde), aber die meisten Umgebungen bieten dies an. Zum Beispiel hat der Browser [performance.now()](mdn:api/Performance/now), was die Anzahl der Millisekunden seit dem Start des Seitenladens mit Mikrosekunden-Präzision ergibt (3 Ziffern nach dem Punkt):
 
 ```js run
-alert(`Loading started ${performance.now()}ms ago`);
-// Something like: "Loading started 34731.26000000001ms ago"
-// .26 is microseconds (260 microseconds)
-// more than 3 digits after the decimal point are precision errors, only the first 3 are correct
+alert(`Das Laden hat vor ${performance.now()}ms begonnen`);
+// Etwas wie: "Das Laden hat vor 34731.26000000001ms begonnen"
+// .26 sind Mikrosekunden (260 Mikrosekunden)
+// mehr als 3 Ziffern nach dem Dezimalpunkt sind Präzisionsfehler, nur die ersten 3 sind korrekt
 ```
 
-Node.js has `microtime` module and other ways. Technically, almost any device and environment allows to get more precision, it's just not in `Date`.
+Node.js hat das `microtime` Modul und andere Weisen. Technisch gesehen, ermöglicht fast jedes Gerät und jede Umgebung eine genauere Präzision, sie ist nur nicht in `Date`.