Merge pull request #53 from javascript-tutorial/sync-cd2c7ce3

Sync with upstream @ cd2c7ce

Author: christianhegedues

1-js/02-first-steps/01-hello-world/article.md

@@ -78,7 +78,7 @@ Hier ist `/pfad/zum/script.js` ein absoluter Pfad zu dem Skript, aus dem Wurzelv
 Außerdem können wir auch eine komplette URL angeben. Beispielsweise:
 
 ```html
-<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.2.0/lodash.js"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js"></script>
 ```
 
 Um mehrere Skripte einzufügen, nutze Mehrfach-Tags:

1-js/02-first-steps/03-strict-mode/article.md

@@ -19,8 +19,7 @@ Beispielsweise:
 ...
 ```
 
-Wir werden bald Funktionen (eine Möglichkeit, Befehle zu gruppieren) lernen. Mit Blick auf die Zukunft sei angemerkt, dass `"use strict"` anstelle des gesamten Skripts am Anfang des Funktionskörpers stehen kann. Auf diese Weise wird der strikte Modus nur in dieser Funktion aktiviert. Normalerweise wird es jedoch für das gesamte Skript verwendet.
-
+Bald werden wir Funktionen kennenlernen (eine Möglichkeit, Anweisungen zu gruppieren), also, so viel sei verraten, `"use strict"` kann an den Anfang einer Funktion gestellt werden. Auf diese Weise wird der strikte Modus nur in dieser Funktion aktiviert. Normalerweise wird er aber für das ganze Skript verwendet.
 
 ````warn header="Stellen sicher, dass \"use strict\" am Anfang steht"
 Stelle sicher, dass `"use strict"` am Anfang deiner Skripte steht, da sonst der strikte Modus möglicherweise nicht aktiv ist.
@@ -47,11 +46,13 @@ Sobald wir in den strikten Modus wechseln, gibt es kein Zurück mehr.
 
 ## Browser-Konsole
 
-Wenn du in Zukunft eine Browserkonsole zum Testen von Funktionalitäten verwendest, beachte bitte, dass `use strict` standardmäßig nicht verwendet wird.
+Wenn du eine [Entwicklerkonsole](info:devtools) zum Ausführen von Code verwendest, beachte bitte, dass sie standardmäßig nicht `use strict` verwendet.
 
 Manchmal, wenn `use strict` einen Unterschied macht, erhältst du falsche Ergebnisse.
 
-Du kannst versuchen, durch Drücken von `key:Umschalt+Eingabetaste` mehrere Zeilen einzugeben und `use strict` wie folgt an den Anfang zu setzen:
+Wie kann man also in der Konsole tatsächlich `use strict` verwenden?
+
+Zuerst kannst du versuchen, mit `key:Umschalt+Eingabe` mehrere Zeilen einzugeben, und oben drauf `use strict` setzen, so wie hier:
 
 ```js
 'use strict'; <Umschalt+Eingabe für eine neue Zeile>
@@ -61,25 +62,28 @@ Du kannst versuchen, durch Drücken von `key:Umschalt+Eingabetaste` mehrere Zeil
 
 Es funktioniert in den meisten Browsern, wie Firefox und Chrome.
 
-Wenn dies nicht der Fall ist, besteht die zuverlässigste Möglichkeit, um `use strict` sicherzustellen, darin, den Code wie folgt in die Konsole einzugeben:
+Wenn das nicht der Fall ist, z.B. in einem alten Browser, gibt es einen unsauberen, aber zuverlässigen Weg, um `use strict` sicherzustellen. Ummantel es wie folgt:
 
 ```js
 (function() {
   'use strict';
 
-  // ...Dein Code...
+  // ...your code here...
 })()
 ```
 
-## Immer "use strict" verwenden
+## Should we "use strict"?
+
+Die Frage mag offensichtlich klingen, aber dem ist nicht so.
+
+Man könnte empfehlen, Skripte mit `"use strict"` zu beginnen... Aber weißt du, was besser ist?
+
+Modernes JavaScript unterstützt "Klassen" und "Module" - fortgeschrittene Sprachstrukturen (zu denen wir sicher noch kommen werden), die automatisch die `use strict` Verwendung ermöglichen. Wir brauchen also nicht die `"use strict"`-Direktive hinzuzufügen, wenn wir sie verwenden.
 
-Wir müssen die Unterschiede zwischen dem striken Modus und dem "Standardmodus" noch behandeln.
+**Also, für den Moment ist `"use strict;"` ein willkommener Gast an der Spitze deiner Skripte. Später, wenn der Code nur noch aus Klassen und Modulen besteht, können wir ihn weglassen.**
 
