Map and Set

1-js/05-data-types/07-map-set/01-array-unique-map/task.md

@@ -2,17 +2,17 @@ importance: 5
 
 ---
 
-# Filter unique array members
+# Filtere eindeutige Array-Elemente
 
-Let `arr` be an array.
+Lass `arr` ein Array sein.
 
-Create a function `unique(arr)` that should return an array with unique items of `arr`.
+Erstelle eine Funktion `unique(arr)`, die ein Array mit den eindeutigen Elementen von `arr` zurückgeben sollte.
 
-For instance:
+Zum Beispiel:
 
 ```js
 function unique(arr) {
-  /* your code */
+  /* Dein Code */
 }
 
 let values = ["Hare", "Krishna", "Hare", "Krishna",
@@ -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. Hier werden Zeichenketten verwendet, es können aber Werte jeglichen Typs sein.
 
-P.P.S. Use `Set` to store unique values.
+P.P.S. Verwende `Set`, um eindeutige Werte zu speichern.

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.
+Um alle Anagramme zu finden, lassen wir uns jede Zeichenkette in Buchstaben aufteilen und sortieren sie. Wenn sie buchstabensortiert sind, sind alle Anagramme gleich.
 
-For instance:
+Zum Beispiel:
 
 ```
 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:
+Wir verwenden die buchstabensortierten Varianten als Schlüssel in einer Map, um nur einen Wert pro Schlüssel zu speichern:
 
 ```js run
 function aclean(arr) {
   let map = new Map();
 
   for (let word of arr) {
-    // split the word by letters, sort them and join back
+    // das Wort in Buchstaben aufteilen, sortieren und wieder zusammenfügen
 *!*
     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 `(*)`.
+Das Buchstabensortieren wird durch die Aufrufkette in der Zeile `(*)` durchgeführt.
 
-For convenience let's split it into multiple lines:
+Zur besseren Übersicht teilen wir es in mehrere Zeilen auf:
 
 ```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'`.
+Zwei unterschiedliche Wörter `'PAN'` und `'nap'` erhalten dieselbe buchstabensortierte Form `'anp'`.
 
-The next line put the word into the map:
+Die nächste Zeile fügt das Wort in die Map ein:
 
 ```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.
+Wenn wir erneut auf ein Wort mit derselben buchstabensortierten Form stoßen, wird der vorherige Wert mit demselben Schlüssel in der Map überschrieben. Daher haben wir immer maximal ein Wort pro Buchstabenform.
 
-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.
+Am Ende erzeugt `Array.from(map.values())` ein iterierbares über die Werte der Map (wir benötigen die Schlüssel im Ergebnis nicht) und gibt ein Array davon zurück.
 
-Here we could also use a plain object instead of the `Map`, because keys are strings.
+Hier könnten wir anstelle der `Map` auch ein einfaches Objekt verwenden, da die Schlüssel Zeichenketten sind.
 
-That's how the solution can look:
+So könnte die Lösung aussehen:
 
 ```js run demo
 function aclean(arr) {

1-js/05-data-types/07-map-set/02-filter-anagrams/task.md

@@ -1,28 +1,28 @@
+---
 importance: 4
 
 ---
 
-# Filter anagrams
+# Anagramme filtern
 
-[Anagrams](https://en.wikipedia.org/wiki/Anagram) are words that have the same number of same letters, but in different order.
+[Anagramme](https://de.wikipedia.org/wiki/Anagramm) sind Wörter, die die gleiche Anzahl von Buchstaben haben, aber in einer anderen Reihenfolge.
 
-For instance:
+Zum Beispiel:
 
 ```
 nap - pan
 ear - are - era
 cheaters - hectares - teachers
 ```
 
-Write a function `aclean(arr)` that returns an array cleaned from anagrams.
+Schreibe eine Funktion `aclean(arr)`, die ein Array zurückgibt, das von Anagrammen bereinigt ist.
 
-For instance:
+Zum Beispiel:
 
 ```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" oder "PAN,cheaters,era"
 ```
 
-From every anagram group should remain only one word, no matter which one.
-
+Von jeder Anagrammgruppe sollte nur ein Wort übrig bleiben, egal welches.

1-js/05-data-types/07-map-set/03-iterable-keys/solution.md

@@ -1,7 +1,6 @@
+Das liegt daran, dass `map.keys()` ein iterierbares Objekt zurückgibt, aber kein Array.
 
-That's because `map.keys()` returns an iterable, but not an array.
-
-We can convert it into an array using `Array.from`:
+Wir können es mit `Array.from` in ein Array umwandeln:
 
 
 ```js run

1-js/05-data-types/07-map-set/03-iterable-keys/task.md

@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Iterable keys
+# Iterierbare Schlüssel
 
-We'd like to get an array of `map.keys()` in a variable and then apply array-specific methods to it, e.g. `.push`.
+Wir möchten ein Array von `map.keys()` in einer Variablen haben und dann darauf array-spezifische Methoden anwenden, z.B. `.push`.
 
-But that doesn't work:
+Aber das funktioniert nicht:
 
 ```js run
 let map = new Map();
@@ -16,9 +16,10 @@ map.set("name", "John");
 let keys = map.keys();
 
 *!*
-// Error: keys.push is not a function
+// Fehler: keys.push ist keine Funktion
 keys.push("more");
 */!*
 ```
 
-Why? How can we fix the code to make `keys.push` work?
+Warum? Wie können wir den Code korrigieren, damit `keys.push` funktioniert?
+