Sync with upstream @ f4891457

1-js/01-getting-started/1-intro/article.md

@@ -26,7 +26,11 @@ Verschiedene Engines haben unterschiedliche "Kodnamen". Zum Beispiel:
 
 - [V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) -- in Chrome und Opera.
 - [SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey) -- in Firefox.
+<<<<<<< HEAD
 - ...Es existieren auch noch andere Kodnamen wie "Trident" und "Chakra" für verschiedene Versionen von IE, "ChakraCore" für Microsoft Edge, "Nitro" und "SquirrelFish" für Safari, usw.
+=======
+- ...There are other codenames like "Chakra" for IE, "ChakraCore" for Microsoft Edge, "Nitro" and "SquirrelFish" for Safari, etc.
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 
 Die obigen Begriffe sind gut zu merken, da sie in Entwicklerartikeln im Internet verwendet werden. Wir werden sie auch benutzen. Wenn zum Beispiel "ein Feature X von V8 unterstützt wird", dann funktioniert es wahrscheinlich in Chrome und Opera.
 
@@ -107,10 +111,18 @@ Moderne Werkzeuge machen die Transpilation sehr schnell und transparent und erla
 
 Beispiele für solche Sprachen sind:
 
+<<<<<<< HEAD
 - [CoffeeScript](http://coffeescript.org/) ist ein "syntactic sugar" für JavaScript. Es führt eine kürzere Syntax ein, was uns erlaubt, klareren und präziseren Code zu schreiben. Usually, Ruby devs like it.
 - [TypeScript](http://www.typescriptlang.org/) ist darauf konzentriert "strict data typing" hinzuzufügen. TypeScript verfolg das Ziel den Entwicklungsprozess und den Support für komplexe Systeme zu vereinfachen. Die Sprache wurde von Microsoft entwickelt.
 - [Flow](http://flow.org/) fügt auch "data typing" hinzu, aber auf eine andere Art und Weise. Sie wurde von Facebook entwickelt.
 - [Dart](https://www.dartlang.org/) ist eine eigenständige Sprache, die eine eigene Engine hat, die in Nicht-Browser-Umgebungen (wie z.B. mobilen Anwendungen) läuft, aber auch in JavaScript umgesetzt werden kann. Sie wurde von Google entwickelt.
+=======
+- [CoffeeScript](http://coffeescript.org/) is a "syntactic sugar" for JavaScript. It introduces shorter syntax, allowing us to write clearer and more precise code. Usually, Ruby devs like it.
+- [TypeScript](http://www.typescriptlang.org/) is concentrated on adding "strict data typing" to simplify the development and support of complex systems. It is developed by Microsoft.
+- [Flow](http://flow.org/) also adds data typing, but in a different way. Developed by Facebook.
+- [Dart](https://www.dartlang.org/) is a standalone language that has its own engine that runs in non-browser environments (like mobile apps), but also can be transpiled to JavaScript. Developed by Google.
+- [Brython](https://brython.info/) is a Python transpiler to JavaScript that allow to write application in pure Python without JavaScript.
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 
 Es gibt noch mehr. Auch wenn wir eine der transpilierten Sprachen verwenden sollten wir auch JavaScript trozdem kennen. Es ist wichtig zu verstehen, was im Hintergrund passiert und was wir eigentlich tun.
 

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

@@ -66,7 +66,11 @@ Mehr über das Arbeiten mit Zahlen erfahren wir in diesem Kapitel <info:number>.
 
 ## BigInt
 
+<<<<<<< HEAD
 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.
+=======
+In JavaScript, the "number" type cannot represent integer values larger than <code>(2<sup>53</sup>-1)</code> (that's `9007199254740991`), or less than <code>-(2<sup>53</sup>-1)</code> for negatives. It's a technical limitation caused by their internal representation.
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 
 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.
 
@@ -81,10 +85,18 @@ const bigInt = 1234567890123456789012345678901234567890n;
 
 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.
 
+<<<<<<< HEAD
 ```smart header="Compatability issues"
 Im Moment wird `BigInt` in Firefox/Chrome/Edge unterstützt, aber nicht in Safari/IE.
+=======
+
+```smart header="Compatibility issues"
+Right now, `BigInt` is supported in Firefox/Chrome/Edge/Safari, but not in IE.
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 ```
 
+You can check [*MDN* BigInt compatibility table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#Browser_compatibility) to know which versions of a browser are supported.
+
 ## String
 
 Ein String in JavaScript muss in Anführungszeichen gesetzt werden.
@@ -127,7 +139,11 @@ In diesem Kapitel werden wir uns eingehender mit Strings befassen <info:string>.
 ```smart header="Es gibt keinen *Zeichen*-Typ."
 In einigen Sprachen gibt es einen speziellen "Zeichen"-Typ für ein einzelnes Zeichen. In der C-Sprache und in Java heißt er beispielsweise "char".
 
+<<<<<<< HEAD
 In JavaScript gibt es so einen Typ nicht. Es gibt nur einen Typ: `string`. Eine Zeichenfolge kann aus nur einem oder mehreren Zeichen bestehen.
+=======
+In JavaScript, there is no such type. There's only one type: `string`. A string may consist of zero characters (be empty), one character or many of them.
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 ```
 
 ## Boolean (logische Werte)
@@ -254,6 +270,7 @@ Die letzten drei Zeilen bedürfen möglicherweise einer zusätzlichen Erläuteru
 
 Es gibt 8 grundlegende Datentypen in JavaScript.
 
+<<<<<<< HEAD
 - `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.
@@ -262,6 +279,16 @@ Es gibt 8 grundlegende Datentypen in JavaScript.
 - `undefined` für nicht zugewiesene Werte -- ein eigenständiger Typ mit einem einzelnen Wert `undefined`.
 - `object` für komplexere Datenstrukturen.
 - `symbol` für eindeutige Kennungen.
+=======
+- `number` for numbers of any kind: integer or floating-point, integers are limited by <code>±(2<sup>53</sup>-1)</code>.
+- `bigint` is for integer numbers of arbitrary length.
+- `string` for strings. A string may have zero or more characters, there's no separate single-character type.
+- `boolean` for `true`/`false`.
+- `null` for unknown values -- a standalone type that has a single value `null`.
+- `undefined` for unassigned values -- a standalone type that has a single value `undefined`.
+- `object` for more complex data structures.
+- `symbol` for unique identifiers.
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 
 Mit dem Operator `typeof` können wir sehen, welcher Typ in einer Variablen gespeichert ist.
 

1-js/02-first-steps/06-alert-prompt-confirm/article.md

@@ -4,7 +4,11 @@ Da wir den Browser als unsere Demo-Umgebung verwenden, wollen wir einige Funktio
 
 ## alert
 
+<<<<<<< HEAD
 Diese haben wir bereits gesehen. Es zeigt eine Meldung an und wartet darauf, dass der Benutzer "OK" drückt.
+=======
+This one we've seen already. It shows a message and waits for the user to press "OK".
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 
 Zum Beispiel:
 
@@ -30,8 +34,13 @@ 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.
 
+<<<<<<< HEAD
 ```smart header="Eckige Klammer in der Syntax `[...]`"
 Die eckigen Klammern um `default` in der obigen Syntax bedeuten, dass der Parameter optional, nicht erforderlich ist.
+=======
+```smart header="The square brackets in syntax `[...]`"
+The square brackets around `default` in the syntax above denote that the parameter is optional, not required.
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 ```
 
 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`.

1-js/02-first-steps/08-operators/4-fix-prompt/solution.md

@@ -9,7 +9,7 @@ let b = "2"; // prompt("Second number?", 2);
 alert(a + b); // 12
 ```
 
-What we should to is to convert strings to numbers before `+`. For example, using `Number()` or prepending them with `+`.
+What we should do is to convert strings to numbers before `+`. For example, using `Number()` or prepending them with `+`.
 
 For example, right before `prompt`:
 

1-js/02-first-steps/08-operators/article.md

@@ -180,7 +180,11 @@ Klammern überschreiben alle Prioritäten. Wenn wir mit der Standardreihenfolge
 
 In JavaScript gibt es viele Operatoren. Jeder Operator hat eine entsprechende Vorrangsnummer. Der mit der größeren Nummer wird zuerst ausgeführt. Bei gleicher Rangfolge erfolgt die Ausführung von links nach rechts.
 
+<<<<<<< HEAD
 Hier ist ein Auszug aus der [Ranglistentabelle](https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Operators/Operator_Precedence) (Du musst dir das nicht merken, aber beachte, dass unäre Operatoren höher sind als entsprechende binäre):
+=======
+Here's an extract from the [precedence table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence) (you don't need to remember this, but note that unary operators are higher than corresponding binary ones):
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 
 | Vorrang | Name | Zeichen |
 |------------|------|------|
@@ -428,7 +432,11 @@ Die Liste der Operatoren:
 - Rechtsverschiebung ( `>>` )
 - Null füllende Rechtsverschiebung ( `>>>` )
 
+<<<<<<< HEAD
 Diese Operatoren werden sehr selten verwendet, wenn wir mit Zahlen auf der untersten (bitweisen) Ebene herumspielen müssen. Wir werden diese Operatoren in absehbarer Zeit nicht brauchen, da die Webentwicklung kaum Gebrauch von ihnen macht, aber in einigen speziellen Bereichen, wie der Kryptographie, sind sie nützlich. Bei bedarf kannst du den Artikel [Bitweise Operatoren](https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Operators/Bitwise_Operatoren) auf MDN lesen.
+=======
+These operators are used very rarely, when we need to fiddle with numbers on the very lowest (bitwise) level. We won't need these operators any time soon, as web development has little use of them, but in some special areas, such as cryptography, they are useful. You can read the [Bitwise Operators](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#Bitwise) chapter on MDN when a need arises.
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 
 ## Komma
 

1-js/02-first-steps/09-comparison/1-comparison-questions/solution.md

@@ -14,7 +14,7 @@ Some of the reasons:
 
 1. Obviously, true.
 2. Dictionary comparison, hence false. `"a"` is smaller than `"p"`.
-3. Again, dictionary comparison, first char of `"2"` is greater than the first char of `"1"`.
+3. Again, dictionary comparison, first char `"2"` is greater than the first char `"1"`.
 4. Values `null` and `undefined` equal each other only.
 5. Strict equality is strict. Different types from both sides lead to false.
 6. Similar to `(4)`, `null` only equals `undefined`.

1-js/02-first-steps/09-comparison/article.md

@@ -9,9 +9,9 @@ In JavaScript they are written like this:
 - Equals: `a == b`, please note the double equality sign `==` means the equality test, while a single one `a = b` means an assignment.
 - Not equals. In maths the notation is <code>&ne;</code>, but in JavaScript it's written as <code>a != b</code>.
 
-In this article we'll learn more about different types of comparisons, how JavaScript makes them, including important peculiarities. 
+In this article we'll learn more about different types of comparisons, how JavaScript makes them, including important peculiarities.
 
-At the end you'll find a good recipe to avoid "javascript quirks"-related issues.
+At the end you'll find a good recipe to avoid "JavaScript quirks"-related issues.
 
 ## Boolean is the result
 
@@ -57,7 +57,7 @@ The algorithm to compare two strings is simple:
 4. Repeat until the end of either string.
 5. If both strings end at the same length, then they are equal. Otherwise, the longer string is greater.
 
-In the examples above, the comparison `'Z' > 'A'` gets to a result at the first step while the strings `"Glow"` and `"Glee"` are compared character-by-character:
+In the examples above, the comparison `'Z' > 'A'` gets to a result at the first step while the strings `'Glow'` and `'Glee'` are compared character-by-character:
 
 1. `G` is the same as `G`.
 2. `l` is the same as `l`.

1-js/02-first-steps/10-ifelse/article.md

@@ -1,4 +1,4 @@
-# Conditional operators: if, '?'
+# Conditional branching: if, '?'
 
 Sometimes, we need to perform different actions based on different conditions.
 

1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md

@@ -4,4 +4,10 @@ importance: 3
 
 # Bereichsprüfung (positiv)
 
+<<<<<<< HEAD
 Schreibe die Bedingung für eine Fallunterscheidung mit `if` um zu prüfen, daß `age` zwischen `14` and `90` liegt (Grenzen inklusive, `age` kann also die Werte `14` und `90` annehmen).
+=======
+Write an `if` condition to check that `age` is between `14` and `90` inclusively.
+
+"Inclusively" means that `age` can reach the edges `14` or `90`.
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d

1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md

@@ -4,6 +4,10 @@ importance: 3
 
 # Bereichsprüfung (negativ)
 
+<<<<<<< HEAD
 Schreibe die Bedingung für eine Fallunterscheidung mit `if` um zu prüfen, dass `age` NICHT zwischen `14` und `90` liegt (Grenzen inklusive).
+=======
+Write an `if` condition to check that `age` is NOT between `14` and `90` inclusively.
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 
 Formuliere 2 Varianten, die Erste mit NICHT `!`, die Zweite -- ohne.

1-js/02-first-steps/11-logical-operators/9-check-login/solution.md

@@ -3,20 +3,32 @@
 ```js run demo
 let userName = prompt("Wer da?", '');
 
-if (userName == 'Admin') {
+if (userName === 'Admin') {
 
   let pass = prompt('Passwort?', '');
 
+<<<<<<< HEAD
   if (pass == 'TheMaster') {
     alert( 'Willkommen!' );
   } else if (pass == '' || pass == null) {
     alert( 'Abbruch' );
+=======
+  if (pass === 'TheMaster') {
+    alert( 'Welcome!' );
+  } else if (pass === '' || pass === null) {
+    alert( 'Canceled' );
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
   } else {
     alert( 'Falsches Passwort' );
   }
 
+<<<<<<< HEAD
 } else if (userName == '' || userName == null) {
   alert( 'Abbruch' );
+=======
+} else if (userName === '' || userName === null) {
+  alert( 'Canceled' );
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 } else {
   alert( "Ich kenne Sie nicht!" );
 }

1-js/02-first-steps/11-logical-operators/article.md

@@ -84,7 +84,11 @@ arbeitet der Operator ODER `||` wie folgt:
 
 Ein Wert wird in seiner ursprünglichen Form zurückgegeben, ohne die Konvertierung.
 
+<<<<<<< HEAD
 Mit anderen Worten, eine Folge von ODER `"||"` gibt den ersten effektiv wahren Wert zurück oder - sofern kein solcher gefunden wird - den letzten Wert.
+=======
+In other words, a chain of OR `||` returns the first truthy value or the last one if no truthy value is found.
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 
 Beispiel:
 
@@ -101,9 +105,15 @@ Das führt im Vergleich zu einem "reinen, klassischen, nur-Booleschen ODER" zu e
 
 1. **Bestimme den ersten effektiv wahren Wert aus einer Liste von Variablen bzw. Ausdrücken.**
 
+<<<<<<< HEAD
     Haben wir zum Beispiel die Variablen `firstName`, `lastName` und `nickName`, die alle optional sind.
 
     Benutzen wir ODER `||`, um denjenigen auszuwählen, der Daten enthält und geben sie aus (oder `Anonym` wenn nichts gesetzt ist):
+=======
+    For instance, we have `firstName`, `lastName` and `nickName` variables, all optional (i.e. can be undefined or have falsy values).
+
+    Let's use OR `||` to choose the one that has the data and show it (or `"Anonymous"` if nothing set):
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 
     ```js run
     let firstName = "";
@@ -115,7 +125,11 @@ Das führt im Vergleich zu einem "reinen, klassischen, nur-Booleschen ODER" zu e
     */!*
     ```
 
+<<<<<<< HEAD
     Wenn alle Variablen falsch sind, würde `Anonym` herauskommen.
+=======
+    If all variables were falsy, `"Anonymous"` would show up.
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 
 2. **Short-circuit evaluation.**
 
@@ -223,8 +237,13 @@ Die Präzedenz der Operators UND  `&&` ist höher als die von ODER `||`.
 Der Code `a && b || c && d` verhält sich daher i.w. so, als ob die Ausdrücke mit `&&` in Klammern gesetzt würden: `(a && b) || (c && d)`.
 ````
 
+<<<<<<< HEAD
 ````warn header="Ersetze `if` nicht durch || oder &&"
 Manchmal wird der Operator UND `&&` als "Kürzel zum Schreiben von `if`" verwendet.
+=======
+````warn header="Don't replace `if` with `||` or `&&`"
+Sometimes, people use the AND `&&` operator as a "shorter way to write `if`".
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 
 Beispiel:
 
@@ -244,7 +263,11 @@ let x = 1;
 if (x > 0) alert( 'Größer als Null!' );
 ```
 
+<<<<<<< HEAD
 Obwohl die Variante mit `&&` kürzer erscheint, ist `if` offensichtlicher und tendenziell etwas lesbarer. Daher empfehlen wir, jedes Konstrukt für seinen Zweck zu verwenden: Verwende `if`, wenn wir eine Bedingung wollen, und verwende `&&`, wenn wir UND wollen.
+=======
+Although, the variant with `&&` appears shorter, `if` is more obvious and tends to be a little bit more readable. So we recommend using every construct for its purpose: use `if` if we want `if` and use `&&` if we want AND.
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 ````