From bef52166c4a49e4c54f6882a28d2a0cefe4c02e9 Mon Sep 17 00:00:00 2001
From: ockley <vestergaard.karsten@gmail.com>
Date: Mon, 16 Feb 2026 08:58:42 +0100
Subject: [PATCH] Oversat til dansk

---
 .../11-date/1-new-date/solution.md            |  10 +-
 1-js/05-data-types/11-date/1-new-date/task.md |   6 +-
 .../2-get-week-day/_js.view/solution.js       |   3 +-
 .../11-date/2-get-week-day/_js.view/test.js   |  30 +-
 .../11-date/2-get-week-day/solution.md        |  10 +-
 .../11-date/2-get-week-day/task.md            |  10 +-
 .../11-date/3-weekday/_js.view/solution.js    |   2 +-
 .../11-date/3-weekday/_js.view/test.js        |  16 +-
 1-js/05-data-types/11-date/3-weekday/task.md  |   8 +-
 .../11-date/4-get-date-ago/_js.view/test.js   |  12 +-
 .../11-date/4-get-date-ago/solution.md        |   6 +-
 .../11-date/4-get-date-ago/task.md            |  10 +-
 .../5-last-day-of-month/_js.view/test.js      |   6 +-
 .../11-date/5-last-day-of-month/solution.md   |   4 +-
 .../11-date/5-last-day-of-month/task.md       |  12 +-
 .../11-date/6-get-seconds-today/solution.md   |  12 +-
 .../11-date/6-get-seconds-today/task.md       |   8 +-
 .../7-get-seconds-to-tomorrow/solution.md     |  14 +-
 .../11-date/7-get-seconds-to-tomorrow/task.md |   8 +-
 .../_js.view/solution.js                      |  22 +-
 .../8-format-date-relative/_js.view/test.js   |  16 +-
 .../8-format-date-relative/solution.md        |  42 +--
 .../11-date/8-format-date-relative/task.md    |  22 +-
 1-js/05-data-types/11-date/article.md         | 278 +++++++++---------
 24 files changed, 285 insertions(+), 282 deletions(-)

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..899246bd6 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,15 +1,15 @@
-The `new Date` constructor uses the local time zone. So the only important thing to remember is that months start from zero.
+`new Date` konstruktøren bruger lokal tidszone. Så det vigtigste at huske er, at måneder starter fra 0.
 
-So February has number 1.
+Så februar har nummer 1.
 
-Here's an example with numbers as date components:
+Her er et eksempel med tal som dato-komponenter:
 
 ```js run
-//new Date(year, month, date, hour, minute, second, millisecond)
+//new Date(år, måned, månedsdag, timer, minutter, sekunder, mellisekunder)
 let d1 = new Date(2012, 1, 20, 3, 12);
 alert( d1 );
 ```
-We could also create a date from a string, like this:
+Vi kunne også oprette en dato fra en streng, som dette:
 
 ```js run
 //new Date(datastring)
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..49f83da64 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
+# Opret et dato objekt
 
-Create a `Date` object for the date: Feb 20, 2012, 3:12am. The time zone is local.
+Opret et `Date` objekt for datoen: 20. februar 2012 kl. 03:12. Tidszonen er lokal.
 
-Show it using `alert`.
+Vis det med `alert`.
diff --git a/1-js/05-data-types/11-date/2-get-week-day/_js.view/solution.js b/1-js/05-data-types/11-date/2-get-week-day/_js.view/solution.js
index 642c376a9..a243894d5 100644
--- a/1-js/05-data-types/11-date/2-get-week-day/_js.view/solution.js
+++ b/1-js/05-data-types/11-date/2-get-week-day/_js.view/solution.js
@@ -1,5 +1,6 @@
 function getWeekDay(date) {
-  let days = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'];
+  let days = ['Søn', 'Man', 'Tir', 'Ons', 'Tors', 'Fre', 'Lør'];
 
   return days[date.getDay()];
 }
+
diff --git a/1-js/05-data-types/11-date/2-get-week-day/_js.view/test.js b/1-js/05-data-types/11-date/2-get-week-day/_js.view/test.js
index 3cdc91830..546c1deb5 100644
--- a/1-js/05-data-types/11-date/2-get-week-day/_js.view/test.js
+++ b/1-js/05-data-types/11-date/2-get-week-day/_js.view/test.js
@@ -1,29 +1,29 @@
-describe("getWeekDay", function() {
-  it("3 January 2014 - friday", function() {
-    assert.equal(getWeekDay(new Date(2014, 0, 3)), 'FR');
+describe("getWeekDay", function () {
+  it("3 January 2014 - fredag", function () {
+    assert.equal(getWeekDay(new Date(2014, 0, 3)), 'Fre');
   });
 
-  it("4 January 2014 - saturday", function() {
-    assert.equal(getWeekDay(new Date(2014, 0, 4)), 'SA');
+  it("4 January 2014 - lørdag", function () {
+    assert.equal(getWeekDay(new Date(2014, 0, 4)), 'Lør');
   });
 
-  it("5 January 2014 - sunday", function() {
-    assert.equal(getWeekDay(new Date(2014, 0, 5)), 'SU');
+  it("5 January 2014 - søndag", function () {
+    assert.equal(getWeekDay(new Date(2014, 0, 5)), 'Søn');
   });
 
-  it("6 January 2014 - monday", function() {
-    assert.equal(getWeekDay(new Date(2014, 0, 6)), 'MO');
+  it("6 January 2014 - mandag", function () {
+    assert.equal(getWeekDay(new Date(2014, 0, 6)), 'Man');
   });
 
-  it("7 January 2014 - tuesday", function() {
-    assert.equal(getWeekDay(new Date(2014, 0, 7)), 'TU');
+  it("7 January 2014 - tirsdag", function () {
+    assert.equal(getWeekDay(new Date(2014, 0, 7)), 'Tir');
   });
 
-  it("8 January 2014 - wednesday", function() {
-    assert.equal(getWeekDay(new Date(2014, 0, 8)), 'WE');
+  it("8 January 2014 - onsdag", function () {
+    assert.equal(getWeekDay(new Date(2014, 0, 8)), 'Ons');
   });
 
-  it("9 January 2014 - thursday", function() {
-    assert.equal(getWeekDay(new Date(2014, 0, 9)), 'TH');
+  it("9 January 2014 - torsdag", function () {
+    assert.equal(getWeekDay(new Date(2014, 0, 9)), 'Tors');
   });
 });
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..24226f0fd 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.
+Metoden `date.getDay()` returnerer nummeret af dagen, der starter med søndag.
 
-Let's make an array of weekdays, so that we can get the proper day name by its number:
+Lad os lave et array af dage, så vi kan få den rigtige dagnavn efter nummeret:
 
 ```js run demo
 function getWeekDay(date) {
-  let days = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'];
+  let days = ['Søn', 'Man', 'Tir', 'Ons', 'Tors', 'Fre', 'Lør'];
 
   return days[date.getDay()];
 }
 