-In den nächsten Kapiteln werden wir beim Erlernen der Sprachfunktionen die Unterschiede zwischen dem Strikten und dem Standardmodus feststellen. Zum Glück gibt es nicht viele und sie verbessern unser Leben.
+Ab jetzt sollten wir über `use strict` im Allgemeinen Bescheid wissen.
 
-Im Moment genügt es, allgemein zu wissen:
+In den nächsten Kapiteln werden wir, während wir die sprachlichen Merkmale kennen lernen, die Unterschiede zwischen dem strikten und dem herkömmlichen Modus sehen. Zum Glück gibt es nicht viele, und sie machen uns das Leben tatsächlich angenehmer.
 
-1. Die Anweisung `"use strict"` schaltet die Engine in den "modernen" Modus und ändert das Verhalten einiger eingebauter Funktionen. Wir werden die Details später im Tutorial sehen.
-2. Der strikte Modus wird aktiviert, indem `"use strict"` am Anfang eines Skripts oder einer Funktion platziert wird. Verschiedene Sprachfunktionen, wie "Klassen" und "Module", aktivieren den strikten Modus automatisch.
-3. Der strikte Modus wird von allen modernen Browsern unterstützt.
-4. Wir empfehlen, Skripte immer mit `"use strict"` zu starten. Alle Beispiele in diesen Tutorial gehen von einem strengen Modus aus, sofern nicht (sehr selten) anders angegeben.
+Alle Beispiele in diesem Tutorial gehen vom strikten Modus aus, sofern nicht (sehr selten) anders angegeben.

1-js/02-first-steps/05-types/article.md

@@ -1,16 +1,18 @@
 # Datentypen
 
-Eine Variable in JavaScript kann beliebige Daten enthalten. Eine Variable kann in einem Moment eine Zeichenkette und in einem anderen eine Zahl sein:
+Ein Wert in JavaScript ist immer von einem bestimmten Typ. Zum Beispiel eine Zeichenfolge oder eine Zahl.
+
+Es gibt acht grundlegende Datentypen in JavaScript. Hier werden wir sie allgemein behandeln, und in den nächsten Kapiteln werden wir auf jeden von ihnen im Detail eingehen.
+
+Wir können jeden beliebigen Typ in eine Variable setzen. Zum Beispiel kann eine Variable in einem Moment eine Zeichenfolge sein und dann eine Zahl speichern:
 
 ```js
 // kein Fehler
 let message = "Hallo";
 message = 123456;
 ```
 
-Programmiersprachen, die solche Dinge erlauben, werden als "dynamisch typisiert" bezeichnet, was bedeutet, dass es Datentypen gibt, aber Variablen an keine von ihnen gebunden sind.
-
-Es gibt acht grundlegende Datentypen in JavaScript. Hier werden wir sie allgemein behandeln und in den nächsten Kapiteln detailliert auf sie eingehen.
+Programmiersprachen, die solche Eigenschaften ermöglichen, wie z.B. JavaScript, werden als "dynamisch typisiert" bezeichnet, d.h. es gibt zwar Datentypen, aber die Variablen sind nicht an einen dieser Typen gebunden.
 
 ## Number
 
@@ -64,21 +66,23 @@ Mehr über das Arbeiten mit Zahlen erfahren wir in diesem Kapitel <info:number>.
 
 ## BigInt
 
-In JavaScript kann der Typ "number" keine Ganzzahlwerte darstellen, die größer als <code>2<sup>53</sup></code> (oder kleiner als <code>-2<sup>53</sup></code> für Negative), sind. Das ist eine technische Einschränkung, die durch ihre interne Darstellung verursacht wird. Das sind ungefähr 16 Dezimalstellen, daher ist die Beschränkung für die meisten Zwecke kein Problem, aber manchmal benötigen wir wirklich große Zahlen, z.B. für Verschlüsselungen oder Zeitstempel mit Mikrosekundengenauigkeit.
+In JavaScript kann der Typ "Zahl" keine ganzzahligen Werte darstellen, die größer als <code>(2<sup>53</sup>-1)</code> (das ist `9007199254740991`) oder kleiner als <code>-(-2<sup>53</sup>-1)</code> für Negative sind. Es handelt sich um eine technische Einschränkung, die durch ihre interne Darstellung bedingt ist.
+
+Für die meisten Zwecke reicht das völlig aus, aber manchmal brauchen wir wirklich große Zahlen, z.B. für die Kryptographie oder Zeitstempel mit Mikrosekunden-Genauigkeit.
 
 Der Typ `BigInt` wurde kürzlich der Sprache hinzugefügt, um Ganzzahlen beliebiger Länge darzustellen.
 
