feat: add german translation

i18n/de.json

@@ -0,0 +1,24 @@
+{
+    "exercise": {
+          "INTRODUCTION":           "EINFÜHRUNG"
+        , "VARIABLES":              "VARIABLEN"
+        , "STRINGS":                "STRINGS/ZEICHENKETTEN"
+        , "STRING LENGTH":          "STRING LÄNGE"
+        , "REVISING STRINGS":       "STRINGS BEARBEITEN"
+        , "NUMBERS":                "NUMBERS/ZAHLEN"
+        , "ROUNDING NUMBERS":       "NUMBERS RUNDEN"
+        , "NUMBER TO STRING":       "NUMBER ZU STRING"
+        , "IF STATEMENT":           "IF STATEMENT"
+        , "FOR LOOP":               "FOR SCHLEIFE"
+        , "ARRAYS":                 "ARRAYS/LISTEN"
+        , "ARRAY FILTERING":        "ARRAYS FILTERN"
+        , "ACCESSING ARRAY VALUES": "AUF ARRAY WERTE ZUGREIFEN"
+        , "LOOPING THROUGH ARRAYS": "SCHLEIFE ÜBER EIN ARRAY"
+        , "OBJECTS":                "OBJEKTE"
+        , "OBJECT PROPERTIES":      "OBJEKT EIGENSCHAFTEN"
+        , "OBJECT KEYS":            "OBJEKT SCHLÜSSEL/KEYS"
+        , "FUNCTIONS":              "FUNKTIONEN"
+        , "FUNCTION ARGUMENTS":     "ARGUMENTE VON FUNKTIONEN"
+        , "SCOPE":                  "GELTUNGSBEREICH"
+    }
+}

i18n/footer/de.md

@@ -0,0 +1 @@
+__Du brauchst Hilfe?__ Lies die README für diesen Kurs: https://github.com/workshopper/javascripting

i18n/troubleshooting_de.md

@@ -0,0 +1,27 @@
+---
+# O-oh, etwas funktioniert nicht.
+# Aber keine Panik!  
+---
+
+## Überprüfe deine Lösung:
+
+`Lösung
+===================`
+
+%solution%
+
+`Dein Ansatz
+===================`
+
+%attempt%
+
+`Unterschied
+===================`
+
+%diff%
+
+## Weitere Lösungsansätze:
+ * Ist der Name der Datei richtig geschrieben? Teste dies mit `ls %filename%`. Wenn die Antwort `ls: cannot access %filename%: No such file or directory` ist, dann existiert die Datei nicht, hat einen anderen Namen, oder befindet sich in einem anderen Verzeichnis.
+ * Stelle sicher, dass du keine Klammern vergessen hast, sonst kann der Compiler die Datei nicht interpretieren.
+ * Stelle sicher, dass du dich nirgends vertippt hast.
+

problems/accessing-array-values/problem_de.md

@@ -0,0 +1,47 @@
+Array-Elemente können über die Indexnummer aufgerufen werden.
+
+Die Indexnummer beginnt bei Null und endet bei der Länge des Array-Properties minus eins.
+
+Hier ist ein Beispiel:
+
+```js
+const pets = ['cat', 'dog', 'rat']
+
+console.log(pets[0])
+```
+
+Der obige Code gibt das erste Element des Array `pets` aus - die Zeichenfolge `cat`.
+
+Array-Elemente können ausschließlich über die Klammernotation aufgerufen werden.
+
+Die Punktnotation ist ungültig.
+
+Gültige Notation:
+
+```js
+console.log(pets[0])
+```
+
+Ungültige Notation:
+
+```js
+console.log(pets.1);
+```
+
+## Die Aufgabe:
+
+Erstelle eine Datei mit dem Namen `accessing-array-values.js`.
+
+Definiere in dieser Datei das Array food:
+
+```js
+const food = ['apple', 'pizza', 'pear']
+```
+
+Verwende `console.log()`, um den `zweiten` Wert des Arrays auf der Konsole auszugeben.
+
+Überprüfe, ob dein Programm korrekt ist, indem du diesen Befehl ausführst:
+
+```bash
+javascripting verify accessing-array-values.js
+```