-let date = new Date(2014, 0, 3); // 3 Jan 2014
-alert( getWeekDay(date) ); // FR
+let date = new Date(2014, 0, 3); // 3. januar 2014
+alert( getWeekDay(date) ); // Fre
 ```
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..b9ffa9e0d 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
+# Vis dagen i ugen
 
-Write a function `getWeekDay(date)` to show the weekday in short format: 'MO', 'TU', 'WE', 'TH', 'FR', 'SA', 'SU'.
+Skriv en funktion `getWeekDay(date)` der viser dagen i ugen i forkortet format: 'Man', 'Tir', 'Ons', 'Tors', 'Fre', 'Lør', 'Søn'.
 
-For instance:
+For eksempel:
 
 ```js no-beautify
-let date = new Date(2012, 0, 3);  // 3 Jan 2012
-alert( getWeekDay(date) );        // should output "TU"
+let date = new Date(2014, 0, 3);  // 3. januar 2014
+alert( getWeekDay(date) );        // Skal skrive "Fre
 ```
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..215bed779 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) { // ugedage 0 (søndag) er 7 i europæiske lande
     day = 7;
   }
 
diff --git a/1-js/05-data-types/11-date/3-weekday/_js.view/test.js b/1-js/05-data-types/11-date/3-weekday/_js.view/test.js
index 57032154f..0d3fd4186 100644
--- a/1-js/05-data-types/11-date/3-weekday/_js.view/test.js
+++ b/1-js/05-data-types/11-date/3-weekday/_js.view/test.js
@@ -1,29 +1,29 @@
-describe("getLocalDay returns the \"european\" weekday", function() {
-  it("3 January 2014 - friday", function() {
+describe("getLocalDay returnerer den europæiske ugedag", function () {
+  it("3 January 2014 - fredag", function () {
     assert.equal(getLocalDay(new Date(2014, 0, 3)), 5);
   });
 
-  it("4 January 2014 - saturday", function() {
+  it("4 January 2014 - lørdag", function () {
     assert.equal(getLocalDay(new Date(2014, 0, 4)), 6);
   });
 
-  it("5 January 2014 - sunday", function() {
+  it("5 January 2014 - søndag", function () {
     assert.equal(getLocalDay(new Date(2014, 0, 5)), 7);
   });
 
-  it("6 January 2014 - monday", function() {
+  it("6 January 2014 - mandag", function () {
     assert.equal(getLocalDay(new Date(2014, 0, 6)), 1);
   });
 
-  it("7 January 2014 - tuesday", function() {
+  it("7 January 2014 - tirsdag", function () {
     assert.equal(getLocalDay(new Date(2014, 0, 7)), 2);
   });
 
-  it("8 January 2014 - wednesday", function() {
+  it("8 January 2014 - onsdag", function () {
     assert.equal(getLocalDay(new Date(2014, 0, 8)), 3);
   });
 
-  it("9 January 2014 - thursday", function() {
+  it("9 January 2014 - torsdag", function () {
     assert.equal(getLocalDay(new Date(2014, 0, 9)), 4);
   });
 });
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..cf99d5da2 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æiske ugedage
 
-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æiske lande starter med mandag (nummer 1), så tirsdag (nummer 2) og så videre indtil søndag (nummer 7). Skriv en funktion `getLocalDay(date)` der returnerer "Europæisk" ugedag for `date`.
 
 ```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. januar 2012