-Ein `BigInt` wird durch Anhängen von `n` an das Ende einer Ganzzahl erstellt:
+Ein `BigInt`-Wert wird durch Anhängen von `n` an das Ende einer Ganzzahl erzeugt:
 
 ```js
 // Das "n" am Ende bedeutet, dass es ein BigInt ist
 const bigInt = 1234567890123456789012345678901234567890n;
 ```
 
-Da `BigInt`-Zahlen selten benötigt werden, haben wir ihnen ein eigenes Kapitel gewidmet <info:bigint>.
+Da `BigInt`-Zahlen selten benötigt werden, behandeln wir sie hier nicht, sondern widmen ihnen ein eigenes Kapitel <info:bigint>. Lies es, wenn du so große Zahlen brauchst.
 
-```smart header="Kompatibilitätsprobleme"
-Derzeit wird `BigInt` in Firefox und Chrome unterstützt, nicht jedoch in Safari/IE/Edge.
+```smart header="Compatability issues"
+Im Moment wird `BigInt` in Firefox/Chrome/Edge unterstützt, aber nicht in Safari/IE.
 ```
 
 ## String
@@ -163,41 +167,43 @@ In JavaScript ist `null` kein "Verweis auf ein nicht vorhandenes Objekt" oder ei
 
 Es ist nur ein spezieller Wert, der "nichts", "leer" oder "Wert unbekannt" darstellt.
 
-Der obige Code besagt, dass `age` aus irgendeinem Grund unbekannt oder leer ist.
+Der oben genannte Code besagt, dass `age` unbekannt ist.
 
 ## Der Wert "undefined"
-
 Der spezielle Wert `undefined` steht ebenfalls abseits. Er bildet einen eigenen Typ, genau wie `null`.
 
 Die Bedeutung von `undefined` ist "Wert ist nicht zugewiesen".
 
 Wenn eine Variable deklariert, aber nicht zugewiesen ist, ist ihr Wert `undefined`:
 
 ```js run
-let x;
+let age;
 
-alert(x); // zeigt "undefined"
+alert(age); // zeigt "undefined"
 ```
 
 Technisch gesehen ist es möglich, jeder Variablen ein `undefined` zuzuweisen:
 
 ```js run
-let x = 123;
+let age = 100;
 
-x = undefined;
+// change the value to undefined
+age = undefined;
 