problems/accessing-array-values/solution_de.md

@@ -0,0 +1,11 @@
+---
+
+# ZWEITES ELEMENT DES ARRAYS AUSGEGEBEN!
+
+Gut gemacht!
+
+In der nächsten Aufgabe arbeiten wir mit einem Beispiel zum Durchlaufen von Arrays.
+
+Führe `javascripting` im Terminal aus, um die nächste Aufgabe auszuwählen.
+
+---

problems/for-loop/problem_de.md

@@ -0,0 +1,40 @@
+For-Schleifen ermöglichen es dir, einen Codeblock eine bestimmte Anzahl von Wiederholungen auszuführen. Diese for-Schleife loggt zehn Mal auf der Konsole:
+
+```js
+for (let i = 0; i < 10; i++) {
+  // gibt die Zahlen 0 bis 9 aus
+  console.log(i)
+}
+```
+
+Der erste Teil, `let i = 0`, wird einmal zu Beginn der Schleife ausgeführt. Die Variable `i` wird verwendet, um zu verfolgen, wie oft die Schleife gelaufen ist.
+
+Der zweite Teil, `i < 10`, wird zu Beginn jeder Schleifen-Iteration geprüft, bevor der Code innerhalb der Schleife ausgeführt wird. Wenn die Aussage wahr ist, wird der Code innerhalb der Schleife ausgeführt. Wen falsch ist, ist die Schleife beendet. Die Anweisung `i < 10;` bedeutet, dass die Schleife so lange fortgesetzt wird, wie `i` kleiner als `10` ist.
+
+Der letzte Teil, `i++`, wird am Ende jeder Schleife ausgeführt. Dadurch wird die Variable `i` nach jeder Schleife um 1 erhöht. Sobald `i` die Zahl `10` erreicht, wird die Schleife beendet.
+
+## Die Aufgabe:
+
+Erstelle eine Datei mit dem Namen `for-loop.js`.
+
+In dieser Datei definiere eine Variable namens `total` und setze sie gleich der Zahl `0`.
+
+Definiere eine zweite Variable mit dem Namen `limit` und mache sie gleich der Zahl `10`.
+
+Erstelle eine for-Schleife mit einer Variablen `i`, die bei 0 beginnt und bei jedem Durchlauf der Schleife um 1 erhöht wird. Die Schleife sollte so lange laufen, wie `i` kleiner als `limit` ist.
+
+Bei jeder Iteration der Schleife addiere die Zahl `i` zur Variablen `total`. Um dies zu tun, kannst du diese Anweisung verwenden:
+
+``js
+total += i
+```
+
+Wenn diese Anweisung in einer for-Schleife verwendet wird, kann man sie auch als _Akkumulator_ bezeichnen.  Stelle dir die Anweisung wie die laufende Summe einer Registrierkasse vor, bei der jeder Posten gescannt und addiert wird.  In dieser Aufgabe hast du 10 Artikel, die zufällig jeweils um 1 teurer werden (wobei der erste Artikel gratis ist!).
+
+Nach der for-Schleife gibst du mit `console.log()` die Variable `total` auf dem Terminal aus.
+
+Überprüfe, ob dein Programm korrekt ist, indem du diesen Befehl ausführst:
+
+``bash
+javascripting verify for-loop.js
+```

problems/for-loop/solution_de.md

@@ -0,0 +1,11 @@
+---
+
+# DIE SUMME IST 45
+
+Dies ist eine grundlegende Einführung in for-Schleifen, die in vielen Situationen nützlich sind, insbesondere in Kombination mit anderen Datentypen wie Strings und Arrays.
+
+In der nächsten Aufgabe werden wir anfangen, mit **Arrays** zu arbeiten.
+
+Führe `javascripting` in der Konsole aus, um die nächste Aufgabe zu wählen.
+
+---

