German translation

content/de/1-5-Decomposition.md

@@ -1,3 +1,3 @@
-## 1.5. Декомпозиция и разделение ответственности
+## 1.5. Dekomposition und _Separation of Concerns_
 
 No translation

content/de/2-1-Identifiers.md

@@ -0,0 +1,38 @@
+## 2.1. Wert, Bezeichner, Variable und Konstante, Literal, Zuweisung
+
+```js
+const INTERVAL = 500;
+let counter = 0;
+const MAX_VALUE = 10;
+let timer = null;
+
+const event = () => {
+  if (counter === MAX_VALUE) {
+    console.log('Das Ende');
+    clearInterval(timer);
+    return;
+  }
+  console.dir({ counter, date: new Date() });
+  counter++;
+};
+
+console.log('Beginn');
+timer = setInterval(event, INTERVAL);
+```
+
+```js
+// Konstanten
+
+const SALUTATION = 'Ave';
+
+const COLORS = [
+  /* 0 */ 'schwarz',
+  /* 1 */ 'rot',
+  /* 2 */ 'grün',
+  /* 3 */ 'gelb',
+  /* 4 */ 'blau',
+  /* 5 */ 'magenta',
+  /* 6 */ 'cyan',
+  /* 7 */ 'weiß',
+];
+```

content/de/2-2-Types.md

@@ -0,0 +1,42 @@
+## 2.2. Datentypen: skalare, Referenz- und strukturierte Typen
+
+> Typ — eine Menge von Werten und Operationen, die auf diesen Werten ausgeführt werden können.
+
+Zum Beispiel nimmt der `Boolean`-Typ in `JavaScript` zwei Werte `true` und `false` an und logische Operationen darauf, der `Null`-Typ nimmt einen `null`-Wert an, und der `Number`-Typ ist eine Menge rationaler Zahlen mit zusätzlichen Einschränkungen für Mindest- und Maximalwerte sowie Einschränkungen für Präzision und mathematische Operationen `+ - * ** / % ++ -- > < >= <= & | ~ ^ << >>`.
+
+> Datentypen
+
+```js
+const values = [5, 'Kiew', true, { size: 10 }, (a) => ++a];
+
+const types = values.map((x) => typeof x);
+console.log({ types });
+```
+
+> Skalar (Primitiv, Atomarer Wert) — der Wert des primitiven Datentyps.
+
+Der Skalar wird bei der Zuweisung kopiert und an die Funktion als Wert übergeben.
+
+> Referenz zeigt auf einen Wert eines Referenztyps, d.h. nicht auf einen Skalarwert.
+
+Für `JavaScript` sind dies die Untertypen: `Object`, `Function`, `Array`.
+
+> Strukturierte Typen (Zusammengesetzte Typen) — zusammengesetzte Typen oder Strukturen, die aus mehreren Skalarwerten bestehen.
+
+Skalarwerte werden so zu einem kombiniert, dass eine Reihe von Operationen auf diesem kombinierten Wert ausgeführt werden können. Zum Beispiel: Objekt, Array, Set, Tupel.
+
+> Aufzählungstyp
+
+> Flag — ein boolescher Wert, der den Zustand von etwas bestimmt.
+
+Zum Beispiel: Status einer geschlossenen Verbindung, Status der Beendigung einer Suche über eine Datenstruktur usw.
+
+```js
+let flagName = false;
+```
+
+Manchmal können Flags nicht als logische, sondern als Aufzählungstypen bezeichnet werden.
+
+> String — eine Zeichenfolge
+
+In den meisten Sprachen kann auf jedes Zeichen über die Array-Zugriffssyntax zugegriffen werden, wie z.B. eckige Klammern.

content/de/2-3-Blocks.md

