From 9df23997fd0c128cf68611c3d4d6cd8cfa89773e Mon Sep 17 00:00:00 2001
From: u-n-known <60901726+u-n-known@users.noreply.github.com>
Date: Fri, 14 Feb 2020 05:46:27 +0100
Subject: [PATCH 01/13] Update article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Die vollständige Übersetzung folgt noch
---
 .../14-function-basics/article.md             | 128 ++++++++----------
 1 file changed, 60 insertions(+), 68 deletions(-)

diff --git a/1-js/02-first-steps/14-function-basics/article.md b/1-js/02-first-steps/14-function-basics/article.md
index cbc3cc1ed..001b569c9 100644
--- a/1-js/02-first-steps/14-function-basics/article.md
+++ b/1-js/02-first-steps/14-function-basics/article.md
@@ -1,18 +1,18 @@
-# Functions
+# Funktionen (*Functions*)
 
-Quite often we need to perform a similar action in many places of the script.
+Des öfteren kommt es vor dass wir eine (ähnliche) Aktion an mehreren Stellen im *script* ausführen möchten. 
 
-For example, we need to show a nice-looking message when a visitor logs in, logs out and maybe somewhere else.
+Z. B. wenn wir dem Besucher unsere Seite eine schöne Nachreicht anzeigen wollen wenn dieser sich ein-, auslogt oder eventuell noch bei anderen Events. 
 
-Functions are the main "building blocks" of the program. They allow the code to be called many times without repetition.
+Funktionen kann man auch als das "Hauptgerüst" des Programs verstehen. Sie erlauben es uns geschriebenen Code häufig abzurufen ohne diesen erneut schreiben zu müssen.
 
-We've already seen examples of built-in functions, like `alert(message)`, `prompt(message, default)` and `confirm(question)`. But we can create functions of our own as well.
+Wir wurden bereits Zeugen von eingebauten (*built-in*) Funktionen (*functions*) wie `alert(nachricht)`, `prompt(nachricht, default)` und `confirm(frage)`. Es ist uns aber auch möglich slebst Funktionen zu kreieren.
 
-## Function Declaration
+## Funktionsdeklarierung (*Function Declaration*)
 
-To create a function we can use a *function declaration*.
+Funktionen können wir m. H. von Funktionsdeklarierungen (*function declaration*) erstellen.
 
-It looks like this:
+Das sieht wie folgt aus:
 
 ```js
 function showMessage() {
@@ -20,7 +20,7 @@ function showMessage() {
 }
 ```
 
-The `function` keyword goes first, then goes the *name of the function*, then a list of *parameters* between the parentheses (comma-separated, empty in the example above) and finally the code of the function, also named "the function body", between curly braces.
+Das *keyword* (Schlüsselwort) `function` steht an erster Stelle, darauf folgt der *Name der Funktion*. Dann noch eine Liste an Parameter zwischen den Paranthesen (mit einem "," voneinander getrennt; om obigen Beispiel leer) und letztlich der Code der Funktion, der auch als "Körper der Funktion" (*the function body*) genannt wird, der zwischen den eckigen Klammern steht (*curly brackets*).
 
 ```js
 function name(parameters) {
@@ -28,121 +28,114 @@ function name(parameters) {
 }
 ```
 
-Our new function can be called by its name: `showMessage()`.
+Unsere neue Funktion kann mittels dessen Name abgerufen werden (*called*): `showMessage()`.
 
-For instance:
+Bspw. :
 
 ```js run
 function showMessage() {
   alert( 'Hello everyone!' );
 }
-
 *!*
 showMessage();
-showMessage();
 */!*
 ```
 
-The call `showMessage()` executes the code of the function. Here we will see the message two times.
+Der Abruf (*call*) `showMessage()` führt den Code der Funktion aus. Darum sehen wir die Nachricht hier zwei Mal.
 
-This example clearly demonstrates one of the main purposes of functions: to avoid code duplication.
+Dieses Beispeil zeigt perfekt was der hauptsächliche Zweck von Funktionen ist: sie verhindern die Duplikation von Code.
 
-If we ever need to change the message or the way it is shown, it's enough to modify the code in one place: the function which outputs it.
+Falls wir jemals die Nachricht ändern müssten oder die Art auf die sie angezeigt wird genügt es den Code einmalig umzuschreiben: der innerhalb der Funktion der ihn ausführt. Genial! 
 
-## Local variables
+## Lokale (*local*) Variabeln
 
-A variable declared inside a function is only visible inside that function.
+Eine Variabel die innerhalb einer Funktion deklariert wird ist ausschließlich innerhalb dieser sichtbar. 
 
-For example:
+Ein Beispiel:
 
 ```js run
 function showMessage() {
 *!*
-  let message = "Hello, I'm JavaScript!"; // local variable
+  let message = "Hello, I'm JavaScript!"; // Lokale (*local*) Variabel
 */!*
-
   alert( message );
 }
-
 showMessage(); // Hello, I'm JavaScript!
-
-alert( message ); // <-- Error! The variable is local to the function
+alert( message ); // <-- Fehler! Die Variabel ist lokal zur Funktion
 ```
 
-## Outer variables
+## Außenstehende (*outer*) Variabeln
 
-A function can access an outer variable as well, for example:
+Eine Funktion kann auch auf außenstehende Variabeln zugreifen wie folgendes Beispiel zeigt:
 
 ```js run no-beautify
 let *!*userName*/!* = 'John';
-
 function showMessage() {
   let message = 'Hello, ' + *!*userName*/!*;
   alert(message);
 }
-
 showMessage(); // Hello, John
 ```
 
-The function has full access to the outer variable. It can modify it as well.
+Die Funktion hat vollständigen Zugriff auf außenstehende Variabeln. Und kann diese auch modifieren.
 