problems/functions/problem_de.md

@@ -0,0 +1,37 @@
+Eine Funktion ist ein Block von Code, der eine Eingabe entgegennimmt, diese Eingabe verarbeitet und dann eine Ausgabe produziert.
+
+Hier ist ein Beispiel:
+
+```js
+function example (x) {
+  return x * 2
+}
+```
+
+Wir können diese Funktion wie folgt **aufrufen**, um die Zahl 10 zu erhalten:
+
+```js
+example(5)
+```
+
+Das obige Beispiel geht davon aus, dass die Funktion `example` eine Zahl als Argument -- als Eingabe -- entgegennimmt und diese Zahl mit 2 multipliziert zurückgibt.
+
+## Die Aufgabe:
+
+Erstelle eine Datei namens `functions.js`.
+
+Definiere in dieser Datei eine Funktion namens `eat`, die ein Argument namens `food` annimmt und erwartet, dass es sich dabei um einen String handelt.
+
+Gib innerhalb der Funktion das `food`-Argument auf folgende Weise zurück:
+
+```js
+return food + ' tasted really good.'
+```
+
+Rufe die `eat()`-Funktion mit dem String `bananas` als Argument innerhalb der Klammern von `console.log()` auf.
+
+Überprüfe, ob dein Programm korrekt ist, indem du diesen Befehl ausführst:
+
+```bash
+javascripting verify functions.js
+```

problems/functions/solution_de.md

@@ -0,0 +1,9 @@
+---
+
+# WOOO BANANEN
+
+Du hast es geschafft! Du hast eine Funktion erstellt, die Eingaben entgegennimmt, verarbeitet und Ausgaben liefert.
+
+Führe `javascripting` in der Konsole aus, um die nächste Aufgabe auszuwählen.
+
+---

problems/if-statement/problem_de.md

@@ -0,0 +1,32 @@
+Bedingte Anweisungen werden verwendet, um den Kontrollfluss eines Programms auf der Grundlage einer bestimmten booleschen Bedingung zu ändern.
+
+Eine bedingte Anweisung sieht wie folgt aus:
+
+```js
+if (n > 1) {
+  console.log('die Variable n ist größer als 1.')
+} else {
+  console.log('die Variable n ist kleiner oder gleich 1.')
+}
+```
+
+Innerhalb der Klammern musst du eine logische Anweisung eingeben, was bedeutet, dass das Ergebnis der Anweisung entweder wahr oder falsch ist. 
+
+Der else-Block ist optional und enthält den Code, der ausgeführt wird, wenn die Anweisung falsch ist.
+
+## Die Aufgabe:
+
+Erstelle eine Datei mit dem Namen `if-statement.js`.
+
+Deklariere in dieser Datei eine Variable namens `fruit`.
+
+Weise der Variable `fruit` den String-Wert **"orange"** zu.
+
+Verwende dann `console.log()`, um "**The fruit name has more than five characters.**" zu drucken, wenn die Länge des Wertes von `fruit` größer als fünf ist.
+Andernfalls drucke "**The fruit name has five characters or less.**"
+
+Überprüfe, ob dein Programm korrekt ist, indem du diesen Befehl ausführst:
+
+```bash
+javascripting verify if-statement.js
+```

problems/if-statement/solution_de.md

@@ -0,0 +1,11 @@
+---
+
+# CONDITIONAL MASTER
+
+Du hast es geschafft! Die Zeichenkette `orange` hat mehr als fünf Zeichen.
+
+Mach dich als nächstes bereit für die **for-Schleife**!
+
+Führe `javascripting` in der Konsole aus, um die nächste Aufgabe zu wählen.
+
+---

problems/introduction/problem_de.md