-alert(x); // "undefined"
+alert(age); // "undefined"
 ```
 
-...Aber wir empfehlen das nicht. Normalerweise verwenden wir `null`, um einer Variablen einen "leeren" oder "unbekannten" Wert zuzuweisen, und `undefined`, um zu überprüfen, ob eine Variable zugewiesen wurde.
+...Aber wir raten davon ab, das zu tun. Normalerweise verwendet man `null`, um einer Variablen einen "leeren" oder "unbekannten" Wert zuzuweisen, während `undefined` als Standard-Anfangswert für nicht zugewiesene Werte reserviert ist.
 
 ## Objekte und Symbole
 
 Der Typ `object` ist etwas Besonderes.
 
-Alle anderen Typen werden als "primitive" (skalare) Datentypen bezeichnet, da ihre Werte nur ein einzelnes Element enthalten können (sei es eine Zeichenfolge oder eine Zahl oder was auch immer). Im Gegensatz dazu werden Objekte zum Speichern von Datensammlungen und komplexeren Einheiten verwendet. Wir werden später im Kapitel <info:object> darauf eingehen, nachdem wir mehr über skalare Datentypen erfahren haben.
+Alle anderen Typen werden als "primitiv" bezeichnet, weil ihre Werte nur eine einzige Sache enthalten können (sei es eine Zeichenfolge oder eine Zahl oder was auch immer). Im Gegensatz dazu werden Objekte zur Speicherung von Datensammlungen und komplexeren Entitäten verwendet.
+
+Da Objekte so wichtig sind, verdienen sie besondere Aufmerksamkeit. Wir werden sie später im Kapitel <info:object> behandeln, nachdem wir mehr über Primitive erfahren haben.
 
-Der Typ `symbol` wird verwendet, um eindeutige Bezeichner für Objekte zu erstellen. Der Vollständigkeit halber erwähnen wir es hier, aber wir werden ihn nach den Objekten untersuchen.
+Der Typ `symbol` wird verwendet, um eindeutige Bezeichner für Objekte zu erstellen. Wir müssen es hier der Vollständigkeit halber erwähnen, aber auch die Details aufschieben, bis wir Objekte kennen.
 
 ## Der Operator typeof [#type-typeof]
 
@@ -241,16 +247,16 @@ typeof alert // "function"  (3)
 Die letzten drei Zeilen bedürfen möglicherweise einer zusätzlichen Erläuterung:
 
 1. `Math` ist ein eingebautes Objekt, das mathematische Operationen liefert. Wir werden es im Kapitel <info:number> lernen. Hier dient es nur als Beispiel für ein Objekt.
-2. Das Ergebnis von `typeof null` ist `"object"`. Das ist falsch. Es ist ein offiziell anerkannter Fehler, der aus Kompatibilitätsgründen erhalten wurde. Natürlich ist `null` kein Objekt. Es ist ein besonderer Wert mit einem eigenen Typ. Also, nochmal, es ist ein Fehler der Sprache.
-3. Das Ergebnis von `typeof alert` ist `"function"`, da `alert` eine Funktion ist. Wir werden Funktionen in den nächsten Kapiteln untersuchen, in denen wir auch feststellen werden, dass es in JavaScript keinen speziellen "Funktionstyp" gibt. Funktionen gehören zum Objekttyp. Aber `typeof` behandelt sie anders und gibt `"function"` zurück. Das ist nicht ganz richtig, aber in der Praxis sehr nützlich.
+2. Das Ergebnis von `typeof null` ist `"object"`. Das ist ein offiziell anerkannter Fehler im `typeof`-Verhalten, der aus den frühen Tagen von JavaScript stammt und aus Kompatibilitätsgründen beibehalten wurde. Definitiv ist `null` kein Objekt. Es ist ein besonderer Wert mit einem eigenen Typ.
+3. Das Ergebnis von `typeof alert` ist `"function"`, denn `alert` ist eine Funktion. Wir werden Funktionen in den nächsten Kapiteln untersuchen, wo wir auch sehen werden, dass es keinen speziellen "Funktionstyp" in JavaScript gibt. Funktionen gehören zum Objekttyp. Aber `typeof` behandelt sie anders und gibt `"function"` zurück. Auch das stammt aus den frühen Tagen von JavaScript. Technisch gesehen ist ein solches Verhalten nicht korrekt, kann aber in der Praxis bequem sein.
 
 ## Zusammenfassung
 
 Es gibt 8 grundlegende Datentypen in JavaScript.
 
-- `number` für Zahlen jeglicher Art: Ganzzahl oder Gleitkommazahl, ganze Zahlen werden begrenzt durch ±2<sup>53</sup>.
-- `bigint` steht für ganzzahlige Zahlen beliebiger Länge.
-- `string` für Zeichenketten. Eine String kann aus einem oder mehreren Zeichen bestehen. Es gibt keine separaten Einzelzeichen.
+- `number` für Zahlen jeglicher Art: Ganzzahl oder Gleitkommazahl, ganze Zahlen sind auf ±2<sup>53</sup> begrenzt.
+- `bigint` steht für ganze Zahlen beliebiger Länge.
+- `string` für Zeichenketten. Eine String kann aus null oder mehreren Zeichen bestehen. Es gibt keine separaten Einzelzeichentyp.
 - `boolean` für `true`/`false`.
 - `null` für unbekannte Werte -- ein eigenständiger Typ mit einem einzelnen Wert `null`.
 - `undefined` für nicht zugewiesene Werte -- ein eigenständiger Typ mit einem einzelnen Wert `undefined`.

1-js/02-first-steps/09-alert-prompt-confirm/1-simple-page/solution.md renamed to 1-js/02-first-steps/06-alert-prompt-confirm/1-simple-page/solution.md

@@ -1,26 +1,18 @@
 # Interaktion: alert, prompt, confirm
 
-In diesem Teil des Tutorials behandeln wir die JavaScript-Sprache "als solche", ohne umgebungsspezifische Anpassungen.
-
-Aber wir verwenden immer noch den Browser als Demoumgebung, also sollten wir zumindest einige seiner Funktionen der Benutzeroberfläche kennen. In diesem Kapitel machen wir uns mit den Browser-Funktionen `alert` (hinweisen), `prompt` (anfragen) und `confirm` (bestätigen) vertraut.
+Da wir den Browser als unsere Demo-Umgebung verwenden, wollen wir einige Funktionen zur Interaktion mit dem Benutzer betrachten: `alert`, `prompt` und `confirm`.
 
 ## alert
 
-Syntax:
-
-```js
-alert(message);
-```
-
-Dies zeigt eine Meldung `message` an und hält die Ausführung des Skripts an, bis der Benutzer auf "OK" klickt. 
+Diese haben wir bereits gesehen. Es zeigt eine Meldung an und wartet darauf, dass der Benutzer "OK" drückt.
 
 Zum Beispiel:
 
 ```js run
