Sync with upstream @ 52c1e619

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

@@ -72,9 +72,14 @@ Es gibt Möglichkeiten, mit Kamera/Mikrofon und anderen Geräten zu interagieren
 
 Dies wird die "Same-Origin-Policy" genannt. Um dies zu umgehen, müssen *beide Seiten* dem Datenaustausch zustimmen und einen speziellen JavaScript-Code enthalten, der dies ermöglicht. Wir werden das im Tutorial behandeln.
 
+<<<<<<< HEAD
     Auch diese Einschränkung dient der Sicherheit des Benutzers. Eine Seite von `http://anysite.com`, die ein Benutzer geöffnet hat, darf nicht in der Lage sein, auf einen anderen Browser-Tab mit der URL `http://gmail.com` zuzugreifen und Informationen von dort zu stehlen.
 - JavaScript kann leicht über das Netz mit dem Server kommunizieren, von dem die aktuelle Seite stammt. Aber seine Fähigkeit, Daten von anderen Seiten/Domains zu empfangen, ist eingeschränkt.
 Obwohl es möglich ist, erfordert es eine ausdrückliche Zustimmung (ausgedrückt in HTTP-Headern) von der entfernten Seite. Auch dies ist eine Sicherheitseinschränkung.
+=======
+    This limitation is, again, for the user's safety. A page from `http://anysite.com` which a user has opened must not be able to access another browser tab with the URL `http://gmail.com`, for example, and steal information from there.
+- JavaScript can easily communicate over the net to the server where the current page came from. But its ability to receive data from other sites/domains is severely limited. Though possible, it requires explicit agreement (expressed in HTTP headers) from the remote side. Once again, that's a safety limitation.
+>>>>>>> 52c1e61915bc8970a950a3f59bd845827e49b4bf
 
 ![](limitations.svg)
 

1-js/01-getting-started/4-devtools/article.md

@@ -22,7 +22,7 @@ Die Entwicklerwerkzeuge öffnen sich standardmäßig auf dem Konsolen-Reiter.
 
 Es sieht in etwa so aus:
 
-![chrome](chrome.png)
+![chrome](chrome.webp)
 
 Das genaue Aussehen der Entwicklerwerkzeuge hängt von deiner Chrome-Version ab. Es ändert sich von Zeit zu Zeit, sollte aber ähnlich aussehen.
 
@@ -49,7 +49,11 @@ Das Aussehen ist meist sehr ähnlich. Sobald du weißt wie man eins dieser Tools
 
 Safari (Mac Browser, nicht unterstützt werden Windows/Linux) ist etwas speziell. Wir müssen zuerst das "Entwickler-Menü" aktivieren.
 
+<<<<<<< HEAD
 Öffne Einstellungen und wähle "Erweitert" aus. Dort ist unten ein Kontrollkästchen:
+=======
+Open Settings and go to the "Advanced" pane. There's a checkbox at the bottom:
+>>>>>>> 52c1e61915bc8970a950a3f59bd845827e49b4bf
 
 ![safari](safari.png)
 

1-js/02-first-steps/04-variables/article.md

@@ -214,7 +214,11 @@ let userName;
 let test123;
 ```
 
+<<<<<<< HEAD
 Wenn der Name mehrere Wörter enthält, wird üblicherweise [camelCase](https://en.wikipedia.org/wiki/CamelCase) verwendet. Das heißt: Wörter kommen eins nach dem anderen, jedes Wort, außer dem ersten, mit einem großen Anfangsbuchstaben: `myVeryLongName`.
+=======
+When the name contains multiple words, [camelCase](https://en.wikipedia.org/wiki/CamelCase) is commonly used. That is: words go one after another, with each word except the first starting with a capital letter: `myVeryLongName`.
+>>>>>>> 52c1e61915bc8970a950a3f59bd845827e49b4bf
 
 Was interessant ist - das Dollarzeichen `'$'` und der Unterstrich `'_'` können auch in Namen verwendet werden. Sie sind normale Symbole, genau wie Buchstaben, ohne besondere Bedeutung.
 

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

@@ -311,7 +311,11 @@ alert( c ); // 4
 
 Verkettete Zuweisungen werden von rechts nach links ausgewertet. Zuerst wird der ganz rechte Ausdruck `2 + 2` ausgewertet und dann den Variablen auf der linken Seite zugewiesen: `c`, `b` und `a`. Am Ende teilen sich alle Variablen einen einzigen Wert.
 
+<<<<<<< HEAD
 Auch hier gilt: Aufgrund der Lesbarkeit ist es besser, solchen Code in wenige Zeilen aufzuteilen:
+=======
+Once again, for the purposes of readability it's better to split such code into a few lines:
+>>>>>>> 52c1e61915bc8970a950a3f59bd845827e49b4bf
 
 ```js
 c = 2 + 2;

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

