javascript-tutorial · ockley · Feb 12, 2026 · Feb 12, 2026 · Feb 12, 2026
diff --git a/1-js/05-data-types/07-map-set/01-array-unique-map/_js.view/test.js b/1-js/05-data-types/07-map-set/01-array-unique-map/_js.view/test.js
@@ -1,13 +1,13 @@
-describe("unique", function() {
-  it("removes non-unique elements", function() {
+describe("unique", function () {
+  it("fjerner ikke-unikke elementer", function () {
     let strings = ["Hare", "Krishna", "Hare", "Krishna",
       "Krishna", "Krishna", "Hare", "Hare", ":-O"
     ];
 
     assert.deepEqual(unique(strings), ["Hare", "Krishna", ":-O"]);
   });
 
-  it("does not change the source array", function() {
+  it("ændrer ikke det oprindelige array", function () {
     let strings = ["Krishna", "Krishna", "Hare", "Hare"];
     unique(strings);
     assert.deepEqual(strings, ["Krishna", "Krishna", "Hare", "Hare"]);

diff --git a/1-js/05-data-types/07-map-set/01-array-unique-map/task.md b/1-js/05-data-types/07-map-set/01-array-unique-map/task.md
@@ -2,13 +2,13 @@ importance: 5
 
 ---
 
-# Filter unique array members
+# Filtrer unikke array-medlemmer
 
-Let `arr` be an array.
+Lad `arr` være et array.
 
-Create a function `unique(arr)` that should return an array with unique items of `arr`.
+Opret en funktion `unique(arr)`, der skal returnere et array med unikke elementer fra `arr`.
 
-For instance:
+For eksempel:
 
 ```js
 function unique(arr) {
@@ -22,6 +22,6 @@ let values = ["Hare", "Krishna", "Hare", "Krishna",
 alert( unique(values) ); // Hare, Krishna, :-O
 ```
 
-P.S. Here strings are used, but can be values of any type.
+P.S. Her bruges strenge, men det kan være værdier af enhver type.
 
-P.P.S. Use `Set` to store unique values.
+P.P.S. Brug `Set` til at gemme unikke værdier.
diff --git a/1-js/05-data-types/07-map-set/02-filter-anagrams/_js.view/test.js b/1-js/05-data-types/07-map-set/02-filter-anagrams/_js.view/test.js
@@ -2,9 +2,9 @@ function intersection(arr1, arr2) {
   return arr1.filter(item => arr2.includes(item));
 }
 
-describe("aclean", function() {
+describe("aclean", function () {
 
-  it("returns exactly 1 word from each anagram set", function() {
+  it("returner præcis 1 ord fra hvert anagram sæt", function () {
     let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
 
     let result = aclean(arr);
@@ -16,7 +16,7 @@ describe("aclean", function() {
 
   });
 
-  it("is case-insensitive", function() {
+  it("er case-insensitive", function () {
     let arr = ["era", "EAR"];
     assert.equal(aclean(arr).length, 1);
   });

diff --git a/1-js/05-data-types/07-map-set/02-filter-anagrams/solution.md b/1-js/05-data-types/07-map-set/02-filter-anagrams/solution.md
@@ -1,6 +1,6 @@
-To find all anagrams, let's split every word to letters and sort them. When letter-sorted, all anagrams are same.
+For at finde alle anagrammer kan vi opdele hvert ord i bogstaver og sortere dem. Når bogstaverne er sorteret, er alle anagrammer ens.
 
-For instance:
+For eksempel:
 
 ```
 nap, pan -> anp
@@ -9,14 +9,14 @@ cheaters, hectares, teachers -> aceehrst
 ...
 ```
 
-We'll use the letter-sorted variants as map keys to store only one value per each key:
+Vi bruger de bogstav-sorterede varianter som map-nøgler for kun at gemme én værdi per nøgle:
 
 ```js run
 function aclean(arr) {
   let map = new Map();
 
   for (let word of arr) {
-    // split the word by letters, sort them and join back
+    // opsplit ordet i bogstaver, sorter dem og sæt dem sammen igen
 *!*
     let sorted = word.toLowerCase().split('').sort().join(''); // (*)
 */!*
@@ -31,9 +31,9 @@ let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
 alert( aclean(arr) );
 ```
 
-Letter-sorting is done by the chain of calls in the line `(*)`.
+Bogstav-sortering udføres af kæden af kald i linjen `(*)`.
 
-For convenience let's split it into multiple lines:
+For nemheds skyld deler vi det op i flere linjer:
 
 ```js
 let sorted = word // PAN
@@ -43,21 +43,21 @@ let sorted = word // PAN
   .join(''); // anp
 ```
 
-Two different words `'PAN'` and `'nap'` receive the same letter-sorted form `'anp'`.
+To forskellige ord `'PAN'` og `'nap'` får den samme bogstav-sorterede form `'anp'`.
 
-The next line put the word into the map:
+Næste linje sætter ordet ind i map'et med den bogstav-sorterede form som nøgle:
 
 ```js
 map.set(sorted, word);
 ```
 
-If we ever meet a word the same letter-sorted form again, then it would overwrite the previous value with the same key in the map. So we'll always have at maximum one word per letter-form.
+Hvis vi nogensinde møder et ord med den samme bogstav-sorterede form igen, vil det overskrive den tidligere værdi med den samme nøgle i map'et. Så vi vil altid have højst ét ord per bogstav-form.
 
-At the end `Array.from(map.values())` takes an iterable over map values (we don't need keys in the result) and returns an array of them.
+Til sidst tager `Array.from(map.values())` en iterable over map-værdier (vi behøver ikke nøgler i resultatet) og returnerer et array af dem.
 
-Here we could also use a plain object instead of the `Map`, because keys are strings.
+Her kunne vi også bruge et almindeligt objekt i stedet for `Map`, fordi nøglerne er strenge.
 
-That's how the solution can look:
+En løsning kan se sådan ud:
 
 ```js run demo
 function aclean(arr) {

diff --git a/1-js/05-data-types/07-map-set/02-filter-anagrams/task.md b/1-js/05-data-types/07-map-set/02-filter-anagrams/task.md
@@ -2,27 +2,27 @@ importance: 4
 
 ---
 
-# Filter anagrams
+# Filtrer anagrammer
 
-[Anagrams](https://en.wikipedia.org/wiki/Anagram) are words that have the same number of same letters, but in different order.
+[Anagrams](https://en.wikipedia.org/wiki/Anagram) er ord der har det samme antal individuelle tegn men i en anden rækkefølge.
 
-For instance:
+For eksempel:
 
 ```
 nap - pan
 ear - are - era
 cheaters - hectares - teachers
 ```
 
-Write a function `aclean(arr)` that returns an array cleaned from anagrams.
+Skriv en funktion `aclean(arr)` der returnerer et array renset for anagrammer.
 
-For instance:
+For eksempel:
 
 ```js
 let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
 
-alert( aclean(arr) ); // "nap,teachers,ear" or "PAN,cheaters,era"
+alert( aclean(arr) ); // "nap,teachers,ear" eller "PAN,cheaters,era"
 ```
 
-From every anagram group should remain only one word, no matter which one.
+Fra hvert anagramgruppe skal der kun være ét ord tilbage, uanset hvilket.
 
diff --git a/1-js/05-data-types/07-map-set/03-iterable-keys/solution.md b/1-js/05-data-types/07-map-set/03-iterable-keys/solution.md
@@ -1,7 +1,7 @@
 
-That's because `map.keys()` returns an iterable, but not an array.
+Det er fordi `map.keys()` returnerer en iterable, men ikke et array.
 
-We can convert it into an array using `Array.from`:
+Vi kan konvertere det til et array ved hjælp af `Array.from`:
 
 
 ```js run

diff --git a/1-js/05-data-types/07-map-set/03-iterable-keys/task.md b/1-js/05-data-types/07-map-set/03-iterable-keys/task.md
@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Iterable keys
+# Itererbare nøgler
 
-We'd like to get an array of `map.keys()` in a variable and then apply array-specific methods to it, e.g. `.push`.
+Vi vil gerne have et array af `map.keys()` i en variabel og derefter anvende array-specifikke metoder på det, f.eks. `.push`.
 
-But that doesn't work:
+Men det virker ikke:
 
 ```js run
 let map = new Map();
@@ -16,9 +16,9 @@ map.set("name", "John");
 let keys = map.keys();
 
 *!*
-// Error: keys.push is not a function
+// Fejl: keys.push er ikke en funktion
 keys.push("more");
 */!*
 ```
 
-Why? How can we fix the code to make `keys.push` work?
+Hvorfor? Hvordan kan vi rette koden, så `keys.push` virker?