@@ -0,0 +1,15 @@
+## 2.3. Operator und Ausdruck, Codeblock, Funktion, Schleife, Bedingung
+
+```js
+(len - 1) * f(x, INTERVAL);
+```
+
+```js
+const MAX_VALUE = 10;
+
+console.log('Beginn');
+for (let i = 0; i < MAX_VALUE; i++) {
+  console.dir({ i, date: new Date() });
+}
+console.log('Das Ende');
+```

content/de/2-4-Context.md

@@ -0,0 +1,33 @@
+## 2.4. Kontexte und lexikalischer Scope
+
+> Scope
+
+```js
+const level = 1;
+
+const f = () => {
+  const level = 2;
+  {
+    const level = 3;
+    console.log(level); // 3
+  }
+  console.log(level); // 2
+};
+```
+
+```py
+level = 1
+
+def f():
+  level = 2
+  if level == 2:
+    level = 3
+    print(level) // 3
+  print(level) // 3
+
+f()
+```
+
+> Lexikalisches Umfeld
+
+> Globaler Kontext

content/de/2-5-Procedure.md

@@ -0,0 +1,31 @@
+## 2.5. Prozedurales Paradigma, Aufruf, Stack und Heap
+
+```js
+const colorer = (s, color) => `\x1b[3${color}m${s}\x1b[0m`;
+
+const colorize = (name) => {
+  let res = '';
+  const letters = name.split('');
+  let color = 0;
+  for (const letter of letters) {
+    res += colorer(letter, color++);
+    if (color > COLORS.length) color = 0;
+  }
+  return res;
+};
+
+const greetings = (name) =>
+  name.includes('Augustus')
+    ? `${SALUTATION}, ${colorize(name)}!`
+    : `Hello, ${name}!`;
+```
+
+> Verwendung
+
+```js
+const fullName = 'Marcus Aurelius Antoninus Augustus';
+console.log(greetings(fullName));
+
+const shortName = 'Marcus Aurelius';
+console.log(greetings(shortName));
+```

content/de/2-6-Function.md

@@ -0,0 +1,118 @@
+## 2.6. Höhere Funktionen, reine Funktionen, Seiteneffekte
+
+Funktionsdeklaration (Function definition) — in `JavaScript` ist dies eine Art der Funktionsdeklaration, die von überall im lexikalischen Kontext sichtbar ist, in dem die Funktion deklariert ist, Beispiel:
+
+```js
+function sum(a, b) {
+  return a + b;
+}
+```
+
+Funktionsausdruck (Function expression) — Verknüpfung einer Funktion mit einem Bezeichner durch Zuweisung, wobei der Wert über den Bezeichner nicht im gesamten lexikalischen Kontext verfügbar ist, sondern nur nach der Zuweisungsstelle. Hat mehrere syntaktische Varianten:
+
+Funktionsausdruck mit benannter Funktion (Named function expression):
+
+```js
+const sum = function sum(a, b) {
+  return a + b;
+};
+```
+
+Anonymer Funktionsausdruck (Anonymous function expression):
+
+```js
+const sum = function (a, b) {
+  return a + b;
+};
+```
+
+Pfeil- oder Lambda-Funktion (Arrow, Lambda function):
+
+```js
+const sum = (a, b) => {
+  return a + b;
+};
+```
+
+Lambda-Ausdruck, Pfeilfunktion mit Ausdruck als Körper (Lambda expression, Arrow function):
+
+```js
+const sum = (a, b) => a + b;
+```
+
+> Reine Funktion (Pure Function) — deterministische Funktion ohne Seiteneffekte.
+
+Eine reine Funktion ist eine Funktion, die das Ergebnis nur auf der Grundlage der Argumente berechnet, keinen Zustand hat und nicht auf Eingabe-Ausgabe-Operationen zugreift. Das Ergebnis einer solchen Funktion ist immer deterministisch und ohne Seiteneffekte (siehe Seiteneffekt).
+
+> Closure (Closure) — Funktion, die mit dem lexikalischen Umfeld zum Zeitpunkt ihrer Erstellung verknüpft ist.
+
+Wenn eine Funktion `g` aus einer Funktion `f` zurückgegeben wird, wird `g` den Kontext der Funktion `f` sehen, ebenso wie ihre eigenen Argumente. Wenn `f` `g` zurückgibt, sagt man, dass die Instanz `g` den Kontext `f` geschlossen hat. Ein Closure ist eine Möglichkeit, eine Funktion mit einem Kontext (mit Daten oder Kontextvariablen) zu verknüpfen. Ein Closure ermöglicht es, einen Effekt zu erzeugen, der dem Zustand eines Objekts (der Menge seiner Eigenschaften) in der OOP ähnelt. Eigenschaften sind mit Methoden über das Objekt verknüpft, im Wesentlichen ist das Objekt in der OOP selbst der Verknüpfungskontext. Ein Closure erzeugt ebenfalls einen ähnlichen Kontext, aber auf der Grundlage von Funktionen erster Klasse und lexikalischem Kontext, nicht objektbasiert.
+
+Mit Hilfe von Closures kann funktionale Vererbung implementiert werden.
+
+Beispiele:
+
+```js
+const sum = (a) => (b) => a + b;
+
+const hash =
+  (data = {}) =>
+  (key, value) => ((data[key] = value), data);
+```
+
+> Superposition (Superposition) — Kombination von Funktionsaufrufen in Ausdrücken so, dass das Ergebnis einiger Funktionen zu Argumenten anderer Funktionen wird.
+
+```js
+const expr2 = sum(
+  pow(mul(5, 8), 2),
+  div(inc(sqrt(20)), log(2, 7))
+);
+```
+
+> Komposition (Composition) — Erstellung einer neuen Funktion durch Kombination einfacherer.
+
+```js
+const compose = (f1, f2) => (x) => f2(f1(x));
+```
+
+```js
+// prettier-ignore
+const compose = (...funcs) => (...args) =>
+  funcs.reduce((args, fn) => [fn(...args)], args);
+```
+
+> Partielle Anwendung (Partial application)
+
+```js
+// prettier-ignore
+const partial = (fn, x) => (...args) => fn(x, ...args);
+```
+
+> Currying (Currying)
+
+```js
+const result = curry((a, b, c) => a + b + c)(1, 2)(3);
+```
+
+> Seiteneffekte (Side effects)
+
+> Funktion höherer Ordnung (Higher-order Function)
+
+1. Wenn eine Funktion als Argument an eine andere Funktion übergeben wird, ist es ein Callback.
+2. Wenn eine Funktion als Ergebnis zurückgegeben wird, ist es eine Funktionsfabrik auf Closures.
+3. Wenn die zurückgegebene Funktion dieselbe Semantik hat wie die in den Argumenten erhaltene, aber mit zusätzlichem (erweitertem) Verhalten, ist es eine Wrapper-Funktion.
+4. Es kommt selten vor, dass die zurückgegebene Funktion nicht mit der Funktion aus den Argumenten verknüpft ist oder nicht direkt verknüpft ist und auch eine andere Semantik hat und keine Wrapper-Funktion ist.
+5. Wenn am Ausgang eine Klasse oder Konstruktorfunktion steht, sind es Fabriken für Klassen und Prototypen.
+
+> Wrapper-Funktion (Wrapper)
+
+Eine Funktion, die eine andere Funktion (manchmal ein Objekt, Interface oder funktionales Objekt) umhüllt und ihr zusätzliches Verhalten hinzufügt. Man kann eine ganze API-Schnittstelle und sogar eine asynchrone Funktion zusammen mit Callbacks umhüllen (wenn der Vertrag bekannt ist).
+
+```js
+const sum = (a, b) => a + b;
+
+console.log(`Add nums:    ${sum(5, 2)}`);
+console.log(`Add float:   ${sum(5.1, 2.3)}`);
+console.log(`Concatenate: ${sum('5', '2')}`);
+console.log(`Subtraction: ${sum(5, -2)}`);
+```