@@ -212,5 +212,5 @@ Why did we go over these examples? Should we remember these peculiarities all th
 - Comparison operators return a boolean value.
 - Strings are compared letter-by-letter in the "dictionary" order.
 - When values of different types are compared, they get converted to numbers (with the exclusion of a strict equality check).
-- The values `null` and `undefined` equal `==` each other and do not equal any other value.
+- The values `null` and `undefined` are equal `==` to themselves and each other, but do not equal any other value.
 - Be careful when using comparisons like `>` or `<` with variables that can occasionally be `null/undefined`. Checking for `null/undefined` separately is a good idea.

1-js/03-code-quality/02-coding-style/1-style-errors/solution.md

@@ -2,6 +2,7 @@
 Man kann Folgendes anmerken:
 
 ```js no-beautify
+<<<<<<< HEAD
 function pow(x,n)  // <- kein Leerzeichen zwischen Parametern
 {  // <- Klammer auf in eine zweite Zeile
   let result=1;   // <- keine Leerzeichen vor und nach =
@@ -18,6 +19,22 @@ if (n<0)  // <- keine Leerzeichen in den Klammern (n < 0), davor sollte auch ein
   // unten - lange Zeilen können aufgeteilt werden um die Lesbarkeit zu verbessern
   alert(`Exponent ${n} wird nicht unterstützt, bitte geben Sie einen Integerwert ein, der größer ist als null`);
 
+=======
+function pow(x,n)  // <- no space between arguments
+{  // <- curly brace on a separate line
+  let result=1;   // <- no spaces before or after =
+  for(let i=0;i<n;i++) {result*=x;}   // <- no spaces
+  // the contents of { ... } should be on a new line
+  return result;
+}
+
+let x=prompt("x?",''), n=prompt("n?",'') // <-- technically possible,
+// but better make it 2 lines, also there's no spaces and missing ;
+if (n<=0)  // <- no spaces inside (n <= 0), and should be extra line above it
+{   // <- curly brace on a separate line
+  // below - long lines can be split into multiple lines for improved readability
+  alert(`Power ${n} is not supported, please enter an integer number greater than zero`);
+>>>>>>> 52c1e61915bc8970a950a3f59bd845827e49b4bf
 }
 else // <- man könnte es in einer einzigen Zeile schreiben "} else {"
 {

1-js/04-object-basics/01-object/article.md

@@ -5,7 +5,7 @@ As we know from the chapter <info:types>, there are eight data types in JavaScri
 
 In contrast, objects are used to store keyed collections of various data and more complex entities. In JavaScript, objects penetrate almost every aspect of the language. So we must understand them first before going in-depth anywhere else.
 
-An object can be created with figure brackets `{…}` with an optional list of *properties*. A property is a "key: value" pair, where `key` is a string (also called a "property name"), and `value` can be anything.
+An object can be created with curly braces `{…}` with an optional list of *properties*. A property is a "key: value" pair, where `key` is a string (also called a "property name"), and `value` can be anything.
 
 We can imagine an object as a cabinet with signed files. Every piece of data is stored in its file by the key. It's easy to find a file by its name or add/remove a file.
 
@@ -20,7 +20,7 @@ let user = {};  // "object literal" syntax
 
 ![](object-user-empty.svg)
 
-Usually, the figure brackets `{...}` are used. That declaration is called an *object literal*.
+Usually, the curly braces `{...}` are used. That declaration is called an *object literal*.
 
 ## Literals and properties
 

1-js/05-data-types/04-array/article.md

@@ -100,7 +100,7 @@ Let's say we want the last element of the array.
 
 Some programming languages allow the use of negative indexes for the same purpose, like `fruits[-1]`.
 
-Although, in JavaScript it won't work. The result will be `undefined`, because the index in square brackets is treated literally.
+However, in JavaScript it won't work. The result will be `undefined`, because the index in square brackets is treated literally.
 
 We can explicitly calculate the last element index and then access it: `fruits[fruits.length - 1]`.
 

1-js/05-data-types/10-destructuring-assignment/article.md

@@ -82,7 +82,14 @@ Das funktioniert, weil intern eine Zuweisung über Destrukturierung durch Iterie
 ````smart header="Zuweisen an alles auf der linken Seite"
 Wir können jede "zuweisbare" Sache auf der linken Seite verwenden.
 
+<<<<<<< HEAD
 Zum Beispiel, eine Objekteigenschaft:
+=======
+````smart header="Assign to anything on the left-side"
+We can use any "assignables" on the left side.
+
+For instance, an object property:
+>>>>>>> 52c1e61915bc8970a950a3f59bd845827e49b4bf
 ```js run
 let user = {};
 [user.name, user.surname] = "John Smith".split(' ');