-For instance:
+Hier zu sehen:
 
 ```js run
 let *!*userName*/!* = 'John';
 
 function showMessage() {
-  *!*userName*/!* = "Bob"; // (1) changed the outer variable
+  *!*userName*/!* = "Bob"; // (1) Ändert die außenstehende (*outer*) Variabel 
 
   let message = 'Hello, ' + *!*userName*/!*;
   alert(message);
 }
 
-alert( userName ); // *!*John*/!* before the function call
+alert( userName ); // *!*John*/!* Vor dem Funktionsabruf
 
 showMessage();
 
-alert( userName ); // *!*Bob*/!*, the value was modified by the function
+alert( userName ); // *!*Bob*/!*, Der Wert wurde von der Funktion modifiziert
 ```
 
-The outer variable is only used if there's no local one.
+Die außenstehende Variabel wird nur genutzt wenn es keine lokale gibt.
 
-If a same-named variable is declared inside the function then it *shadows* the outer one. For instance, in the code below the function uses the local `userName`. The outer one is ignored:
+Falls innerhalb der Funktion eine gleichnamige Variabel deklariert wird, wird die außenstehende von dieser überschattet (*shadowed*). Im folgenden Beispiel greift die Funktion auf die lokale Variabel `userName` zu. Die außenstehende wird schlicht ignoriert: 
 
 ```js run
 let userName = 'John';
 
 function showMessage() {
 *!*
-  let userName = "Bob"; // declare a local variable
+  let userName = "Bob"; // deklariert eine lokale Variabel
 */!*
 
   let message = 'Hello, ' + userName; // *!*Bob*/!*
   alert(message);
 }
 
-// the function will create and use its own userName
+// die Funktion wird ihre eigene Variabel erstellen und nutzen
 showMessage();
 
-alert( userName ); // *!*John*/!*, unchanged, the function did not access the outer variable
+alert( userName ); // *!*John*/!*, bleibt unverändert, die Funktion greift nicht auf die außenstehende Variabel zu
 ```
 
-```smart header="Global variables"
-Variables declared outside of any function, such as the outer `userName` in the code above, are called *global*.
+```smart header="*Global* variables"
+Variabeln die außerhalb jeglicher Funktionen deklariert werden, wie das äußere `userName` im oben stehenden Code, nennt man *global*.
 
-Global variables are visible from any function (unless shadowed by locals).
+Auf globale Variabeln kann von jeder Funktion aus zugegriffen werden (, solange diese nicht von einer lokalen "überschattet" wird).
 
-It's a good practice to minimize the use of global variables. Modern code has few or no globals. Most variables reside in their functions. Sometimes though, they can be useful to store project-level data.
+So wenig globale Variabeln wie möglich nutzen ist gute Praxis, denn moderner Code hat wenige bis keine. Die meisten Variabeln verbleiben innerhalb ihrer Funktionen. Manchmal sind globale aber doch praktisch, wenn man bspw. Daten des Projektstands speichern möchte.
 ```
 
-## Parameters
+## Parameter
 
-We can pass arbitrary data to functions using parameters (also called *function arguments*) .
+Wir können Funktionen jedliche Art von Daten zukommen lassen (auch Funktionsargumente [*function arguments*] genannt).
 
-In the example below, the function has two parameters: `from` and `text`.
+Im unten stehenden Beispiel hat die Funktion zwei Parameter: `from` und `text`.
 
 ```js run