-alert("Hello");
+alert("Hallo");
 ```
 
-Das Minifenster mit der Meldung wird als *modales Fenster* bezeichnet. Das Wort "modal" bedeutet, dass der Besucher nicht mit dem Rest der Seite interagieren kann, keine anderen Knöpfe drücken kann, usw., bis er sich mit dem Fenster beschäftigt hat. In diesem Fall -- bis er auf "OK" drückt.
+Das Mini-Fenster mit der Nachricht wird als *Dialog-Fenster* bezeichnet. Das Wort "Dialog" bedeutet, dass der Besucher erst dann mit dem Rest der Seite interagieren, andere Knöpfe drücken usw. kann, wenn er sich mit dem Fenster beschäftigt hat. In diesem Fall -- bis er "OK" drückt.
 
 ## prompt
 
@@ -38,7 +30,11 @@ Es wir ein modales Fenster mit einer Meldung angezeigt, ein Eingabefeld für den
 `default`
 : Ein optionaler zweiter Parameter, der vor-befüllte Wert für das Eingabefeld.
 
-Der Besucher kann etwas in das Feld tippen und dann auf OK klicken. Oder er beendet die Eingabe, indem er auf Abbrechen klickt oder die `key:Esc` Taste drückt.
+```smart header="Eckige Klammer in der Syntax `[...]`"
+Die eckigen Klammern um `default` in der obigen Syntax bedeuten, dass der Parameter optional, nicht erforderlich ist.
+```
+
+Der Besucher kann etwas in das Eingabefeld eingeben und OK drücken. Dann erhalten wir diesen Text im `Ergebnis`. Oder er kann die Eingabe beenden, indem er Abbrechen drückt oder `key:Esc` drückt, dann erhalten wir `Null` als `Ergebnis`.
 
 Der Aufruf von `prompt` gibt den Text des Eingabefelds zurück. Wenn die Eingabe abgebrochen wurde, so ist der Rückgabewert `null`.
 
@@ -51,7 +47,7 @@ alert(`Du bist ${age} Jahre alt!`); // Du bist 100 Jahre alt!
 ```
 
 ````warn header="Im IE: stelle immer einen `default` Wert bereit"
-Der zweite Parameter ist optional, aber wenn wir ihn nicht angeben, wird Internet Explorer den Text `"undefined"` in die Eingabeaufforderung einfügen. 
+Der zweite Parameter ist optional, aber wenn wir ihn nicht angeben, wird Internet Explorer den Text `"undefined"` in die Eingabeaufforderung einfügen.
 
 Führe diesen Code im Internet Explorer aus, um es zu sehen:
 

1-js/02-first-steps/09-alert-prompt-confirm/1-simple-page/task.md renamed to 1-js/02-first-steps/06-alert-prompt-confirm/1-simple-page/task.md

@@ -6,8 +6,10 @@ Zum Beispiel wandelt `alert` automatisch jeden Wert in den Datentyp "String" um
 
 Es gibt auch Fälle, in denen wir einen Wert explizit in den erwarteten Datentyp umwandeln müssen.
 
-```smart header="Wir sprechen noch nicht über Objekte"
-In diesem Kapitel werden wir keine Objekte behandeln. Stattdessen werden wir uns zuerst die primitiven Datentypen ansehen. Später, nachdem wir mehr über Objekte gelernt haben, werden wir im Kapitel <info:object-toprimitive> sehen, wie die Objektumwandlung funktioniert.
+```smart header="Noch nicht von Objekten sprechen"
+In diesem Kapitel werden wir keine Objekte behandeln. Im Moment werden wir nur über Primitive sprechen.
+
+Später, nachdem wir etwas über Objekte gelernt haben, werden wir im Kapitel <info:objekt-toprimitive> sehen, wie Objekte hineinpassen.
 ```
 
 ## String Umwandlung