1-js/06-advanced-functions/06-function-object/article.md

@@ -326,7 +326,7 @@ welcome(); // Hello, Guest (nested call works)
 
 Now it works, because the name `"func"` is function-local. It is not taken from outside (and not visible there). The specification guarantees that it will always reference the current function.
 
-The outer code still has its variable `sayHi` or `welcome`. And `func` is an "internal function name", the way for the function to can call itself reliably.
+The outer code still has its variable `sayHi` or `welcome`. And `func` is an "internal function name", the way for the function to call itself reliably.
 
 ```smart header="There's no such thing for Function Declaration"
 The "internal name" feature described here is only available for Function Expressions, not for Function Declarations. For Function Declarations, there is no syntax for adding an "internal" name.

1-js/06-advanced-functions/08-settimeout-setinterval/article.md

@@ -218,7 +218,7 @@ And here is the picture for the nested `setTimeout`:
 
 ![](settimeout-interval.svg)
 
-**The nested `setTimeout` guarantees the fixed delay (here 100ms).**
+**The nested `setTimeout` ensures a minimum delay (100ms here) between the end of one call and the beginning of the subsequent one.**
 
 That's because a new call is planned at the end of the previous one.
 

1-js/06-advanced-functions/10-bind/article.md

@@ -125,7 +125,7 @@ funcUser(); // John
 */!*
 ```
 
-Here `func.bind(user)` as a "bound variant" of `func`, with fixed `this=user`.
+Here `func.bind(user)` is a "bound variant" of `func`, with fixed `this=user`.
 
 All arguments are passed to the original `func` "as is", for instance:
 

1-js/09-classes/06-instanceof/article.md

@@ -55,7 +55,7 @@ The algorithm of `obj instanceof Class` works roughly as follows:
     For example:
 
     ```js run
-    // setup instanceOf check that assumes that
+    // set up instanceof check that assumes that
     // anything with canEat property is an animal
     class Animal {
       static [Symbol.hasInstance](obj) {
@@ -68,7 +68,7 @@ The algorithm of `obj instanceof Class` works roughly as follows:
     alert(obj instanceof Animal); // true: Animal[Symbol.hasInstance](obj) is called
     ```
 
-2. Most classes do not have `Symbol.hasInstance`. In that case, the standard logic is used: `obj instanceOf Class` checks whether `Class.prototype` is equal to one of the prototypes in the `obj` prototype chain.
+2. Most classes do not have `Symbol.hasInstance`. In that case, the standard logic is used: `obj instanceof Class` checks whether `Class.prototype` is equal to one of the prototypes in the `obj` prototype chain.
 
     In other words, compare one after another:
     ```js

1-js/10-error-handling/1-try-catch/article.md

@@ -632,7 +632,7 @@ For instance:
 
 The role of the global handler `window.onerror` is usually not to recover the script execution -- that's probably impossible in case of programming errors, but to send the error message to developers.
 
-There are also web-services that provide error-logging for such cases, like <https://errorception.com> or <https://www.muscula.com>.
+There are also web-services that provide error-logging for such cases, like <https://muscula.com> or <https://www.sentry.io>.
 
 They work like this: