chore(i18n,learn): processed translations (#47330)

curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-arguments-passed-in-the-wrong-order-when-calling-a-function.md

@@ -0,0 +1,57 @@
+---
+id: 587d7b85367417b2b2512b3a
+title: Fange Argumente ab, die beim Aufruf einer Funktion in der falschen Reihenfolge übergeben wurden
+challengeType: 1
+forumTopicId: 301184
+dashedName: catch-arguments-passed-in-the-wrong-order-when-calling-a-function
+---
+
+# --description--
+
+Wenn man die Diskussion über aufrufende Funktionen fortsetzt, ist der nächste Fehler, auf den man achten sollte, die Angabe der Argumente einer Funktion in der falschen Reihenfolge. Wenn die Argumente von unterschiedlichem Typ sind, z. B. eine Funktion, die ein Array und eine ganze Zahl (Integer) erwartet, wird dies wahrscheinlich einen Laufzeitfehler auslösen. Wenn die Argumente vom gleichen Typ sind (zum Beispiel alle Integer), dann ergibt die Logik des Codes keinen Sinn. Stelle sicher, dass alle erforderlichen Argumente in der richtigen Reihenfolge angegeben sind, um diese Probleme zu vermeiden.
+
+# --instructions--
+
+Die Funktion `raiseToPower` erhöht eine Basis um einen Exponenten. Leider wird sie nicht richtig aufgerufen - korrigiere den Code, damit der Wert von `power` die erwartete 8 ergibt.
+
+# --hints--
+
+Dein Code sollte die Variable `power` so ändern, dass sie 2³ entspricht und nicht 3².
+
+```js
+assert(power == 8);
+```
+
+Dein Code sollte die richtige Reihenfolge der Argumente für den Funktionsaufruf von `raiseToPower` verwenden.
+
+```js
+assert(code.match(/raiseToPower\(\s*?base\s*?,\s*?exp\s*?\);/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function raiseToPower(b, e) {
+  return Math.pow(b, e);
+}
+
+let base = 2;
+let exp = 3;
+let power = raiseToPower(exp, base);
+console.log(power);
+```
+
+# --solutions--
+
+```js
+function raiseToPower(b, e) {
+ return Math.pow(b, e);
+}
+
+let base = 2;
+let exp = 3;
+let power = raiseToPower(base, exp);
+console.log(power);
+```

curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-missing-open-and-closing-parenthesis-after-a-function-call.md

@@ -0,0 +1,69 @@
+---
+id: 587d7b85367417b2b2512b39
+title: Fehlende offene und schließende Klammern nach einem Funktionsaufruf abfangen
+challengeType: 1
+forumTopicId: 301185
+dashedName: catch-missing-open-and-closing-parenthesis-after-a-function-call
+---
+
+# --description--
+
+Wenn eine Funktion oder Methode keine Argumente annimmt, kann es sein, dass Du beim Aufruf vergisst, die (leeren) öffnenden und schließenden Klammern zu setzen. Oft wird das Ergebnis eines Funktionsaufrufs in einer Variablen gespeichert, die du dann in deinem Code weiterverwenden kannst. Dieser Fehler kann erkannt werden, indem Variablenwerte (oder ihre Typen) auf der Konsole protokolliert werden und festgestellt wird, dass eine Variable auf eine Funktionsreferenz gesetzt ist, anstatt auf den erwarteten Wert, den die Funktion zurückgibt.
+
+Die Variablen im folgenden Beispiel sind unterschiedlich:
+
+```js
+function myFunction() {
+  return "You rock!";
+}
+let varOne = myFunction;
+let varTwo = myFunction();
+```
+
+Hier ist `varOne` die Funktion `myFunction` und `varTwo` ist der String `You rock!`.
+
+# --instructions--
+
+Korrigiere den Code so, dass die Variable `result` auf den Wert gesetzt wird, der beim Aufruf der Funktion `getNine` zurückgegeben wird.
+
+# --hints--
+
+Dein Code sollte die Variable `result` so verändern, dass sie auf die Zahl gesetzt wird, die die Funktion `getNine` zurückgibt.
+
+```js
+assert(result == 9);
+```
+
+Dein Code sollte die Funktion `getNine` aufrufen.
+
+```js
+assert(code.match(/getNine\(\)/g).length == 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function getNine() {
+  let x = 6;
+  let y = 3;
+  return x + y;
+}
+
+let result = getNine;
+console.log(result);
+```
+
+# --solutions--
+
+```js
+function getNine() {
+ let x = 6;
+ let y = 3;
+ return x + y;
+}
+
+let result = getNine();
+console.log(result);
+```

curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-misspelled-variable-and-function-names.md

@@ -0,0 +1,69 @@
+---
+id: 587d7b84367417b2b2512b35
+title: Falsch geschriebene Variablen- und Funktionsnamen abfangen
+challengeType: 1
+forumTopicId: 301186
+dashedName: catch-misspelled-variable-and-function-names
+---
+
+# --description--
+
+Die Methoden `console.log()` und `typeof` sind die beiden wichtigsten Methoden, um Zwischenwerte und Typen von Programmausgaben zu überprüfen. Jetzt ist es an der Zeit, sich mit den häufigsten Formen von Bugs zu beschäftigen. Ein Problem auf der Ebene der Syntax, mit dem schnelle Tipper mitfühlen können, ist der einfache Rechtschreibfehler.
+
+Vertauschte, fehlende oder falsch großgeschriebene Zeichen in einem Variablen- oder Funktionsnamen führen dazu, dass der Browser nach einem Objekt sucht, das nicht existiert - und sich in Form eines Referenzfehlers beschwert. Bei JavaScript-Variablen- und Funktionsnamen wird zwischen Groß- und Kleinschreibung unterschieden.
+
+# --instructions--
+
+Korrigiere die beiden Rechtschreibfehler im Code, damit die Berechnung des `netWorkingCapital` funktioniert.
+
+# --hints--
+
+Überprüfe die Schreibweise der beiden Variablen, die in der Berechnung des NetWorkingCapitals verwendet werden. Die Konsolenausgabe sollte Folgendes anzeigen: " Net working capital is: 2".
+
+```js
+assert(netWorkingCapital === 2);
+```
+
+Es sollten keine falsch geschriebenen Variablen im Code vorkommen.
+
+```js
+assert(!code.match(/recievables/g));
+```
+
+Die Variable `receivables` sollte im Code richtig deklariert und verwendet werden.
+
+```js
+assert(code.match(/receivables/g).length == 2);
+```
+
+Es sollten keine falsch geschriebenen Variablen im Code vorkommen.
+
+```js
+assert(!code.match(/payable;/g));
+```
+
+Die Variable `payables` sollte im Code richtig deklariert und verwendet werden.
+
+```js
+assert(code.match(/payables/g).length == 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let receivables = 10;
+let payables = 8;
+let netWorkingCapital = recievables - payable;
+console.log(`Net working capital is: ${netWorkingCapital}`);
+```
+
+# --solutions--
+
+```js
+let receivables = 10;
+let payables = 8;
+let netWorkingCapital = receivables - payables;
+console.log(`Net working capital is: ${netWorkingCapital}`);
+```

curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-mixed-usage-of-single-and-double-quotes.md

@@ -0,0 +1,63 @@
+---
+id: 587d7b84367417b2b2512b37
+title: Gemischte Verwendung von einfachen und doppelten Anführungszeichen abfangen
+challengeType: 1
+forumTopicId: 301188
+dashedName: catch-mixed-usage-of-single-and-double-quotes
+---
+
+# --description--
+
+JavaScript erlaubt die Verwendung von einfachen (`'`) und doppelten (`"`) Anführungszeichen zur Deklaration eines Strings. Die Entscheidung für eine der beiden Varianten ist in der Regel eine Frage der persönlichen Vorliebe, es gibt aber auch Ausnahmen.
+
+Zwei Möglichkeiten zu haben ist toll, wenn ein String Kontraktionen oder einen anderen Textteil enthält, der in Anführungszeichen steht. Achte nur darauf, dass du den String nicht zu früh schließt, denn das führt zu einem Syntaxfehler.
+
+Hier sind einige Beispiele für gemischte Anführungszeichen:
+
+```js
+const grouchoContraction = "I've had a perfectly wonderful evening, but this wasn't it.";
+const quoteInString = "Groucho Marx once said 'Quote me as saying I was mis-quoted.'";
+const uhOhGroucho = 'I've had a perfectly wonderful evening, but this wasn't it.';
+```
+
+Die ersten Beiden sind richtig, aber das Dritte ist falsch.
+
+Natürlich ist es in Ordnung, nur eine Art von Anführungszeichen zu verwenden. Du kannst die Anführungszeichen innerhalb des Strings mit dem Escape-Zeichen Backslash (`\`) umgehen:
+
+```js
+const allSameQuotes = 'I\'ve had a perfectly wonderful evening, but this wasn\'t it.';
+```
+
+# --instructions--
+
+Korrigiere den String so, dass er entweder andere Anführungszeichen für den Wert `href` verwendet oder die vorhandenen escaped werden. Behalte die doppelten Anführungszeichen um den gesamten String herum bei.
+
+# --hints--
+
+Dein Code sollte die Anführungszeichen um den Wert `href` `#Home` korrigieren, indem du sie entweder änderst oder umgehst (escaping).
+
+```js
+assert(code.match(/<a href=\s*?('|\\")#Home\1\s*?>/g));
+```
+
+Dein Code sollte die doppelten Anführungszeichen um den gesamten String herum beibehalten.
+
+```js
+assert(code.match(/"<p>.*?<\/p>";/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let innerHtml = "<p>Click here to <a href="#Home">return home</a></p>";
+console.log(innerHtml);
+```
+
+# --solutions--
+
+```js
+let innerHtml = "<p>Click here to <a href=\"#Home\">return home</a></p>";
+console.log(innerHtml);
+```

curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-off-by-one-errors-when-using-indexing.md

@@ -0,0 +1,93 @@
+---
+id: 587d7b86367417b2b2512b3b
+title: Abfangen von Fehlern bei der Indizierung um eins
+challengeType: 1
+forumTopicId: 301189
+dashedName: catch-off-by-one-errors-when-using-indexing
+---
+
+# --description--
+
+<dfn>Off-by-one-Fehler</dfn> (manchmal auch OBOE genannt) treten auf, wenn du versuchst, einen bestimmten Index eines Strings oder Arrays anzusteuern (um ein Segment zu zerteilen oder darauf zuzugreifen), oder wenn du eine Schleife über die Indizes der Strings durchläufst. Die Indizierung in JavaScript beginnt bei Null, nicht bei Eins, was bedeutet, dass der letzte Index immer um Eins kleiner ist als die Länge des Elements. Wenn du versuchst, auf einen Index zuzugreifen, der gleich der Länge ist, kann das Programm einen Referenzfehler "index out of range" oder `undefined` ausgeben.
+
+Wenn du String- oder Array-Methoden verwendest, die Indexbereiche als Argumente annehmen, ist es hilfreich, die Dokumentation zu lesen und zu wissen, ob sie inklusiv sind (das Element am angegebenen Index ist Teil des Rückgabewerts) oder nicht. Hier sind einige Beispiele von Fehlern, die sich um eins unterscheiden:
+
+```js
+let alphabet = "abcdefghijklmnopqrstuvwxyz";
+let len = alphabet.length;
+for (let i = 0; i <= len; i++) {
+  console.log(alphabet[i]);
+}
+for (let j = 1; j < len; j++) {
+  console.log(alphabet[j]);
+}
+for (let k = 0; k < len; k++) {
+  console.log(alphabet[k]);
+}
+```
+
+Das erste Beispiel macht eine Schleife zu viel und das zweite eine Schleife zu wenig (es fehlt der erste Index, 0). Das dritte Beispiel ist korrekt.
+
+# --instructions--
+
+Behebe die beiden Indizierungsfehler in der folgenden Funktion, damit alle Zahlen 1 bis 5 auf der Konsole ausgegeben werden.
+
+# --hints--
+
+Dein Code sollte die Anfangsbedingung der Schleife so setzen, dass sie beim ersten Index beginnt.
+
+```js
+assert(code.match(/i\s*?=\s*?0\s*?;/g).length == 1);
+```
+
+Dein Code sollte die Anfangsbedingung der Schleife so festlegen, dass der Index bei 0 beginnt.
+
+```js
+assert(!code.match(/i\s?=\s*?1\s*?;/g));
+```
+
+Dein Code sollte die Endbedingung der Schleife so setzen, dass sie beim letzten Index anhält.
+
+```js
+assert(code.match(/i\s*<\s*len\s*;|i\s*<=\s*len\s*-\s*1\s*;/g).length == 1);
+```
+
+Dein Code sollte die Endbedingung der Schleife so festlegen, dass sie bei 1 vor der Länge aufhört.
+
+```js
+assert(!code.match(/i\s*?<=\s*?len;/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function countToFive() {
+  let firstFive = "12345";
+  let len = firstFive.length;
+  // Only change code below this line
+  for (let i = 1; i <= len; i++) {
+  // Only change code above this line
+    console.log(firstFive[i]);
+  }
+}
+
+countToFive();
+```
+
+# --solutions--
+
+```js
+function countToFive() {
+ let firstFive = "12345";
+ let len = firstFive.length;
+ // Only change code below this line
+ for (let i = 0; i < len; i++) {
+ // Only change code above this line
+   console.log(firstFive[i]);
+ }
+}
+
+countToFive();
+```

curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-unclosed-parentheses-brackets-braces-and-quotes.md

@@ -0,0 +1,49 @@
+---
+id: 587d7b84367417b2b2512b36
+title: 'Nicht geschlossene Klammern, geschweifte Klammern und Anführungszeichen abfangen'
+challengeType: 1
+forumTopicId: 301190
+dashedName: catch-unclosed-parentheses-brackets-braces-and-quotes
+---
+
+# --description--
+
+Ein weiterer Syntaxfehler, auf den du achten solltest, ist, dass alle öffnenden Klammern, geschweifte Klammern und Anführungszeichen ein schließendes Paar besitzen. Das Vergessen eines Teils passiert oft, wenn du bestehenden Code bearbeitest und Elemente mit einem der Paartypen einfügst. Sei außerdem vorsichtig, wenn du Codeblöcke in andere verschachtelst, z. B. wenn du eine Rückruffunktion (Callback-Funktion) als Argument zu einer Methode hinzufügst.
+
+Eine Möglichkeit, diesen Fehler zu vermeiden, besteht darin, dass du, sobald du das erste Zeichen getippt hast, sofort das letzte Zeichen einfügst, dann den Cursor wieder dazwischen setzt und mit der Programmierung fortfährst. Zum Glück erzeugen die meisten modernen Code-Editoren die zweite Hälfte des Paares automatisch.
+
+# --instructions--
+
+Behebe die beiden Paarfehler im Code.
+
+# --hints--
+
+Dein Code sollte das fehlende Stück des Arrays reparieren.
+
+```js
+assert(code.match(/myArray\s*?=\s*?\[\s*?1\s*?,\s*?2\s*?,\s*?3\s*?\];/g));
+```
+
+Dein Code sollte den fehlenden Teil der Methode `.reduce()` beheben. Die Konsolenausgabe sollte Folgendes anzeigen: `Sum of array values is: 6`.
+
+```js
+assert(arraySum === 6);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myArray = [1, 2, 3;
+let arraySum = myArray.reduce((previous, current =>  previous + current);
+console.log(`Sum of array values is: ${arraySum}`);
+```
+
+# --solutions--
+
+```js
+let myArray = [1, 2, 3];
+let arraySum = myArray.reduce((previous, current) =>  previous + current);
+console.log(`Sum of array values is: ${arraySum}`);
+```

curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-use-of-assignment-operator-instead-of-equality-operator.md

@@ -0,0 +1,81 @@
+---
+id: 587d7b85367417b2b2512b38
+title: Verwendung des Zuweisungsoperators anstelle des Gleichheitsoperators abfangen
+challengeType: 1
+forumTopicId: 301191
+dashedName: catch-use-of-assignment-operator-instead-of-equality-operator
+---
+
+# --description--
+
+Verzweigende Programme, d.h. solche, die verschiedene Dinge tun, wenn bestimmte Bedingungen erfüllt sind, basieren auf `if`, `else if` und `else` Anweisungen in JavaScript. Die Bedingung hat manchmal die Form einer Prüfung, ob ein Ergebnis gleich einem Wert ist.
+
+Diese Logik kann (zumindest im Englischen und Deutschen) als "wenn x gleich y ist, dann ..." ausgedrückt werden, was buchstäblich mit dem `=` oder Zuweisungsoperator in Code übersetzt werden kann. Das führt zu einem unerwarteten Kontrollfluss in deinem Programm.
+
+Wie in den vorherigen Aufgaben behandelt, ordnet der Zuweisungsoperator (`=`) in JavaScript einem Variablennamen einen Wert zu. Und die Operatoren `==` und `===` prüfen auf Gleichheit (das Tripel `===` prüft auf strikte Gleichheit, d. h. Wert und Typ sind gleich).
+
+Der folgende Code weist `x` den Wert 2 zu, was als `true` ausgewertet wird. Fast jeder Wert in JavaScript wird als `true` ausgewertet, außer den sogenannten "falsy" Werten: `false`, `0`, `""` (ein leerer String), `NaN`, `undefined` und `null`.
+
+```js
+let x = 1;
+let y = 2;
+if (x = y) {
+
+} else {
+
+}
+```
+
+In diesem Beispiel wird der Codeblock innerhalb der `if`-Anweisung für jeden beliebigen Wert von `y` ausgeführt, es sei denn, `y` ist falsy. Der `else`-Block, von dem wir erwarten, dass er hier ausgeführt wird, wird nicht wirklich ausgeführt.
+
+# --instructions--
+
+Korrigiere die Bedingung, damit das Programm die richtige Verzweigung ausführt und `result` der richtige Wert zugewiesen wird.
+
+# --hints--
+
+Dein Code sollte die Bedingung so ändern, dass er auf Gleichheit prüft, anstatt eine Zuweisung zu verwenden.
+
+```js
+assert(result == 'Not equal!');
+```
+
+Die Bedingung sollte entweder `==` oder `===` verwenden, um auf Gleichheit zu testen.
+
+```js
+assert(code.match(/x\s*?===?\s*?y/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let x = 7;
+let y = 9;
+let result = "to come";
+
+if(x = y) {
+  result = "Equal!";
+} else {
+  result = "Not equal!";
+}
+
+console.log(result);
+```
+
+# --solutions--
+
+```js
+let x = 7;
+let y = 9;
+let result = "to come";
+
+if(x === y) {
+ result = "Equal!";
+} else {
+ result = "Not equal!";
+}
+
+console.log(result);
+```

curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/prevent-infinite-loops-with-a-valid-terminal-condition.md

@@ -0,0 +1,63 @@
+---
+id: 587d7b86367417b2b2512b3d
+title: Verhindere Endlosschleifen mit einer gültigen Abschlussbedingung
+challengeType: 1
+forumTopicId: 301192
+dashedName: prevent-infinite-loops-with-a-valid-terminal-condition
+---
+
+# --description--
+
+Das letzte Thema ist die gefürchtete Endlosschleife. Schleifen sind großartige Werkzeuge, wenn dein Programm einen Codeblock eine bestimmte Anzahl von Malen ausführen soll oder bis eine Bedingung erfüllt ist, aber sie brauchen eine Abschlussbedingung, die die Schleife beendet. Endlosschleifen können dazu führen, dass der Browser einfriert oder abstürzt und die Programmausführung allgemein beeinträchtigt wird, was niemand will.
+
+In der Einleitung zu diesem Abschnitt gab es ein Beispiel für eine Endlosschleife - sie hatte keine Abschlussbedingung, um aus der `while`-Schleife innerhalb von `loopy()` heraus zu kommen. Rufe diese Funktion NICHT auf!
+
+```js
+function loopy() {
+  while(true) {
+    console.log("Hello, world!");
+  }
+}
+```
+
+Es ist die Aufgabe des Programmierers, dafür zu sorgen, dass die Abschlussbedingung, die dem Programm sagt, wann es aus dem Schleifencode herauskommen soll, schließlich erreicht wird. Ein Fehler ist das Inkrementieren (Erhöhen) oder Dekrementieren (Verringern) einer Zählervariablen in der falschen Richtung vom Endzustand aus. Eine andere Möglichkeit ist das versehentliche Zurücksetzen eines Zählers oder einer Indexvariablen innerhalb des Schleifencodes, anstatt sie zu inkrementieren oder zu dekrementieren.
+
+# --instructions--
+
+Die Funktion `myFunc()` enthält eine Endlosschleife, weil die Abschlussbedingung `i != 4` niemals `false` ergibt (und die Schleife unterbricht) - `i` wird bei jedem Durchlauf um 2 erhöht und springt direkt über 4, da `i` zu Beginn ungerade ist. Korrigiere den Vergleichsoperator in der Abschlussbedingung, damit die Schleife nur für `i` kleiner oder gleich 4 läuft.
+
+# --hints--
+
+Dein Code sollte den Vergleichsoperator in der Abschlussbedingung (dem mittleren Teil) der `for`-Schleife ändern.
+
+```js
+assert(code.match(/i\s*?<=\s*?4;/g).length == 1);
+```
+
+Dein Code sollte den Vergleichsoperator in der Abschlussbedingung der Schleife korrigieren.
+
+```js
+assert(!code.match(/i\s*?!=\s*?4;/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function myFunc() {
+  for (let i = 1; i != 4; i += 2) {
+    console.log("Still going!");
+  }
+}
+```
+
+# --solutions--
+
+```js
+function myFunc() {
+ for (let i = 1; i <= 4; i += 2) {
+   console.log("Still going!");
+ }
+}
+```

curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/understanding-the-differences-between-the-freecodecamp-and-browser-console.md

@@ -0,0 +1,65 @@
+---
+id: 587d7b83367417b2b2512b37
+title: Die Unterschiede zwischen der freeCodeCamp- und der Browser-Konsole verstehen
+challengeType: 1
+forumTopicId: 301193
+dashedName: understanding-the-differences-between-the-freecodecamp-and-browser-console
+---
+
+# --description--
+
+Du hast vielleicht bemerkt, dass einige Aufgaben im freeCodeCamp eine eigene Konsole enthalten. Diese Konsole verhält sich ein wenig anders als die Browser-Konsole.
+
+Es gibt viele Methoden, um mit `console` Nachrichten auszugeben. `log`, `warn`, und `clear`, um nur einige zu nennen. Die freeCodeCamp-Konsole gibt nur `log`-Meldungen aus, während die Browser-Konsole alle Meldungen ausgibt. Wenn du Änderungen an deinem Code vornimmst, wird er automatisch ausgeführt und die Protokolle werden angezeigt. Die freeCodeCamp-Konsole wird dann jedes Mal geleert, wenn dein Code ausgeführt wird.
+
+# --instructions--
+
+Öffne zunächst deine Browserkonsole, damit du die Logs sehen kannst. Um das zu tun, kannst du in den meisten Browsern mit der rechten Maustaste auf die freeCodeCamp-Navigationsleiste oben klicken und `inspect` (Untersuchen) anklicken. Dann suche in dem Fenster, das sich öffnet, den Reiter `console` (Konsole).
+
+Verwende danach `console.log`, um die Variable `output` zu protokollieren. Sieh dir die beiden Konsolen an, um das Protokoll zu sehen. Verwende schließlich `console.clear` nach deinem Log, um die Browserkonsole zu löschen. Sieh dir den Unterschied zwischen den beiden Konsolen an.
+
+# --hints--
+
+Du solltest `console.log()` verwenden, um die Variable `output` auszugeben.
+
+```js
+assert(__helpers.removeWhiteSpace(code).match(/console\.log\(output\)/));
+```
+
+Du solltest `console.clear()` verwenden, um die Browserkonsole zu löschen.
+
+```js
+assert(
+  __helpers
+    .removeWhiteSpace(code)
+    .match(/console.clear\(\)/)
+);
+```
+
+Du solltest die Konsole nach deinem Log löschen.
+
+```js
+assert(
+  __helpers
+    .removeWhiteSpace(code)
+    .match(/console\.log\(output\)[\s\S]*console.clear\(\)/)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let output = "Get this to show once in the freeCodeCamp console and not at all in the browser console";
+
+```
+
+# --solutions--
+
+```js
+let output = "Get this to show once in the freeCodeCamp console and not at all in the browser console";
+
+console.log(output);
+console.clear();
+```

curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/use-caution-when-reinitializing-variables-inside-a-loop.md

@@ -0,0 +1,97 @@
+---
+id: 587d7b86367417b2b2512b3c
+title: Sei vorsichtig, wenn du Variablen innerhalb einer Schleife reinitialisierst
+challengeType: 1
+forumTopicId: 301194
+dashedName: use-caution-when-reinitializing-variables-inside-a-loop
+---
+
+# --description--
+
+Manchmal ist es notwendig, innerhalb einer Schleife Informationen zu speichern, Zähler zu erhöhen oder Variablen neu zu setzen. Ein mögliches Problem ist, wenn Variablen reinitialisiert werden sollten, es aber nicht geschehen ist, oder andersherum. Das ist besonders gefährlich, wenn du die Variable, die für die Endbedingung verwendet wird, versehentlich zurücksetzt und damit eine Endlosschleife auslöst.
+
+Wenn du die Variablenwerte bei jedem Zyklus deiner Schleife mit `console.log()` ausdruckst, kannst du ein fehlerhaftes Verhalten aufdecken, das mit dem Zurücksetzen oder dem Nichtzurücksetzen einer Variablen zusammenhängt.
+
+# --instructions--
+
+Die folgende Funktion soll ein zweidimensionales Array mit `m` Zeilen und `n` Spalten aus Nullen erstellen. Leider bringt es nicht die erwartete Ausgabe, weil die Variable `row` in der äußeren Schleife nicht neu initialisiert (auf ein leeres Array zurückgesetzt) wird. Korrigiere den Code so, dass er ein korrektes 3x2-Array mit Nullen zurückgibt, das wie folgt aussieht: `[[0, 0], [0, 0], [0, 0]]`.
+
+# --hints--
+
+Dein Code sollte die Variable `matrix` auf ein Array setzen, das aus 3 Zeilen und 2 Spalten besteht, die jeweils Nullen enthalten.
+
+```js
+assert(JSON.stringify(matrix) == '[[0,0],[0,0],[0,0]]');
+```
+
+Die Variable `matrix` sollte 3 Zeilen enthalten.
+
+```js
+assert(matrix.length == 3);
+```
+
+Die Variable `matrix` sollte 2 Spalten in jeder Zeile besitzen.
+
+```js
+assert(
+  matrix[0].length == 2 && matrix[1].length === 2 && matrix[2].length === 2
+);
+```
+
+`zeroArray(4,3)` sollte ein Array mit 4 Zeilen und 3 Spalten bestehend aus Nullen zurückgeben.
+
+```js
+assert(JSON.stringify(zeroArray(4,3)) == '[[0,0,0],[0,0,0],[0,0,0],[0,0,0]]');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function zeroArray(m, n) {
+  // Creates a 2-D array with m rows and n columns of zeroes
+  let newArray = [];
+  let row = [];
+  for (let i = 0; i < m; i++) {
+    // Adds the m-th row into newArray
+
+    for (let j = 0; j < n; j++) {
+      // Pushes n zeroes into the current row to create the columns
+      row.push(0);
+    }
+    // Pushes the current row, which now has n zeroes in it, to the array
+    newArray.push(row);
+  }
+  return newArray;
+}
+
+let matrix = zeroArray(3, 2);
+console.log(matrix);
+
+```
+
+# --solutions--
+
+```js
+function zeroArray(m, n) {
+ // Creates a 2-D array with m rows and n columns of zeroes
+ let newArray = [];
+ for (let i = 0; i < m; i++) {
+   let row = [];
+   // Adds the m-th row into newArray
+
+   for (let j = 0; j < n; j++) {
+     // Pushes n zeroes into the current row to create the columns
+     row.push(0);
+   }
+   // Pushes the current row, which now has n zeroes in it, to the array
+   newArray.push(row);
+ }
+ return newArray;
+}
+
+let matrix = zeroArray(3, 2);
+console.log(matrix);
+
+```

curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/use-the-javascript-console-to-check-the-value-of-a-variable.md

@@ -0,0 +1,54 @@
+---
+id: 587d7b83367417b2b2512b33
+title: Verwende die JavaScript-Konsole, um den Wert einer Variable zu überprüfen
+challengeType: 1
+forumTopicId: 18372
+dashedName: use-the-javascript-console-to-check-the-value-of-a-variable
+---
+
+# --description--
+
+Sowohl Chrome als auch Firefox haben hervorragende JavaScript-Konsolen, auch DevTools genannt, um dein JavaScript zu debuggen.
+
+Du findest die Entwicklertools im Menü von Chrome oder die Webkonsole im Menü von Firefox. Wenn du einen anderen Browser oder ein Mobiltelefon verwendest, empfehlen wir dir dringend, auf den Desktop-Browser Firefox oder Chrome umzusteigen.
+
+Die Methode `console.log()`, die die Ausgabe dessen, was in den Klammern steht, auf der Konsole ausgibt, ist wahrscheinlich das hilfreichste Debugging-Tool. Wenn du sie an strategischen Punkten in deinem Code platzierst, kannst du dir die Zwischenwerte von Variablen anzeigen lassen. Es ist gut, eine Vorstellung davon zu haben, wie die Ausgabe aussehen soll, bevor du dir ansiehst, was sie ist. Kontrollpunkte, an denen du den Status deiner Berechnungen in deinem Code überprüfen kannst, helfen dabei, das Problem einzugrenzen.
+
+Hier ist ein Beispiel, mit dem du den String `Hello world!` auf der Konsole ausgibst:
+
+```js
+console.log('Hello world!');
+```
+
+# --instructions--
+
+Verwende die Methode `console.log()`, um den Wert der Variable `a` an den Stellen im Code auszugeben.
+
+# --hints--
+
+Dein Code sollte `console.log()` verwenden, um den Wert der Variable `a` zu überprüfen.
+
+```js
+assert(code.match(/console\.log\(a\)/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let a = 5;
+let b = 1;
+a++;
+// Only change code below this line
+
+
+let sumAB = a + b;
+console.log(sumAB);
+```
+
+# --solutions--
+
+```js
+var a = 5; console.log(a);
+```

curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/use-typeof-to-check-the-type-of-a-variable.md

@@ -0,0 +1,66 @@
+---
+id: 587d7b84367417b2b2512b34
+title: Verwende typeof, um den Typ einer Variable zu prüfen
+challengeType: 1
+forumTopicId: 18374
+dashedName: use-typeof-to-check-the-type-of-a-variable
+---
+
+# --description--
+
+Du kannst `typeof` verwenden, um die Datenstruktur oder den Typ einer Variablen zu überprüfen. Dies ist bei der Fehlersuche nützlich, wenn du mit mehreren Datentypen arbeitest. Wenn du denkst, dass du zwei Zahlen addierst, aber eine davon in Wirklichkeit ein String ist, kann das Ergebnis unerwartet sein. Typfehler können sich in Berechnungen oder Funktionsaufrufen verstecken. Sei besonders vorsichtig, wenn du auf externe Daten in Form eines JSON-Objekts (JavaScript Object Notation) zugreifst und mit ihnen arbeitest.
+
+Hier sind einige Beispiele mit `typeof`:
+
+```js
+console.log(typeof "");
+console.log(typeof 0);
+console.log(typeof []);
+console.log(typeof {});
+```
+
+In der Reihenfolge zeigt die Konsole die Strings `string`, `number`, `object`, und `object` an.
+
+JavaScript kennt sieben primitive (unveränderliche) Datentypen: `Boolean`, `Null`, `Undefined`, `Number`, `String`, `Symbol` (neu mit ES6) und `BigInt` (neu mit ES2020), und einen Typ für veränderbare Elemente: `Object`. Beachte, dass Arrays in JavaScript technisch gesehen eine Art von Objekt sind.
+
+# --instructions--
+
+Füge zwei `console.log()` Anweisungen hinzu, um den Typ (`typeof`) jeder der beiden Variablen `seven` und `three` im Code zu überprüfen.
+
+# --hints--
+
+Dein Code sollte `typeof` in zwei `console.log()` Anweisungen verwenden, um den Typ der Variablen zu überprüfen.
+
+```js
+assert(code.match(/console\.log\s*\(typeof[\( ].*\)?\)/g).length == 2);
+```
+
+Dein Code sollte `typeof` verwenden, um den Typ der Variablen `seven` zu überprüfen.
+
+```js
+assert(code.match(/typeof[\( ]seven\)?/g));
+```
+
+Dein Code sollte `typeof` verwenden, um den Typ der Variablen `three` zu überprüfen.
+
+```js
+assert(code.match(/typeof[\( ]three\)?/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let seven = 7;
+let three = "3";
+console.log(seven + three);
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+let seven = 7;let three = "3";console.log(typeof seven);
+console.log(typeof three);
+```