+alert( getLocalDay(date) );       // tirsdag, should show 2
 ```
diff --git a/1-js/05-data-types/11-date/4-get-date-ago/_js.view/test.js b/1-js/05-data-types/11-date/4-get-date-ago/_js.view/test.js
index 255acffe0..6298403a4 100644
--- a/1-js/05-data-types/11-date/4-get-date-ago/_js.view/test.js
+++ b/1-js/05-data-types/11-date/4-get-date-ago/_js.view/test.js
@@ -1,23 +1,23 @@
-describe("getDateAgo", function() {
+describe("getDateAgo", function () {
 
-  it("1 day before 02.01.2015 -> day 1", function() {
+  it("1 dag før 02.01.2015 -> day 1", function () {
     assert.equal(getDateAgo(new Date(2015, 0, 2), 1), 1);
   });
 
 
-  it("2 days before 02.01.2015 -> day 31", function() {
+  it("2 dage før 02.01.2015 -> day 31", function () {
     assert.equal(getDateAgo(new Date(2015, 0, 2), 2), 31);
   });
 
-  it("100 days before 02.01.2015 -> day 24", function() {
+  it("100 dage før 02.01.2015 -> day 24", function () {
     assert.equal(getDateAgo(new Date(2015, 0, 2), 100), 24);
   });
 
-  it("365 days before 02.01.2015 -> day 2", function() {
+  it("365 dage før 02.01.2015 -> day 2", function () {
     assert.equal(getDateAgo(new Date(2015, 0, 2), 365), 2);
   });
 
-  it("does not modify the given date", function() {
+  it("ændrer ikke den givne datoen", function () {
     let date = new Date(2015, 0, 2);
     let dateCopy = new Date(date);
     getDateAgo(dateCopy, 100);
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..21dcb383a 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`:
+Ideen er simpel: at trække det givne antal af dage fra `date`:
 
 ```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.
+...men funktionen skal ikke ændre den givne `date`. Det er en vigtig ting, fordi den ydre kode, der giver os datoen, ikke forventer, at den ændres.
 
-To implement it let's clone the date, like this:
+For at implementere det skal vi klone datoen, sådan her:
 
 ```js run demo
 function getDateAgo(date, days) {
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..60fb6dff7 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,13 +2,13 @@ importance: 4
 
 ---
 
-# Which day of month was many days ago?
+# Hvad var dagen for mange dage siden?
 
-Create a function `getDateAgo(date, days)` to return the day of month `days` ago from the `date`.
+Skriv en funktion `getDateAgo(date, days)` der returnerer dagen for `days` dage siden fra `date`.
 
-For instance, if today is 20th, then `getDateAgo(new Date(), 1)` should be 19th and `getDateAgo(new Date(), 2)` should be 18th.
+For eksempel, hvis idag er den 20de, så skal `getDateAgo(new Date(), 1)` være den 19de og `getDateAgo(new Date(), 2)` være den 18de.
 
-Should work reliably for `days=365` or more:
+Skal virke på en pålitelig måde for `days=365` eller mere:
 
 ```js
 let date = new Date(2015, 0, 2);
@@ -18,4 +18,4 @@ alert( getDateAgo(date, 2) ); // 31, (31 Dec 2014)
 alert( getDateAgo(date, 365) ); // 2, (2 Jan 2014)
 ```
 
-P.S. The function should not modify the given `date`.
+P.S. Funktionen skal ikke ændre den givne `date`.
diff --git a/1-js/05-data-types/11-date/5-last-day-of-month/_js.view/test.js b/1-js/05-data-types/11-date/5-last-day-of-month/_js.view/test.js
index 4ff3e116a..bb43d73de 100644
--- a/1-js/05-data-types/11-date/5-last-day-of-month/_js.view/test.js
+++ b/1-js/05-data-types/11-date/5-last-day-of-month/_js.view/test.js
@@ -1,13 +1,13 @@
 describe("getLastDayOfMonth", function() {
-  it("last day of 01.01.2012 - 31", function() {
+  it("sidste dag i 01.01.2012 - 31", function() {
     assert.equal(getLastDayOfMonth(2012, 0), 31);
   });
 
-  it("last day of 01.02.2012 - 29 (leap year)", function() {
+  it("sidste dag i 01.02.2012 - 29 (skudår)", function() {
     assert.equal(getLastDayOfMonth(2012, 1), 29);
   });
 
-  it("last day of 01.02.2013 - 28", function() {
+  it("sidste dag i 01.02.2013 - 28", function() {
     assert.equal(getLastDayOfMonth(2013, 1), 28);
   });
 });
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..f4ccc29d9 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:
+Lad os oprette en datoen med næste måned, men overfør 0 som dagen:
 ```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".
+Normalt starter datoen fra 1, men vi kan overføre enhver tal, datoen vil autoadjust sig selv. Så når vi overfører 0, betyder det "en dag før den første dag i måned", i anden ord: "den sidste dag i den forrige måned".
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..d4be10459 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?
+# Sidste dag i måned?
 
-Write a function `getLastDayOfMonth(year, month)` that returns the last day of month. Sometimes it is 30th, 31st or even 28/29th for Feb.
+Skriv en funktion `getLastDayOfMonth(year, month)` der returnerer den sidste dag i måned. Som givet kan det være den 30de, 31de eller 28/29 for Feb.
 
-Parameters:
+Parametre:
 
-- `year` -- four-digits year, for instance 2012.
-- `month` -- month, from 0 to 11.
+- `year` -- fire-sifret år, for eksempel 2012.
+- `month` -- måned, fra 0 til 11.
 
-For instance, `getLastDayOfMonth(2012, 1) = 29` (leap year, Feb).
+For eksempel, `getLastDayOfMonth(2012, 1) = 29` (skudår, februar).
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..f90cb7cf7 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".
+For at få antallet af sekunder, kan vi generere en datoen med den nuværende dag og tid 00:00:00, så kan vi subtrahere det fra "nu".
 
-The difference is the number of milliseconds from the beginning of the day, that we should divide by 1000 to get seconds:
+Differensen er antallet af millisekunder fra starten af dagen, der skal divideres med 1000 for at få sekunder:
 
 ```js run
 function getSecondsToday() {
   let now = new Date();
 
-  // create an object using the current day/month/year
+  // opret et objekt med den nuværende dag/måned/år
   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; // forskel i millisekunder
+  return Math.round(diff / 1000); // omdan til sekunder
 }
 
 alert( getSecondsToday() );
 ```
 
-An alternative solution would be to get hours/minutes/seconds and convert them to seconds:
+En anden løsning ville være at få timer/minutes/seconds og konvertere dem til sekunder:
 
 ```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..a16b7229e 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?
+# Hvor mange sekunder har gået i dag?
 
-Write a function `getSecondsToday()` that returns the number of seconds from the beginning of today.
+Skriv en funktion `getSecondsToday()` der returnerer antallet af sekunder fra starten af dagen i dag.
 
-For instance, if now were `10:00 am`, and there was no daylight savings shift, then:
+For eksempel, hvis nu var `10:00 am`, og der var ikke en skudskift, så:
 
 ```js
 getSecondsToday() == 36000 // (3600 * 10)
 ```
 
-The function should work in any day. That is, it should not have a hard-coded value of "today".
+Funktionen skal fungere for enhver dag. Det betyder, at den ikke kan have en fast indsat værdi af dagen i dag.
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..aa296c825 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.
+For at få antallet af millisekunder til morgen, kan vi fra "morgens 00:00:00" subtrahere den nuværende dags tidsstempel.
 
-First, we generate that "tomorrow", and then do it:
+Først genererer vi den "morgens", og så gør vi det:
 
 ```js run
 function getSecondsToTomorrow() {
   let now = new Date();
 
-  // tomorrow date
+  // imorgens tidsstempel
   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; // forskel i millisekunder
+  return Math.round(diff / 1000); // konverter til sekunder
 }
 ```
 
-Alternative solution:
+Alternative løsning:
 
 ```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.
+Bemærk, at mange lande har sommer tid (DST), så der kan være dage med 23 eller 25 timer. Vi kan ønske at behandle sådanne dage separat.
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..55e3c0a90 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?
+# Hvor mange sekunder til morgen?
 
-Create a function `getSecondsToTomorrow()` that returns the number of seconds till tomorrow.
+Skriv en funktion `getSecondsToTomorrow()` der returnerer antallet af sekunder fra starten af dagen i morgen.
 
-For instance, if now is `23:00`, then:
+For eksempel, hvis tiden nu var `23:00`, så:
 
 ```js
 getSecondsToTomorrow() == 3600
 ```
 
-P.S. The function should work at any day, the "today" is not hardcoded.
+P.S. Funktionen skal fungere for enhver dag, dagen i dag er ikke fastsat.
diff --git a/1-js/05-data-types/11-date/8-format-date-relative/_js.view/solution.js b/1-js/05-data-types/11-date/8-format-date-relative/_js.view/solution.js
index 4695354a5..4202de6fe 100644
--- a/1-js/05-data-types/11-date/8-format-date-relative/_js.view/solution.js
+++ b/1-js/05-data-types/11-date/8-format-date-relative/_js.view/solution.js
@@ -1,24 +1,24 @@
 
 function formatDate(date) {
-  let diff = new Date() - date; // the difference in milliseconds
+  let diff = new Date() - date; // forskel i millisekunder
 
-  if (diff < 1000) { // less than 1 second
-    return 'right now';
+  if (diff < 1000) { // under en sekund
+    return 'lige nu';
   }
 
-  let sec = Math.floor(diff / 1000); // convert diff to seconds
+  let sec = Math.floor(diff / 1000); // konverter forskellen til sekunder
 
   if (sec < 60) {
-    return sec + ' sec. ago';
+    return sec + ' sekunder siden';
   }
 
-  let min = Math.floor(diff / 60000); // convert diff to minutes
+  let min = Math.floor(diff / 60000); // konverter forskellen til minutter
   if (min < 60) {
-    return min + ' min. ago';
+    return min + ' minutter siden';
   }
 
-  // format the date
-  // add leading zeroes to single-digit day/month/hours/minutes
+  // formater dato
+  // tilføj foranstående nuller til en-sifret dag/måned/timer/minutes
   let d = date;
   d = [
     '0' + d.getDate(),
@@ -26,8 +26,8 @@ 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)); // tag de sidste 2 cifre af hvert komponent
 
-  // join the components into date
+  // flet komponenterne sammen til en dato
   return d.slice(0, 3).join('.') + ' ' + d.slice(3).join(':');
 }
diff --git a/1-js/05-data-types/11-date/8-format-date-relative/_js.view/test.js b/1-js/05-data-types/11-date/8-format-date-relative/_js.view/test.js
index 9b4cb2f58..87fd6bc42 100644
--- a/1-js/05-data-types/11-date/8-format-date-relative/_js.view/test.js
+++ b/1-js/05-data-types/11-date/8-format-date-relative/_js.view/test.js
@@ -1,17 +1,17 @@
-describe("formatDate", function() {
-  it("shows 1ms ago as \"right now\"", function() {
-    assert.equal(formatDate(new Date(new Date - 1)), 'right now');
+describe("formatDate", function () {
+  it("viser 1 millisekund som \"lige nu\"", function () {
+    assert.equal(formatDate(new Date(new Date - 1)), 'lige nu');
   });
 
-  it('"30 seconds ago"', function() {
-    assert.equal(formatDate(new Date(new Date - 30 * 1000)), "30 sec. ago");
+  it('viser 30 sekunder som \"30 sekunder siden\"', function () {
+    assert.equal(formatDate(new Date(new Date - 30 * 1000)), "30 sekunder siden");
   });
 
-  it('"5 minutes ago"', function() {
-    assert.equal(formatDate(new Date(new Date - 5 * 60 * 1000)), "5 min. ago");
+  it('viser 5 minutter som \"5 minutter siden\"', function () {
+    assert.equal(formatDate(new Date(new Date - 5 * 60 * 1000)), "5 minutter siden");
   });
 
-  it("older dates as DD.MM.YY HH:mm", function() {
+  it('viser mere end en dag siden som DD.MM.YY HH:mm', function () {
     assert.equal(formatDate(new Date(2014, 2, 1, 11, 22, 33)), "01.03.14 11:22");
   });
 
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..f4ad25e60 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.
+For at få tiden fra `date` til nu -- trækker vi den givne dato fra den nuværende.
 
 ```js run demo
 function formatDate(date) {
-  let diff = new Date() - date; // the difference in milliseconds
+  let diff = new Date() - date; // forskel i millisekunder
 
-  if (diff < 1000) { // less than 1 second
-    return 'right now';
+  if (diff < 1000) { // under en sekund
+    return 'lige nu';
   }
 
-  let sec = Math.floor(diff / 1000); // convert diff to seconds
+  let sec = Math.floor(diff / 1000); // konverter forskellen til sekunder
 
   if (sec < 60) {
-    return sec + ' sec. ago';
+    return sec + ' sekunder siden';
   }
 
-  let min = Math.floor(diff / 60000); // convert diff to minutes
+  let min = Math.floor(diff / 60000); // konverter forskellen til minutter
   if (min < 60) {
-    return min + ' min. ago';
+    return min + ' minutter siden';
   }
 
-  // format the date
-  // add leading zeroes to single-digit day/month/hours/minutes
+  // formater dato
+  // tilføj foranstående nuller til en-sifret dag/måned/timer/minutes
   let d = date;
   d = [
     '0' + d.getDate(),
@@ -28,23 +28,23 @@ 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)); // tag de sidste 2 cifre af hvert komponent
 
-  // join the components into date
+  // flet komponenterne sammen til en dato
   return d.slice(0, 3).join('.') + ' ' + d.slice(3).join(':');
 }
 
-alert( formatDate(new Date(new Date - 1)) ); // "right now"
+alert( formatDate(new Date(new Date - 1)) ); // "lige nu"
 
-alert( formatDate(new Date(new Date - 30 * 1000)) ); // "30 sec. ago"
+alert( formatDate(new Date(new Date - 30 * 1000)) ); // "30 sekunder siden"
 
-alert( formatDate(new Date(new Date - 5 * 60 * 1000)) ); // "5 min. ago"
+alert( formatDate(new Date(new Date - 5 * 60 * 1000)) ); // "5 minutter siden"
 
-// yesterday's date like 31.12.2016 20:00
+// Gårsdagens dato, fx 31.12.2016 20:00
 alert( formatDate(new Date(new Date - 86400 * 1000)) );
 ```
 
-Alternative solution:
+Alternative løsning:
 
 ```js run
 function formatDate(date) {
@@ -58,7 +58,7 @@ function formatDate(date) {
   let diffMin = diffSec / 60;
   let diffHour = diffMin / 60;
 
-  // formatting
+  // formatering
   year = year.toString().slice(-2);
   month = month < 10 ? '0' + month : month;
   dayOfMonth = dayOfMonth < 10 ? '0' + dayOfMonth : dayOfMonth;
@@ -66,11 +66,11 @@ function formatDate(date) {
   minutes = minutes < 10 ? '0' + minutes : minutes;
 
   if (diffSec < 1) {
-    return 'right now';  
+    return 'lige nu';  
   } else if (diffMin < 1) {
-    return `${diffSec} sec. ago`
+    return `${diffSec} sekunder siden`
   } else if (diffHour < 1) {
-    return `${diffMin} min. ago`
+    return `${diffMin} minutter siden`
   } else {
     return `${dayOfMonth}.${month}.${year} ${hour}:${minutes}`
   }
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..8f1e97fd0 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,24 +2,24 @@ importance: 4
 
 ---
 
-# Format the relative date
+# Formater den relative dato
 
-Write a function `formatDate(date)` that should format `date` as follows:
+Skriv en funktion `formatDate(date)` der formaterer `date` som følger:
 
-- 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`.
+- Hvis `date` er givet for under en sekund siden, så skal den returnere `"lige nu"`.
+- Hvis `date` er givet for under en minut siden, så skal den returnere `"n sekunder siden"`.
+- Hvis `date` er givet for under en time siden, så skal den returnere `"m minutter siden"`.
+- Hvis `date` er givet for under en dag siden, så skal den returnere `"DD.MM.YY HH:mm"`.
 
-For instance:
+For eksempel:
 
 ```js
-alert( formatDate(new Date(new Date - 1)) ); // "right now"
+alert( formatDate(new Date(new Date - 1)) ); // "lige nu"
 
-alert( formatDate(new Date(new Date - 30 * 1000)) ); // "30 sec. ago"
+alert( formatDate(new Date(new Date - 30 * 1000)) ); // "30 sekunder siden"
 
-alert( formatDate(new Date(new Date - 5 * 60 * 1000)) ); // "5 min. ago"
+alert( formatDate(new Date(new Date - 5 * 60 * 1000)) ); // "5 minutter siden"
 
-// yesterday's date like 31.12.16 20:00
+// En dag siden
 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..f045d6735 100644
--- a/1-js/05-data-types/11-date/article.md
+++ b/1-js/05-data-types/11-date/article.md
@@ -1,39 +1,39 @@
-# Date and time
+# Dato og tid
 
-Let's meet a new built-in object: [Date](mdn:js/Date). It stores the date, time and provides methods for date/time management.
+Lad os se på et andet indbygget objekt: [Date](mdn:js/Date). Det gemmer datoen, tiden og giver metoder til håndtering af dato/tid.
 
-For instance, we can use it to store creation/modification times, to measure time, or just to print out the current date.
+For eksempel kan vi bruge det til at gemme oprettelses-/ændringstider, måle tid eller blot udskrive den nuværende dato.
 
-## Creation
+## Oprettelse
 
-To create a new `Date` object call `new Date()` with one of the following arguments:
+For at oprette et nyt `Date` objekt kalder vi `new Date()` med en af følgende argumenter:
 
 `new Date()`
-: Without arguments -- create a `Date` object for the current date and time:
+: uden argumenter -- opretter et `Date` objekt med nuværende dato og tid:
 
     ```js run
     let now = new Date();
-    alert( now ); // shows current date/time
+    alert( now ); // viser nuværende dato/tid
     ```
 
-`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.
+`new Date(millisekunder)`
+: Opretter et `Date` objekt med tiden lig med antallet af millisekunder (1/1000 af en sekund) der er gået efter 1. januar 1970 UTC+0.
 
     ```js run
-    // 0 means 01.01.1970 UTC+0
+    // 0 betyder 01.01.1970 UTC+0
     let Jan01_1970 = new Date(0);
     alert( Jan01_1970 );
 
-    // now add 24 hours, get 02.01.1970 UTC+0
+    // tilføjer 24 timer, giver 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*.
+    Et heltal der repræsenterer antallet af millisekunder der er gået siden 1. januar 1970 UTC+0 kaldes en *timestamp* (tidsstempel).
 
-    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).
+    Det er en simpel numerisk repræsentation af en dato som heltal. Vi kan altid oprette en dato fra et timestamp ved hjælp af `new Date(timestamp)` og konvertere et eksisterende `Date` objekt til et timestamp ved hjælp af metoden `date.getTime()` (se nedenfor).
 
-    Dates before 01.01.1970 have negative timestamps, e.g.:
+    Datoer før 01.01.1970 har negative timestamps, e.g.:
     ```js run
     // 31 Dec 1969
     let Dec31_1969 = new Date(-24 * 3600 * 1000);
@@ -41,101 +41,103 @@ To create a new `Date` object call `new Date()` with one of the following argume
     ```
 
 `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.
+: Hvis der sendes et enkelt argument og det er en streng, så bliver den automatisk fortolket. Algoritmen er den samme som `Date.parse` bruger - den ser vi på senere.
 
     ```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
+    // Tiden er ikke defineret, så det antages at være midnat GMT og
+    // justeres i forhold til tidszonen hvor koden køres
+    // Så resultatet kan være
     // Thu Jan 26 2017 11:00:00 GMT+1100 (Australian Eastern Daylight Time)
-    // or
+    // eller
     // Wed Jan 25 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.
+`new Date(år, måned, dag, timer, minutter, sekunder, millisekunder)`
+: Opretter et date objekt med de givne komponenter i den lokale tidszone. Kun de første to argumenter er obligatoriske.
 
-    - 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`.
+    - `år` skal have 4 tal. For kompatibilitet er to tal også tilladt og betragtes som `19xx`. F.eks. `98` er det samme som `1998`. Men, brug af 4 tal er stærkt anbefalet.
+    - `måned` tallet for måned starter fra `0` (Jan), op til `11` (Dec).
+    - `dag` parameteren er den aktuelle dag i måneden. Hvis den ikke gives sættes den til `1`.
+    - Hvis `timer/minutter/sekunder/millisekunder` ikke gives, sættes de til `0`.
 
-    For instance:
+    For eksempel, for at oprette et `Date` objekt for 1. januar 2011 kl. 00:00:00, kan vi bruge:
 
     ```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); // samme resultat, timer osv. er sat til 0 som standard
     ```
 
-    The maximal precision is 1 ms (1/1000 sec):
+    Maksimal præcision er 1 ms (1/1000 sekund):
 
     ```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
+## Tilgå de enkelte komponenter i et dato objekt
 
-There are methods to access the year, month and so on from the `Date` object:
+Der er metoder til at tilgå år, måned og så videre fra et `Date` objekt:
 
 [getFullYear()](mdn:js/Date/getFullYear)
-: Get the year (4 digits)
+: Henter årstallet (4 cifre)
 
 [getMonth()](mdn:js/Date/getMonth)
-: Get the month, **from 0 to 11**.
+: Henter måneden, **fra 0 til 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.
+: Henter dagen i måneden, fra 1 til 31 (Metodens navn er lidt mærkeligt).
 
 [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.
+: Henter de tilsvarende tidskomponenter.
 
-```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="Ikke `getYear()`, men `getFullYear()`"
+Mange JavaScript motorer har implememnteret en ikke-standard metode ved navn `getYear()`. Denne metode er udfaset. Den returnerer ofte 2-cifret år. Brug `getFullYear()` til at hente årstallet.
 ```
 
-Additionally, we can get a day of week:
+Derudover kan vi også få ugedagen:
 
 [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.
+: Henter ugedagen, fra `0` (søndag) til `6` (lørdag). Den første dag er som standard altid søndag. I Danmark er det mandag der betragtes som første ugedag, men det kan ikke ændres.
 
-**All the methods above return the components relative to the local time zone.**
+**Alle metoderne ovenfor returnerer komponenterne i forhold til den lokale tidszone.**
 
-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"`.
+Der er også deres UTC-modsvar, som returnerer dag, måned, år og så videre for tidszonen UTC+0: [getUTCFullYear()](mdn:js/Date/getUTCFullYear), [getUTCMonth()](mdn:js/Date/getUTCMonth), [getUTCDay()](mdn:js/Date/getUTCDay). Bare indsæt `"UTC"` lige efter `"get"`.
 
-If your local time zone is shifted relative to UTC, then the code below shows different hours:
+Hvis din lokale tidszone er forskellig fra UTC, så viser koden nedenfor forskellige timer:
+
+Hvis din lokale tidszone er forskellig fra UTC, så viser koden nedenfor forskellige timer:
 
 ```js run
-// current date
+// nuværende dato
 let date = new Date();
 
-// the hour in your current time zone
+// Timer i den lokale tidszone
 alert( date.getHours() );
 
-// the hour in UTC+0 time zone (London time without daylight savings)
+// Timer i UTC+0 tidszone (London tid uden sommertid)
 alert( date.getUTCHours() );
 ```
 
-Besides the given methods, there are two special ones that do not have a UTC-variant:
+Udover de givne metoder er der to specielle der ikke har en UTC-variant:
 
 [getTime()](mdn:js/Date/getTime)
-: Returns the timestamp for the date -- a number of milliseconds passed from the January 1st of 1970 UTC+0.
+: Returnerer en timestamp for datoen -- det antal millisekunder der er gået fra 1. januar 1970 UTC+0.
 
 [getTimezoneOffset()](mdn:js/Date/getTimezoneOffset)
-: Returns the difference between UTC and the local time zone, in minutes:
+: Returnerer forskellen mellem UTC og den lokale tidszone, i minutter. For eksempel, hvis du er i tidszonen UTC-1, så returnerer den `60` (fordi UTC er 60 minutter foran). Hvis du er i tidszonen UTC+3, så returnerer den `-180` (fordi UTC er 180 minutter bagud).:
 
     ```js run
-    // if you are in timezone UTC-1, outputs 60
-    // if you are in timezone UTC+3, outputs -180
+    // hvis du er i tidszonen UTC-1, gives 60
+    // hvis du er i tidszonen UTC+3, gives -180
     alert( new Date().getTimezoneOffset() );
 
     ```
 
-## Setting date components
+## Sæt de enkelte komponenter i et dato objekt
 
-The following methods allow to set date/time components:
+De følgende metoder tillader at sætte dato/tidskomponenter:
 
 - [`setFullYear(year, [month], [date])`](mdn:js/Date/setFullYear)
 - [`setMonth(month, [date])`](mdn:js/Date/setMonth)
@@ -144,38 +146,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) (sætter hele datoen baseret på antal millisekunder siden 01.01.1970 UTC)
 
-Every one of them except `setTime()` has a UTC-variant, for instance: `setUTCHours()`.
+Hver af disse undtaget `setTime()` har en UTC-variant, for eksempel: `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.
+Som vi kan se, kan nogle metoder sætte flere komponenter på én gang, for eksempel `setHours`. De komponenter der ikke er nævnt ændres ikke.
 
-For instance:
+For eksempel:
 
 ```js run
 let today = new Date();
 
 today.setHours(0);
-alert(today); // still today, but the hour is changed to 0
+alert(today); // stadig dagen idag, men timer er ændret til 0
 
 today.setHours(0, 0, 0, 0);
-alert(today); // still today, now 00:00:00 sharp.
+alert(today); // stadig dagen idag, men tiden er sat til 00:00:00.
 ```
 
-## Autocorrection
+## Automatisk korrektion
 
-The *autocorrection* is a very handy feature of `Date` objects. We can set out-of-range values, and it will auto-adjust itself.
+*autokorrektion* er en praktisk feature af `Date` objekter. Vi kan sætte værdier uden for det normale interval, og det vil automatisk justere sig.
 
-For instance:
+For eksempel:
 
 ```js run
 let date = new Date(2013, 0, *!*32*/!*); // 32 Jan 2013 ?!?
-alert(date); // ...is 1st Feb 2013!
+alert(date); // ...bliver til 1st februar 2013!
 ```
 
-Out-of-range date components are distributed automatically.
+Datokomponenter uden for det normale interval distribueres automatisk.
 
-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:
+Lad os sige at vi vil forøge datoen "28 Feb 2016" med 2 dage. Det kan være "2 Mar" eller "1 Mar" i tilfældet af et skudår. Vi behøver ikke at tænke over det. Bare tilføj 2 dage. `Date` objektet vil gøre resten:
 
 ```js run
 let date = new Date(2016, 1, 28);
@@ -183,112 +185,112 @@ let date = new Date(2016, 1, 28);
 date.setDate(date.getDate() + 2);
 */!*
 
-alert( date ); // 1 Mar 2016
+alert( date ); // 1. marts 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":
+Denne feature er ofte brugt til at få datoen efter en given tidsperiode. For eksempel, lad os få datoen for "70 sekunder efter nu":
 
 ```js run
 let date = new Date();
 date.setSeconds(date.getSeconds() + 70);
 
-alert( date ); // shows the correct date
+alert( date ); // viser den korrekte dato, 70 sekunder efter nu
 ```
 
-We can also set zero or even negative values. For example:
+Vi kan også indstille nul eller endda negative værdier. For eksempel, hvis vi sætter dag til nul, så bliver det den sidste dag i den forrige måned:
 
 ```js run
-let date = new Date(2016, 0, 2); // 2 Jan 2016
+let date = new Date(2016, 0, 2); // 2. januar 2016
 
-date.setDate(1); // set day 1 of month
+date.setDate(1); // sæt dagen til den 1. i måneden
 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); // mindste dag er 1, så 0 vil sætte den til sidste dag i måneden før
+alert( date ); // 31. december 2015
 ```
 
-## Date to number, date diff
+## Date til tal kan bruges til at trække datoer fra hinanden
 
-When a `Date` object is converted to number, it becomes the timestamp same as `date.getTime()`:
+Når et `Date` objekt konverteres til et tal, bliver det til en timestamp på samme måde som `date.getTime()`:
 
 ```js run
 let date = new Date();
-alert(+date); // the number of milliseconds, same as date.getTime()
+alert(+date); // antal millisekunder, samme som date.getTime()
 ```
 
-The important side effect: dates can be subtracted, the result is their difference in ms.
+En vigtig sideeffekt: datoer kan trækkes fra, og resultatet er deres forskel i millisekunder.
 
-That can be used for time measurements:
+Det kan bruges til tidsmålinger:
 
 ```js run
-let start = new Date(); // start measuring time
+let start = new Date(); // start måling af tid
 
 // do the job
 for (let i = 0; i < 100000; i++) {
   let doSomething = i * i * i;
 }
 
-let end = new Date(); // end measuring time
+let end = new Date(); // slut tidsmåling
 
-alert( `The loop took ${end - start} ms` );
+alert( `Loopet tog ${end - start} ms at gennemføre` );
 ```
 
 ## Date.now()
 
-If we only want to measure time, we don't need the `Date` object.
+Hvis vi kun vil måle tid, behøver vi ikke hele `Date` objektet.
 
-There's a special method `Date.now()` that returns the current timestamp.
+Der er en speciel metode `Date.now()` som returnerer den aktuelle timestamp.
 
-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.
+Det er det samme som hvis du skriver `new Date().getTime()`, men det opretter ikke selve `Date` objektet. På den måde er det en hurtigere metode uden at påvirke garbage collection.
 
-It is used mostly for convenience or when performance matters, like in games in JavaScript or other specialized applications.
+Det bruges mest fordi det er bekvemmeligt og hvis hastighed er kritisk, som ved udvikling af spil eller andre specialiserede programmer.
 
-So this is probably better:
+Så viil dette nok være bedre:
 
 ```js run
 *!*
-let start = Date.now(); // milliseconds count from 1 Jan 1970
+let start = Date.now(); // millisekunder tæller fra 1. januar 1970
 */!*
 
-// do the job
+// Udfør en hansling
 for (let i = 0; i < 100000; i++) {
   let doSomething = i * i * i;
 }
 
 *!*
-let end = Date.now(); // done
+let end = Date.now(); // færdig
 */!*
 
-alert( `The loop took ${end - start} ms` ); // subtract numbers, not dates
+alert( `Loopet tog ${end - start} ms at gennemføre` ); // træk de to tal fra hinanden
 ```
 
-## Benchmarking
+## Hastighedsmåling (benchmarking)
 
-If we want a reliable benchmark of CPU-hungry function, we should be careful.
+Hvis vi ønsker en pålidelig benchmark af en CPU-intensiv funktion, bør vi være forsigtige.
 
-For instance, let's measure two functions that calculate the difference between two dates: which one is faster?
+For eksempel, lad os måle to funktioner der beregner forskellen mellem to datoer: hvilken er hurtigere?
 
-Such performance measurements are often called "benchmarks".
+Sådanne ydeevne-målinger kaldes ofte "benchmarks".
 
 ```js
-// we have date1 and date2, which function faster returns their difference in ms?
+// Vi har date1 og date2. Hvilken funktion er hurtigere til at returnere forskellen i ms?
 function diffSubtract(date1, date2) {
   return date2 - date1;
 }
 
-// or
+// eller måske denne?
 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.
+Disse to funktioner gør præcis det samme, men en af dem bruger et eksplicit `date.getTime()` for at få datoen i millisekunder, og den anden bruger en dato-til-tal konvertering. Deres resultat er altid det samme.
 
-So, which one is faster?
+Så, hvilken er hurtigere?
 
-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.
+Den første idé kan være at køre dem mange gange i træk og måle tidsforskellen. For vores tilfælde er funktionerne meget simple, så vi skal gøre det mindst 100000 gange.
 
-Let's measure:
+Lad os måle det:
 
 ```js run
 function diffSubtract(date1, date2) {
@@ -308,23 +310,23 @@ function bench(f) {
   return Date.now() - start;
 }
 
-alert( 'Time of diffSubtract: ' + bench(diffSubtract) + 'ms' );
-alert( 'Time of diffGetTime: ' + bench(diffGetTime) + 'ms' );
+alert( 'Tiden for diffSubtract: ' + bench(diffSubtract) + 'ms' );
+alert( 'Tiden for 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! Brugen af `getTime()` er ret meget hurtigere! Hovedårsagen er at der ikke er nogen konvertering af datatype, det er meget lettere for motorer at optimere.
 
-Okay, we have something. But that's not a good benchmark yet.
+Okay, vi er på vej med noget. Men det er ikke en god benchmark endnu.
 
-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.
+Forestil dig at der, mens `bench(diffSubtract)` kører, at CPU'en havde brug for at køre noget parallelt der optog ressourcer. Hvad hvis den opgave så var slut i den periode hvor `bench(diffGetTime)` kører?
 
-A pretty real scenario for a modern multi-process OS.
+Det er et meget realistisk scenarie i et moderne OS med flere porcesser der kører samtidig.
 
-As a result, the first benchmark will have less CPU resources than the second. That may lead to wrong results.
+Resultatet vil være at den første benchmark vil have mindre CPU-ressourcer end den anden. Det kan føre til forkerte resultater.
 
-**For more reliable benchmarking, the whole pack of benchmarks should be rerun multiple times.**
+**For en mere troværdig benchmarking, bør hele bunken af benchmarks blive kørt flere gange.**
 
-For example, like this:
+For eksempel, som dette:
 
 ```js run
 function diffSubtract(date1, date2) {
@@ -359,42 +361,42 @@ alert( 'Total time for diffSubtract: ' + time1 );
 alert( 'Total time for 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 motorer er begyndt at udføre avanceret optimering med fokus på "hot code" der kører mange gange - der er sjældent behov for at optimere kode der bruges sjældent. Så i eksemplet ovenfor er de første par afviklinger ikke godt optimerede. Vi ønsker måske at tilføje en "heat-up" kørsel før den egentlige benchmark for at få mere pålidelige resultater.:
 
 ```js
-// added for "heating up" prior to the main loop
+// Tilføj en "opvarming" før loopet
 bench(diffSubtract);
 bench(diffGetTime);
 
-// now benchmark
+// nu til benchmark
 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="Vær opmærksom på at lave microbenchmarking"
+Moderne JavaScript motorer udfører mange optimeringer. De kan godt tweake "artificielle tests" i forhold til "normal brug", især når vi benchmarker noget meget lille, som hvordan en operator virker eller en indbygget funktion. Så hvis du ønsker at forstå ydeevne, så studér venligst hvordan JavaScript-motoren virker. Og så vil du sandsynligvis ikke have brug for microbenchmarks overhovedet.
 
-The great pack of articles about V8 can be found at <https://mrale.ph>.
+Der findes en god samling af artikler om V8 på <https://mrale.ph>.
 ```
 
-## Date.parse from a string
+## Date.parse fra en streng
 
-The method [Date.parse(str)](mdn:js/Date/parse) can read a date from a string.
+Metoden [Date.parse(str)](mdn:js/Date/parse) kan læse en dato fra en streng.
 
-The string format should be: `YYYY-MM-DDTHH:mm:ss.sssZ`, where:
+Strengformatet skal være: `YYYY-MM-DDTHH:mm:ss.sssZ`, hvor:
 
-- `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` -- er datoen: år-måned-dag.
+- Tegnet `"T"` bruges som separator.
+- `HH:mm:ss.sss` -- er tiden: timer, minutter, sekunder og millisekunder.
+- Den frivillige `'Z'` del markerer tidszonen i formatet `+-hh:mm`. En enkeltkarakter `Z` vil betyde UTC+0.
 
-Shorter variants are also possible, like `YYYY-MM-DD` or `YYYY-MM` or even `YYYY`.
+Kortere varianter er også mulige, f.eks. `YYYY-MM-DD` eller `YYYY-MM` eller endda `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`.
+Kaldet til `Date.parse(str)` tolker strengen i det givne format og returnerer tidsstempel (antal millisekunder fra 1. januar 1970 UTC+0). Hvis formatet er ugyldigt, returneres `NaN`.
 
-For instance:
+For eksempel:
 
 ```js run
 let ms = Date.parse('2012-01-26T13:51:50.417-07:00');
@@ -402,7 +404,7 @@ let ms = Date.parse('2012-01-26T13:51:50.417-07:00');
 alert(ms); // 1327611110417  (timestamp)
 ```
 
-We can instantly create a `new Date` object from the timestamp:
+Vi kan med det samme oprette et `new Date` objekt fra tidsstempel:
 
 ```js run
 let date = new Date( Date.parse('2012-01-26T13:51:50.417-07:00') );
@@ -410,24 +412,24 @@ let date = new Date( Date.parse('2012-01-26T13:51:50.417-07:00') );
 alert(date);
 ```
 
-## Summary
+## Opsummering
 
-- 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.
+- Dato og tid i JavaScript er repræsenteret med [Date](mdn:js/Date) objektet. Vi kan ikke oprette "kun dato" eller "kun tid": `Date` objekter bærer altid begge dele.
+- Måneder tælles fra nul (ja, januar er måneden 0).
+- Dagen på ugen hentes med `getDay()`. Den er også talt fra nul (det er søndag).
+- `Date` autokorrigerer sig selv når delkomponenter sættes. Det er praktisk for at tilføje eller trække dage/måneder/timer fra hinanden.
+- Datoer kan trækkes fra hinanden, hvilket giver deres forskel i millisekunder. Det skyldes at et `Date` objekt bliver et tidsstempel når det konverteres til et tal.
+- Brug `Date.now()` for hurtigt at få det aktuelle tidsstempel.
 
-Note that unlike many other systems, timestamps in JavaScript are in milliseconds, not in seconds.
+Bemærk at, ulig mange andre systemer, er tidsstempel i JavaScript i millisekunder, ikke sekunder.
 
-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):
+Nogle gange har vi brug for en mere præcis måling af tid. JavaScript har ikke en måde at måle tid i mikrosekunder (1 milliontedel af en sekund), men de fleste miljøer har det. For eksempel har browseren [performance.now()](mdn:api/Performance/now) som giver antallet af millisekunder fra starten af sideindlæsningen med mikrosekund præcision (3 cifre efter kommaet):
 
 ```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(`Siden blev indlæst for ${performance.now()}ms siden`);
+// Noget i stil med: "Siden blev indlæst for 34731.26000000001ms siden"
+// .26 er mikrosekunder (260 mikrosekunder)
+// mere end 3 cifre efter kommaet er præcisionsfejl, kun de første 3 er korrekte
 ```
 
-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 har `microtime` modulet og andre måder. Næsten alle enheder har miljøer tilgængeligt, der tillader stor præcision. Teknisk set tillader næsten enhver enhed og miljø at få mere præcise målinger, det er bare ikke i `Date`.