-function showMessage(*!*from, text*/!*) { // arguments: from, text
+function showMessage(*!*from, text*/!*) { // argumente: from, text
   alert(from + ': ' + text);
 }
 
@@ -152,16 +145,16 @@ showMessage('Ann', "What's up?"); // Ann: What's up? (**)
 */!*
 ```
 
-When the function is called in lines `(*)` and `(**)`, the given values are copied to local variables `from` and `text`. Then the function uses them.
+Wenn die Funktion in den Zeilen `(*)` und `(**)`abgerufen wird werden die gegebenen Werte in die lokalen Variabeln `from` und `text` kopiert, woraufhin die Funktion diese nutzt. 
 
-Here's one more example: we have a variable `from` and pass it to the function. Please note: the function changes `from`, but the change is not seen outside, because a function always gets a copy of the value:
+Hier ist ein weiteres Beispiel: wir haben eine Variabel `from` und spielen diese der Funktion zu. Beachte, dass die Funktion `from` ändert, jedoch diese Änderung außen nicht sichtbar wird weil die Funktion stets eine Kopie des Werts annimmt:
 
 
 ```js run
 function showMessage(from, text) {
 
 *!*
-  from = '*' + from + '*'; // make "from" look nicer
+  from = '*' + from + '*'; // hübscht "from" auf
 */!*
 
   alert( from + ': ' + text );
@@ -171,23 +164,23 @@ let from = "Ann";
 
 showMessage(from, "Hello"); // *Ann*: Hello
 
-// the value of "from" is the same, the function modified a local copy
+// der Wert von "from" bleibt der selbe, die Funktion hat nur eine lokale Kopie modifiziert
 alert( from ); // Ann
 ```
 
-## Default values
+## Default-Werte
 
-If a parameter is not provided, then its value becomes `undefined`.
+Wenn ein Parameter nicht gegeben ist wird dessen Wert zu `undefined`.
 
-For instance, the aforementioned function `showMessage(from, text)` can be called with a single argument:
+Bspw. kann die zuvor genannte Funktion `showMessage(from, text)` m. H. eines einzelen Arguments abgerufen werden:
 
 ```js
 showMessage("Ann");
 ```
 
-That's not an error. Such a call would output `"Ann: undefined"`. There's no `text`, so it's assumed that `text === undefined`.
+Das ist kein Fehler. Ein solcher Abruf würde `"Ann: undefined"` ausgeben, da es kein `text` gibt und daher davon ausgegangen wird das `text === undefined` ist.
 
-If we want to use a "default" `text` in this case, then we can specify it after `=`:
+Falls wir in diesem Fall ein "default" für `text` festlegen wollen, können wir diesen hinter `=` definieren:
 
 ```js run
 function showMessage(from, *!*text = "no text given"*/!*) {
@@ -196,28 +189,27 @@ function showMessage(from, *!*text = "no text given"*/!*) {
 
 showMessage("Ann"); // Ann: no text given
 ```
+Wenn der `text` Parameter jetzt nicht gegeben wird, erhält er den Wert `"no text given"`
 
-Now if the `text` parameter is not passed, it will get the value `"no text given"`
-
-Here `"no text given"` is a string, but it can be a more complex expression, which is only evaluated and assigned if the parameter is missing. So, this is also possible:
+Hier ist `"no text given"` nur ein String, kann aber auch eine viel komplexere *Expression* sein die nur evaluiert und zugewissen wird wenn der entsprechende Parameter fehlt. Das macht folgendes möglich:
 
 ```js run
 function showMessage(from, text = anotherFunction()) {
-  // anotherFunction() only executed if no text given
-  // its result becomes the value of text
+  // anotherFunction() wird nur ausgeführt wenn kein Text gegebn ist
+  // dessen Resultat wird der Wert von Text sein
 }
 ```
 
-```smart header="Evaluation of default parameters"
-In JavaScript, a default parameter is evaluated every time the function is called without the respective parameter.
+```smart header="Evaluirtung von Default-Parametern"
+In JavaScript wird ein Default-Parameter immer dann evaluiert wenn die Funktion ohne den respektiven Parameter abgerufen wird.
 
-In the example above, `anotherFunction()` is called every time `showMessage()` is called without the `text` parameter.
+Im oberen Beispiel wird `anotherFunction()` jedes Mal abgerufen, wenn `showMessage()` ohne den `text` Parameter abgerufen wird.
 ```
 
-````smart header="Default parameters old-style"
-Old editions of JavaScript did not support default parameters. So there are alternative ways to support them, that you can find mostly in the old scripts.
+````smart header="Old-style Default-Parameter"
+In älteren JavaScript-Versionen waren Default-Parameter nicht unterstützt weshalb sich alternative Wege entwickelt haben um diese trotzdem zu unterstützen. Diese sind meist in alten *scripts* aufzufinden.
 
-For instance, an explicit check for being `undefined`:
+Beispielhaft ist eine strikte Prüfung auf `undefined`:
 
 ```js
 function showMessage(from, text) {
@@ -231,11 +223,11 @@ function showMessage(from, text) {
 }
 ```
 
-...Or the `||` operator:
+...Oder der `||` Operator:
 
 ```js
 function showMessage(from, text) {
-  // if text is falsy then text gets the "default" value
+  // falls text nicht gegeben ist erhält es den "default" Wert
   text = text || 'no text given';
   ...
 }

From 2ab0938335f9da00cc6675e1e46cc89eb12fcbbf Mon Sep 17 00:00:00 2001
From: u-n-known <60901726+u-n-known@users.noreply.github.com>
Date: Fri, 14 Feb 2020 22:41:50 +0100
Subject: [PATCH 02/13] Apply suggestions from code review
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: Christian Hegedüs <christianhegedues@users.noreply.github.com>
---
 .../14-function-basics/article.md             | 72 +++++++++----------
 1 file changed, 36 insertions(+), 36 deletions(-)

diff --git a/1-js/02-first-steps/14-function-basics/article.md b/1-js/02-first-steps/14-function-basics/article.md
index 001b569c9..14ddb3017 100644
--- a/1-js/02-first-steps/14-function-basics/article.md
+++ b/1-js/02-first-steps/14-function-basics/article.md
@@ -2,11 +2,11 @@
 
 Des öfteren kommt es vor dass wir eine (ähnliche) Aktion an mehreren Stellen im *script* ausführen möchten. 
 
-Z. B. wenn wir dem Besucher unsere Seite eine schöne Nachreicht anzeigen wollen wenn dieser sich ein-, auslogt oder eventuell noch bei anderen Events. 
+Z. B. wenn wir dem Besucher unsere Seite eine schöne Nachricht anzeigen wollen wenn dieser sich einloggt, ausloggt und eventuell noch bei anderen Events. 
 
-Funktionen kann man auch als das "Hauptgerüst" des Programs verstehen. Sie erlauben es uns geschriebenen Code häufig abzurufen ohne diesen erneut schreiben zu müssen.
+Funktionen kann man auch als das "Bausteine" des Programs verstehen. Sie erlauben es uns geschriebenen Code häufig abzurufen ohne diesen erneut schreiben zu müssen.
 
-Wir wurden bereits Zeugen von eingebauten (*built-in*) Funktionen (*functions*) wie `alert(nachricht)`, `prompt(nachricht, default)` und `confirm(frage)`. Es ist uns aber auch möglich slebst Funktionen zu kreieren.
+Wir wurden bereits Zeugen von eingebauten (*built-in*) Funktionen (*functions*) wie `alert(message)`, `prompt(message, default)` und `confirm(question)`. Es ist uns aber auch möglich selbst Funktionen zu kreieren.
 
 ## Funktionsdeklarierung (*Function Declaration*)
 
@@ -45,39 +45,39 @@ Der Abruf (*call*) `showMessage()` führt den Code der Funktion aus. Darum sehen
 
 Dieses Beispeil zeigt perfekt was der hauptsächliche Zweck von Funktionen ist: sie verhindern die Duplikation von Code.
 
-Falls wir jemals die Nachricht ändern müssten oder die Art auf die sie angezeigt wird genügt es den Code einmalig umzuschreiben: der innerhalb der Funktion der ihn ausführt. Genial! 
+Falls wir jemals die Nachricht ändern müssten, oder die Art auf die sie angezeigt wird, genügt es den Code einmalig umzuschreiben: der innerhalb der Funktion der ihn ausführt.
 
-## Lokale (*local*) Variabeln
+## Lokale (*local*) Variablen
 
-Eine Variabel die innerhalb einer Funktion deklariert wird ist ausschließlich innerhalb dieser sichtbar. 
+Eine Variable, die innerhalb einer Funktion deklariert wird, ist ausschließlich innerhalb dieser sichtbar. 
 
 Ein Beispiel:
 
 ```js run
 function showMessage() {
 *!*
-  let message = "Hello, I'm JavaScript!"; // Lokale (*local*) Variabel
+  let message = "Hallo, ich bin JavaScript!"; // Lokale (*local*) Variable
 */!*
   alert( message );
 }
-showMessage(); // Hello, I'm JavaScript!
+showMessage(); // Hallo, ich bin JavaScript!
 alert( message ); // <-- Fehler! Die Variabel ist lokal zur Funktion
 ```
 
-## Außenstehende (*outer*) Variabeln
+## Außenstehende (*outer*) Variablen
 
-Eine Funktion kann auch auf außenstehende Variabeln zugreifen wie folgendes Beispiel zeigt:
+Eine Funktion kann auch auf außenstehende Variablen zugreifen, wie folgendes Beispiel zeigt:
 
 ```js run no-beautify
 let *!*userName*/!* = 'John';
 function showMessage() {
-  let message = 'Hello, ' + *!*userName*/!*;
+  let message = 'Hallo, ' + *!*userName*/!*;
   alert(message);
 }
-showMessage(); // Hello, John
+showMessage(); // Hallo, John
 ```
 
-Die Funktion hat vollständigen Zugriff auf außenstehende Variabeln. Und kann diese auch modifieren.
+Die Funktion hat vollständigen Zugriff auf außenstehende Variablen. Und kann diese auch modifieren.
 
 Hier zu sehen:
 
@@ -85,9 +85,9 @@ Hier zu sehen:
 let *!*userName*/!* = 'John';
 
 function showMessage() {
-  *!*userName*/!* = "Bob"; // (1) Ändert die außenstehende (*outer*) Variabel 
+  *!*userName*/!* = "Bob"; // (1) Ändert die außenstehende (*outer*) Variable
 
-  let message = 'Hello, ' + *!*userName*/!*;
+  let message = 'Hallo, ' + *!*userName*/!*;
   alert(message);
 }
 
@@ -98,34 +98,34 @@ showMessage();
 alert( userName ); // *!*Bob*/!*, Der Wert wurde von der Funktion modifiziert
 ```
 
-Die außenstehende Variabel wird nur genutzt wenn es keine lokale gibt.
+Die außenstehende Variable wird nur genutzt, wenn es keine lokale gibt.
 
-Falls innerhalb der Funktion eine gleichnamige Variabel deklariert wird, wird die außenstehende von dieser überschattet (*shadowed*). Im folgenden Beispiel greift die Funktion auf die lokale Variabel `userName` zu. Die außenstehende wird schlicht ignoriert: 
+Falls innerhalb der Funktion eine gleichnamige Variable deklariert wird, wird die außenstehende von dieser überschattet (*shadowed*). Im folgenden Beispiel greift die Funktion auf die lokale Variable `userName` zu. Die außenstehende wird schlicht ignoriert: 
 
 ```js run
 let userName = 'John';
 
 function showMessage() {
 *!*
-  let userName = "Bob"; // deklariert eine lokale Variabel
+  let userName = "Bob"; // deklariert eine lokale Variable
 */!*
 
-  let message = 'Hello, ' + userName; // *!*Bob*/!*
+  let message = 'Hallo, ' + userName; // *!*Bob*/!*
   alert(message);
 }
 
-// die Funktion wird ihre eigene Variabel erstellen und nutzen
+// die Funktion wird ihre eigene Variable erstellen und nutzen
 showMessage();
 
-alert( userName ); // *!*John*/!*, bleibt unverändert, die Funktion greift nicht auf die außenstehende Variabel zu
+alert( userName ); // *!*John*/!*, bleibt unverändert, die Funktion greift nicht auf die außenstehende Variable zu
 ```
 
 ```smart header="*Global* variables"
-Variabeln die außerhalb jeglicher Funktionen deklariert werden, wie das äußere `userName` im oben stehenden Code, nennt man *global*.
+Variablen, die außerhalb jeglicher Funktionen deklariert werden, wie das äußere `userName` im oben stehenden Code, nennt man *global*.
 
-Auf globale Variabeln kann von jeder Funktion aus zugegriffen werden (, solange diese nicht von einer lokalen "überschattet" wird).
+Auf globale Variablen kann von jeder Funktion aus zugegriffen werden (sofern diese nicht von Lokalen "überschattet" werden).
 
-So wenig globale Variabeln wie möglich nutzen ist gute Praxis, denn moderner Code hat wenige bis keine. Die meisten Variabeln verbleiben innerhalb ihrer Funktionen. Manchmal sind globale aber doch praktisch, wenn man bspw. Daten des Projektstands speichern möchte.
+So wenig globale Variablen wie möglich nutzen ist gute Praxis, denn moderner Code hat wenige bis keine. Die meisten Variablen verbleiben innerhalb ihrer Funktionen. Manchmal sind Globale aber doch praktisch, wenn man bspw. Daten des Projektstands speichern möchte.
 ```
 
 ## Parameter
@@ -135,7 +135,7 @@ Wir können Funktionen jedliche Art von Daten zukommen lassen (auch Funktionsarg
 Im unten stehenden Beispiel hat die Funktion zwei Parameter: `from` und `text`.
 
 ```js run
-function showMessage(*!*from, text*/!*) { // argumente: from, text
+function showMessage(*!*from, text*/!*) { // Argumente: from, text
   alert(from + ': ' + text);
 }
 
@@ -145,9 +145,9 @@ showMessage('Ann', "What's up?"); // Ann: What's up? (**)
 */!*
 ```
 
-Wenn die Funktion in den Zeilen `(*)` und `(**)`abgerufen wird werden die gegebenen Werte in die lokalen Variabeln `from` und `text` kopiert, woraufhin die Funktion diese nutzt. 
+Wenn die Funktion in den Zeilen `(*)` und `(**)`abgerufen wird, werden die gegebenen Werte in die lokalen Variablen `from` und `text` kopiert, woraufhin die Funktion diese nutzt. 
 
-Hier ist ein weiteres Beispiel: wir haben eine Variabel `from` und spielen diese der Funktion zu. Beachte, dass die Funktion `from` ändert, jedoch diese Änderung außen nicht sichtbar wird weil die Funktion stets eine Kopie des Werts annimmt:
+Hier ist ein weiteres Beispiel: wir haben eine Variable `from` und spielen diese der Funktion zu. Beachte, dass die Funktion `from` ändert, jedoch diese Änderung außen nicht sichtbar wird, weil die Funktion stets eine Kopie des Werts annimmt:
 
 
 ```js run
@@ -162,7 +162,7 @@ function showMessage(from, text) {
 
 let from = "Ann";
 
-showMessage(from, "Hello"); // *Ann*: Hello
+showMessage(from, "Hallo"); // *Ann*: Hallo
 
 // der Wert von "from" bleibt der selbe, die Funktion hat nur eine lokale Kopie modifiziert
 alert( from ); // Ann
@@ -183,31 +183,31 @@ Das ist kein Fehler. Ein solcher Abruf würde `"Ann: undefined"` ausgeben, da es
 Falls wir in diesem Fall ein "default" für `text` festlegen wollen, können wir diesen hinter `=` definieren:
 
 ```js run
-function showMessage(from, *!*text = "no text given"*/!*) {
+function showMessage(from, *!*text = "kein Text übergeben"*/!*) {
   alert( from + ": " + text );
 }
 
-showMessage("Ann"); // Ann: no text given
+showMessage("Ann"); // Ann: kein Text übergeben
 ```
 Wenn der `text` Parameter jetzt nicht gegeben wird, erhält er den Wert `"no text given"`
 
-Hier ist `"no text given"` nur ein String, kann aber auch eine viel komplexere *Expression* sein die nur evaluiert und zugewissen wird wenn der entsprechende Parameter fehlt. Das macht folgendes möglich:
+Hier ist `"no text given"` nur ein String, kann aber auch eine viel komplexere *Expression* sein, die nur evaluiert und zugewissen wird, wenn der entsprechende Parameter fehlt. Das macht folgendes möglich:
 
 ```js run
 function showMessage(from, text = anotherFunction()) {
-  // anotherFunction() wird nur ausgeführt wenn kein Text gegebn ist
-  // dessen Resultat wird der Wert von Text sein
+  // anotherFunction() wird nur ausgeführt wenn kein Text gegeben ist
+  // dessen Resultat wird der Wert von *text* sein
 }
 ```
 
-```smart header="Evaluirtung von Default-Parametern"
-In JavaScript wird ein Default-Parameter immer dann evaluiert wenn die Funktion ohne den respektiven Parameter abgerufen wird.
+```smart header="Evaluierung von Default-Parametern"
+In JavaScript wird ein Default-Parameter immer dann evaluiert, wenn die Funktion ohne den respektiven Parameter abgerufen wird.
 
 Im oberen Beispiel wird `anotherFunction()` jedes Mal abgerufen, wenn `showMessage()` ohne den `text` Parameter abgerufen wird.
 ```
 
 ````smart header="Old-style Default-Parameter"
-In älteren JavaScript-Versionen waren Default-Parameter nicht unterstützt weshalb sich alternative Wege entwickelt haben um diese trotzdem zu unterstützen. Diese sind meist in alten *scripts* aufzufinden.
+In älteren JavaScript-Versionen waren Default-Parameter nicht unterstützt, weshalb sich alternative Wege entwickelt haben um diese trotzdem zu unterstützen. Diese sind meist in alten *scripts* aufzufinden.
 
 Beispielhaft ist eine strikte Prüfung auf `undefined`:
 

From 4dbe2ce77adfa2fb65db13790899d0ea218f851c Mon Sep 17 00:00:00 2001
From: u-n-known <60901726+u-n-known@users.noreply.github.com>
Date: Tue, 25 Feb 2020 09:13:38 +0100
Subject: [PATCH 03/13] Update
 1-js/02-first-steps/14-function-basics/article.md

Co-Authored-By: Lukas <37246258+1H0@users.noreply.github.com>
---
 1-js/02-first-steps/14-function-basics/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/14-function-basics/article.md b/1-js/02-first-steps/14-function-basics/article.md
index 14ddb3017..8ce9dc478 100644
--- a/1-js/02-first-steps/14-function-basics/article.md
+++ b/1-js/02-first-steps/14-function-basics/article.md
@@ -1,6 +1,6 @@
 # Funktionen (*Functions*)
 
-Des öfteren kommt es vor dass wir eine (ähnliche) Aktion an mehreren Stellen im *script* ausführen möchten. 
+Des öfteren kommt es vor, dass wir eine (ähnliche) Aktion an mehreren Stellen im *script* ausführen möchten. 
 
 Z. B. wenn wir dem Besucher unsere Seite eine schöne Nachricht anzeigen wollen wenn dieser sich einloggt, ausloggt und eventuell noch bei anderen Events. 
 

From 60c575e74a72f857623c7a0b349cbc25320a652b Mon Sep 17 00:00:00 2001
From: u-n-known <60901726+u-n-known@users.noreply.github.com>
Date: Tue, 25 Feb 2020 09:15:21 +0100
Subject: [PATCH 04/13] Update
 1-js/02-first-steps/14-function-basics/article.md

Co-Authored-By: Lukas <37246258+1H0@users.noreply.github.com>
---
 1-js/02-first-steps/14-function-basics/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/14-function-basics/article.md b/1-js/02-first-steps/14-function-basics/article.md
index 8ce9dc478..807877f68 100644
--- a/1-js/02-first-steps/14-function-basics/article.md
+++ b/1-js/02-first-steps/14-function-basics/article.md
@@ -28,7 +28,7 @@ function name(parameters) {
 }
 ```
 
-Unsere neue Funktion kann mittels dessen Name abgerufen werden (*called*): `showMessage()`.
+Unsere neue Funktion kann mit ihrem Namen abgerufen werden: `showMessage()`.
 
 Bspw. :
 

From 5d41bfbdad0cb37e889cb666bfc5a5aa5e614d4a Mon Sep 17 00:00:00 2001
From: u-n-known <60901726+u-n-known@users.noreply.github.com>
Date: Tue, 25 Feb 2020 09:15:38 +0100
Subject: [PATCH 05/13] Update
 1-js/02-first-steps/14-function-basics/article.md

Co-Authored-By: Lukas <37246258+1H0@users.noreply.github.com>
---
 1-js/02-first-steps/14-function-basics/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/14-function-basics/article.md b/1-js/02-first-steps/14-function-basics/article.md
index 807877f68..97d2031f0 100644
--- a/1-js/02-first-steps/14-function-basics/article.md
+++ b/1-js/02-first-steps/14-function-basics/article.md
@@ -172,7 +172,7 @@ alert( from ); // Ann
 
 Wenn ein Parameter nicht gegeben ist wird dessen Wert zu `undefined`.
 
-Bspw. kann die zuvor genannte Funktion `showMessage(from, text)` m. H. eines einzelen Arguments abgerufen werden:
+Bspw. kann die zuvor genannte Funktion `showMessage(from, text)` mit Hilfe eines einzelen Arguments abgerufen werden:
 
 ```js
 showMessage("Ann");

From 99043b3436401c35d6d02b0352ffb4a3e1b796d2 Mon Sep 17 00:00:00 2001
From: u-n-known <60901726+u-n-known@users.noreply.github.com>
Date: Tue, 25 Feb 2020 09:16:09 +0100
Subject: [PATCH 06/13] Update
 1-js/02-first-steps/14-function-basics/article.md

Co-Authored-By: Lukas <37246258+1H0@users.noreply.github.com>
---
 1-js/02-first-steps/14-function-basics/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/14-function-basics/article.md b/1-js/02-first-steps/14-function-basics/article.md
index 97d2031f0..ebed20671 100644
--- a/1-js/02-first-steps/14-function-basics/article.md
+++ b/1-js/02-first-steps/14-function-basics/article.md
@@ -207,7 +207,7 @@ Im oberen Beispiel wird `anotherFunction()` jedes Mal abgerufen, wenn `showMessa
 ```
 
 ````smart header="Old-style Default-Parameter"
-In älteren JavaScript-Versionen waren Default-Parameter nicht unterstützt, weshalb sich alternative Wege entwickelt haben um diese trotzdem zu unterstützen. Diese sind meist in alten *scripts* aufzufinden.
+In älteren JavaScript-Versionen waren Default-Parameter nicht unterstützt, weshalb sich alternative Wege entwickelt haben. Diese sind meist in alten *scripts* aufzufinden.
 
 Beispielhaft ist eine strikte Prüfung auf `undefined`:
 

From c9e6c84afd0c82c49c96f5a9272aef33d5bc985b Mon Sep 17 00:00:00 2001
From: u-n-known <60901726+u-n-known@users.noreply.github.com>
Date: Tue, 25 Feb 2020 09:16:50 +0100
Subject: [PATCH 07/13] Update
 1-js/02-first-steps/14-function-basics/article.md

Co-Authored-By: Lukas <37246258+1H0@users.noreply.github.com>
---
 1-js/02-first-steps/14-function-basics/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/14-function-basics/article.md b/1-js/02-first-steps/14-function-basics/article.md
index ebed20671..811d388ce 100644
--- a/1-js/02-first-steps/14-function-basics/article.md
+++ b/1-js/02-first-steps/14-function-basics/article.md
@@ -170,7 +170,7 @@ alert( from ); // Ann
 
 ## Default-Werte
 
-Wenn ein Parameter nicht gegeben ist wird dessen Wert zu `undefined`.
+Wenn ein Parameter nicht gegeben ist, wird dessen Wert zu `undefined`.
 
 Bspw. kann die zuvor genannte Funktion `showMessage(from, text)` mit Hilfe eines einzelen Arguments abgerufen werden:
 

From 036357cdf32081e591367b6230ab448f915420cd Mon Sep 17 00:00:00 2001
From: u-n-known <60901726+u-n-known@users.noreply.github.com>
Date: Tue, 25 Feb 2020 09:17:21 +0100
Subject: [PATCH 08/13] Update
 1-js/02-first-steps/14-function-basics/article.md

Co-Authored-By: Lukas <37246258+1H0@users.noreply.github.com>
---
 1-js/02-first-steps/14-function-basics/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/14-function-basics/article.md b/1-js/02-first-steps/14-function-basics/article.md
index 811d388ce..d547cdc7c 100644
--- a/1-js/02-first-steps/14-function-basics/article.md
+++ b/1-js/02-first-steps/14-function-basics/article.md
@@ -125,7 +125,7 @@ Variablen, die außerhalb jeglicher Funktionen deklariert werden, wie das äuße
 
 Auf globale Variablen kann von jeder Funktion aus zugegriffen werden (sofern diese nicht von Lokalen "überschattet" werden).
 
-So wenig globale Variablen wie möglich nutzen ist gute Praxis, denn moderner Code hat wenige bis keine. Die meisten Variablen verbleiben innerhalb ihrer Funktionen. Manchmal sind Globale aber doch praktisch, wenn man bspw. Daten des Projektstands speichern möchte.
+Es hat sich als gute und moderne Praxis entwickelt, so wenig globale Variablen wie möglich zu verwenden. Moderner Code hat wenige bis keine dieser globalen Variablen. Die meisten Variablen verbleiben innerhalb ihrer Funktionen. Manchmal sind Globale Variabeln aber doch praktisch, wenn man z.B. Daten des Projektstands speichern möchte.
 ```
 
 ## Parameter

From 4d383503da9c4aaece44e2d1a266bcbc818c2bdd Mon Sep 17 00:00:00 2001
From: u-n-known <60901726+u-n-known@users.noreply.github.com>
Date: Tue, 25 Feb 2020 09:18:25 +0100
Subject: [PATCH 09/13] Update
 1-js/02-first-steps/14-function-basics/article.md

Co-Authored-By: Lukas <37246258+1H0@users.noreply.github.com>
---
 1-js/02-first-steps/14-function-basics/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/14-function-basics/article.md b/1-js/02-first-steps/14-function-basics/article.md
index d547cdc7c..92da66207 100644
--- a/1-js/02-first-steps/14-function-basics/article.md
+++ b/1-js/02-first-steps/14-function-basics/article.md
@@ -2,7 +2,7 @@
 
 Des öfteren kommt es vor, dass wir eine (ähnliche) Aktion an mehreren Stellen im *script* ausführen möchten. 
 
-Z. B. wenn wir dem Besucher unsere Seite eine schöne Nachricht anzeigen wollen wenn dieser sich einloggt, ausloggt und eventuell noch bei anderen Events. 
+Wenn sich der Benutzer einloggt, ausloggt oder sonstige Aktinen ausübt, möchten wir Ihm eine Nachricht anzeigen. 
 
 Funktionen kann man auch als das "Bausteine" des Programs verstehen. Sie erlauben es uns geschriebenen Code häufig abzurufen ohne diesen erneut schreiben zu müssen.
 

From a66b962e1cfca3321754e666087cc4019fcb2ba1 Mon Sep 17 00:00:00 2001
From: u-n-known <60901726+u-n-known@users.noreply.github.com>
Date: Tue, 25 Feb 2020 09:18:38 +0100
Subject: [PATCH 10/13] Update
 1-js/02-first-steps/14-function-basics/article.md

Co-Authored-By: Lukas <37246258+1H0@users.noreply.github.com>
---
 1-js/02-first-steps/14-function-basics/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/14-function-basics/article.md b/1-js/02-first-steps/14-function-basics/article.md
index 92da66207..c51f3c990 100644
--- a/1-js/02-first-steps/14-function-basics/article.md
+++ b/1-js/02-first-steps/14-function-basics/article.md
@@ -30,7 +30,7 @@ function name(parameters) {
 
 Unsere neue Funktion kann mit ihrem Namen abgerufen werden: `showMessage()`.
 
-Bspw. :
+Zum Beispiel:
 
 ```js run
 function showMessage() {

From a20f47a1375651b7d4ea7d830b7e60ad4c31dac2 Mon Sep 17 00:00:00 2001
From: u-n-known <60901726+u-n-known@users.noreply.github.com>
Date: Sun, 8 Mar 2020 12:43:55 +0100
Subject: [PATCH 11/13] Update
 1-js/02-first-steps/14-function-basics/article.md

---
 1-js/02-first-steps/14-function-basics/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/14-function-basics/article.md b/1-js/02-first-steps/14-function-basics/article.md
index c51f3c990..6f34500e6 100644
--- a/1-js/02-first-steps/14-function-basics/article.md
+++ b/1-js/02-first-steps/14-function-basics/article.md
@@ -20,7 +20,7 @@ function showMessage() {
 }
 ```
 
-Das *keyword* (Schlüsselwort) `function` steht an erster Stelle, darauf folgt der *Name der Funktion*. Dann noch eine Liste an Parameter zwischen den Paranthesen (mit einem "," voneinander getrennt; om obigen Beispiel leer) und letztlich der Code der Funktion, der auch als "Körper der Funktion" (*the function body*) genannt wird, der zwischen den eckigen Klammern steht (*curly brackets*).
+Das *keyword* (Schlüsselwort) `function` steht an erster Stelle, darauf folgt der *Name der Funktion*. Dann noch eine Liste an Parameter zwischen den Parenthesen (mit einem "," voneinander getrennt; im obigen Beispiel leer) und letztlich der Code der Funktion, der auch als "Körper der Funktion" (*the function body*) genannt wird, der zwischen den Akkoladen (*curly braces*) steht.
 
 ```js
 function name(parameters) {

From a755caba6997369c22716011d3e4a6a062caf147 Mon Sep 17 00:00:00 2001
From: u-n-known <60901726+u-n-known@users.noreply.github.com>
Date: Sun, 8 Mar 2020 12:44:03 +0100
Subject: [PATCH 12/13] Update
 1-js/02-first-steps/14-function-basics/article.md

---
 1-js/02-first-steps/14-function-basics/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/14-function-basics/article.md b/1-js/02-first-steps/14-function-basics/article.md
index 6f34500e6..d983a4510 100644
--- a/1-js/02-first-steps/14-function-basics/article.md
+++ b/1-js/02-first-steps/14-function-basics/article.md
@@ -191,7 +191,7 @@ showMessage("Ann"); // Ann: kein Text übergeben
 ```
 Wenn der `text` Parameter jetzt nicht gegeben wird, erhält er den Wert `"no text given"`
 
-Hier ist `"no text given"` nur ein String, kann aber auch eine viel komplexere *Expression* sein, die nur evaluiert und zugewissen wird, wenn der entsprechende Parameter fehlt. Das macht folgendes möglich:
+Hier ist `"no text given"` nur ein String, kann aber auch ein viel komplexerer Ausdruck (*expression*) sein, der nur evaluiert und zugewiesen wird, wenn der entsprechende Parameter fehlt. Das macht folgendes möglich:
 
 ```js run
 function showMessage(from, text = anotherFunction()) {

From f161186a59200cbbaf2e96c8511073f6bc8989b9 Mon Sep 17 00:00:00 2001
From: Constantin <131041909+engag1ng@users.noreply.github.com>
Date: Wed, 14 Aug 2024 03:47:58 +0000
Subject: [PATCH 13/13] fixed typos and consistency

---
 .../14-function-basics/article.md             | 28 +++++++++----------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/1-js/02-first-steps/14-function-basics/article.md b/1-js/02-first-steps/14-function-basics/article.md
index d983a4510..886edc6f0 100644
--- a/1-js/02-first-steps/14-function-basics/article.md
+++ b/1-js/02-first-steps/14-function-basics/article.md
@@ -4,9 +4,9 @@ Des öfteren kommt es vor, dass wir eine (ähnliche) Aktion an mehreren Stellen
 
 Wenn sich der Benutzer einloggt, ausloggt oder sonstige Aktinen ausübt, möchten wir Ihm eine Nachricht anzeigen. 
 
-Funktionen kann man auch als das "Bausteine" des Programs verstehen. Sie erlauben es uns geschriebenen Code häufig abzurufen ohne diesen erneut schreiben zu müssen.
+Funktionen kann man auch als die "Bausteine" des Programms verstehen. Sie erlauben es uns geschriebenen Code häufig abzurufen ohne diesen erneut schreiben zu müssen.
 
-Wir wurden bereits Zeugen von eingebauten (*built-in*) Funktionen (*functions*) wie `alert(message)`, `prompt(message, default)` und `confirm(question)`. Es ist uns aber auch möglich selbst Funktionen zu kreieren.
+Wir haben bereits eingebaute (*built-in*) Funktionen (*functions*) wie `alert(message)`, `prompt(message, default)` und `confirm(question)` gesehen. Es ist uns aber auch möglich selbst Funktionen zu kreieren.
 
 ## Funktionsdeklarierung (*Function Declaration*)
 
@@ -20,7 +20,7 @@ function showMessage() {
 }
 ```
 
-Das *keyword* (Schlüsselwort) `function` steht an erster Stelle, darauf folgt der *Name der Funktion*. Dann noch eine Liste an Parameter zwischen den Parenthesen (mit einem "," voneinander getrennt; im obigen Beispiel leer) und letztlich der Code der Funktion, der auch als "Körper der Funktion" (*the function body*) genannt wird, der zwischen den Akkoladen (*curly braces*) steht.
+Das *keyword* (Schlüsselwort) `function` steht an erster Stelle, darauf folgt der *Name der Funktion*. Dann noch eine Liste an Parameter zwischen den Klammern (mit einem "," voneinander getrennt; im obigen Beispiel leer) und letztlich der Code der Funktion, der auch "Körper der Funktion" (*the function body*) genannt wird, der zwischen den geschweiften Klammern (*curly braces*) steht.
 
 ```js
 function name(parameters) {
@@ -34,7 +34,7 @@ Zum Beispiel:
 
 ```js run
 function showMessage() {
-  alert( 'Hello everyone!' );
+  alert( 'Hallo an alle!' );
 }
 *!*
 showMessage();
@@ -61,7 +61,7 @@ function showMessage() {
   alert( message );
 }
 showMessage(); // Hallo, ich bin JavaScript!
-alert( message ); // <-- Fehler! Die Variabel ist lokal zur Funktion
+alert( message ); // <-- Fehler! Die Variable ist nicht aufrufbar weil sie lokal ist
 ```
 
 ## Außenstehende (*outer*) Variablen
@@ -77,7 +77,7 @@ function showMessage() {
 showMessage(); // Hallo, John
 ```
 
-Die Funktion hat vollständigen Zugriff auf außenstehende Variablen. Und kann diese auch modifieren.
+Die Funktion hat vollständigen Zugriff auf außenstehende Variablen. Und kann diese auch modifizieren.
 
 Hier zu sehen:
 
@@ -130,9 +130,9 @@ Es hat sich als gute und moderne Praxis entwickelt, so wenig globale Variablen w
 
 ## Parameter
 
-Wir können Funktionen jedliche Art von Daten zukommen lassen (auch Funktionsargumente [*function arguments*] genannt).
+Wir können Funktionen jegliche Art von Daten zukommen lassen (auch Funktionsargumente [*function arguments*] genannt).
 
-Im unten stehenden Beispiel hat die Funktion zwei Parameter: `from` und `text`.
+Im folgenden Beispiel hat die Funktion zwei Parameter: `from` und `text`.
 
 ```js run
 function showMessage(*!*from, text*/!*) { // Argumente: from, text
@@ -140,8 +140,8 @@ function showMessage(*!*from, text*/!*) { // Argumente: from, text
 }
 
 *!*
-showMessage('Ann', 'Hello!'); // Ann: Hello! (*)
-showMessage('Ann', "What's up?"); // Ann: What's up? (**)
+showMessage('Ann', 'Hallo!'); // Ann: Hallo! (*)
+showMessage('Ann', "Wie geht's?"); // Ann: Wie geht's? (**)
 */!*
 ```
 
@@ -189,9 +189,9 @@ function showMessage(from, *!*text = "kein Text übergeben"*/!*) {
 
 showMessage("Ann"); // Ann: kein Text übergeben
 ```
-Wenn der `text` Parameter jetzt nicht gegeben wird, erhält er den Wert `"no text given"`
+Wenn der `text` Parameter jetzt nicht gegeben wird, erhält er den Wert `"kein Text übergeben"`
 
-Hier ist `"no text given"` nur ein String, kann aber auch ein viel komplexerer Ausdruck (*expression*) sein, der nur evaluiert und zugewiesen wird, wenn der entsprechende Parameter fehlt. Das macht folgendes möglich:
+Hier ist `"kein Text übergeben"` nur ein String, kann aber auch ein viel komplexerer Ausdruck (*expression*) sein, der nur evaluiert und zugewiesen wird, wenn der entsprechende Parameter fehlt. Das macht folgendes möglich:
 
 ```js run
 function showMessage(from, text = anotherFunction()) {
@@ -215,7 +215,7 @@ Beispielhaft ist eine strikte Prüfung auf `undefined`:
 function showMessage(from, text) {
 *!*
   if (text === undefined) {
-    text = 'no text given';
+    text = 'kein Text übergeben';
   }
 */!*
 
@@ -228,7 +228,7 @@ function showMessage(from, text) {
 ```js
 function showMessage(from, text) {
   // falls text nicht gegeben ist erhält es den "default" Wert
-  text = text || 'no text given';
+  text = text || 'kein Text übergeben';
   ...
 }
 ```