@@ -0,0 +1,46 @@
+Damit alles seine Ordnung hat, erstellen wir zuerst einen Ordner für diesen Workshop.
+
+Führe diesen Befehl in der Konsole aus, um ein Verzeichnis mit dem Namen `javascripting` zu erstellen (oder etwas anderes, wenn du möchtest):
+
+```bash
+mkdir javascripting
+```
+
+Wechsel in das Verzeichnis `javascripting`:
+
+```bash
+cd javascripting
+```
+
+Erstelle eine Datei mit dem Namen `introduction.js`:
+
+```bash
+touch introduction.js
+```
+
+Oder, für Windows: 
+```bash
+type NUL > introduction.js
+```
+(`type` ist Teil des Befehls!)
+
+Öffnen die Datei in deinem bevorzugten Editor und füge diesen Text ein:
+
+```js
+console.log('hello')
+```
+
+Speicher die Datei und überprüfen dann, ob dein Programm korrekt ist, indem du diese Befehl ausführst:
+
+```bash
+javascripting verify introduction.js
+```
+
+Übrigens, in diesem Tutorial kannst du der Datei, mit der du arbeitest, jeden beliebigen Namen geben.
+Wenn du also für jede Übung eine Datei Namens `catsAreAwesome.js` verwenden möchtest, kannst du das tun.
+Stelle dann sicher, dass du immer diesen Befehl ausführst:
+
+```bash
+javascripting verify catsAreAwesome.js
+```
+

problems/introduction/solution_de.md

@@ -0,0 +1,19 @@
+---
+
+# GESCHAFFT! 🎉
+
+Alles, was zwischen den Klammern von `console.log()` steht, wird auf dem Terminal ausgegeben.
+
+Das hier: 
+
+```js
+console.log('Hallo')
+```
+
+gibt `Hallo` auf dem Terminal aus.
+
+Zur Zeit geben wir eine **Zeichenfolge** auf dem Terminal aus: `Hallo`.
+
+In der nächsten Aufgabe konzentrieren wir uns darauf, etwas über **Variablen** zu lernen.
+
+Führe `javascripting` in der Konsole aus, um die nächste Aufgabe zu wählen.

problems/looping-through-arrays/problem_de.md

@@ -0,0 +1,43 @@
+Für diese Aufgabe werden wir eine **For-Schleife** verwenden, um auf eine Liste von Werten in einem Array zuzugreifen und diese zu manipulieren.
+
+Der Zugriff auf Array-Werte kann mit einem Integer erfolgen.
+
+Jedes Element in einem Array wird durch eine Nummer identifiziert, die bei `0` beginnt.
+
+In diesem Array wird `hi` also durch die Nummer `1` identifiziert:
+
+```js
+const greetings = ['Hallo', 'Hi', 'Guten Morgen']
+```
+
+Es kann so aufgerufen werden:
+
+```js
+greetings[1]
+```
+
+Daher verwenden wir in einer **For-Schleife** die Variable `i` innerhalb der eckigen Klammern anstatt direkt einen Integer zu verwenden.
+
+## Die Aufgabe:
+
+Erstelle eine Datei mit dem Namen `looping-through-arrays.js`.
+
+Definiere in dieser Datei eine Variable mit dem Namen pets, die auf folgendes Array verweist:
+
+```js
+['cat', 'dog', 'rat']
+```
+
+Erstelle eine Schleife, die jeden String im Array so verändert, dass er im Plural steht.
+Du wirst innerhalb der Schleife folgende Anweisung verwenden:
+
+```js
+pets[i] = pets[i] + 's'
+```
+
+Verwende nach der Schleife `console.log()`, um das Array `pets` im Terminal auszugeben.
+Überprüfe, ob dein Programm korrekt funktioniert, indem du folgenden Befehl ausführst:
+
+```bash
+javascripting verify looping-through-arrays.js
+```

problems/looping-through-arrays/solution_de.md

@@ -0,0 +1,11 @@
+---
+
+# Erfolg! Viele Tiere!
+
+Jetzt sind alle Elemente im Array `pets` im Plural!
+
+In der nächsten Aufgabe werden wir uns von Arrays zur Arbeit mit *Objekten* bewegen.
+
+Führe `javascripting` im Terminal aus, um die nächste Aufgabe auszuwählen.
+
+---