Sync with upstream @ 18b1314a

1-js/02-first-steps/04-variables/3-uppercast-constant/task.md

@@ -12,13 +12,24 @@ const datumNarození = '18.04.1982';
 const věk = nějakýKód(datumNarození);
 ```
 
+<<<<<<< HEAD
 Zde máme konstantu `datumNarození` a pomocí nějakého kódu se z této proměnné vypočítá `věk` (kód není pro stručnost uveden, na podrobnostech zde nezáleží).
+=======
+Here we have a constant `birthday` for the date, and also the `age` constant.
+
+The `age` is calculated from `birthday` using `someCode()`, which means a function call that we didn't explain yet (we will soon!), but the details don't matter here, the point is that `age` is calculated somehow based on the `birthday`.
+>>>>>>> 18b1314af4e0ead5a2b10bb4bacd24cecbb3f18e
 
 Bylo by správné použít pro název proměnné `datumNarození` velká písmena? A pro `věk`? Nebo dokonce pro obě?
 
 ```js
+<<<<<<< HEAD
 const DATUM_NAROZENÍ = '18.04.1982'; // velkými písmeny?
 
 const VĚK = nějakýKód(DATUM_NAROZENÍ); // velkými písmeny?
-```
+=======
+const BIRTHDAY = '18.04.1982'; // make birthday uppercase?
 
+const AGE = someCode(BIRTHDAY); // make age uppercase?
+>>>>>>> 18b1314af4e0ead5a2b10bb4bacd24cecbb3f18e
+```

1-js/02-first-steps/08-operators/3-primitive-conversions-questions/solution.md

@@ -16,10 +16,20 @@ undefined + 1 = NaN // (6)
 " \t \n" - 2 = -2 // (7)
 ```
 
+<<<<<<< HEAD
 1. Sčítání s řetězcem `"" + 1` převede `1` na řetězec: `"" + 1 = "1"`, pak tedy budeme mít `"1" + 0` a použije se stejné pravidlo.
 2. Odčítání `-` (stejně jako většina matematických operací) pracuje jen s čísly, takže převede prázdný řetězec `""` na `0`.
 3. Sčítání s řetězcem připojí k řetězci číslo `5`.
 4. Odčítání vždy převádí operandy na čísla, takže vyrobí z `"  -9  "` číslo `-9` (mezery okolo něj se ignorují).
 5. `null` se převede na číslo `0`.
 6. `undefined` se převede na číslo `NaN`.
 7. Když se řetězec převádí na číslo, mezerové znaky se z jeho začátku a konce odříznou. V tomto případě se celý řetězec skládá z mezerových znaků, konkrétně `\t`, `\n` a „obyčejné“ mezery mezi nimi. Stejně jako prázdný řetězec se tedy převede na `0`.
+=======
+1. The addition with a string `"" + 1` converts `1` to a string: `"" + 1 = "1"`, and then we have `"1" + 0`, the same rule is applied.
+2. The subtraction `-` (like most math operations) only works with numbers, it converts an empty string `""` to `0`.
+3. The addition with a string appends the number `5` to the string.
+4. The subtraction always converts to numbers, so it makes `"  -9  "` a number `-9` (ignoring spaces around it).
+5. `null` becomes `0` after the numeric conversion.
+6. `undefined` becomes `NaN` after the numeric conversion.
+7. Space characters are trimmed off string start and end when a string is converted to a number. Here the whole string consists of space characters, such as `\t`, `\n` and a "regular" space between them. So, similarly to an empty string, it becomes `0`.
+>>>>>>> 18b1314af4e0ead5a2b10bb4bacd24cecbb3f18e

1-js/04-object-basics/02-object-copy/article.md

@@ -160,16 +160,17 @@ We can also use the method [Object.assign](https://developer.mozilla.org/en-US/d
 The syntax is:
 
 ```js
-Object.assign(dest, src1[, src2, src3...])
+Object.assign(dest, ...sources)
 ```
 
 - The first argument `dest` is a target object.
-- Further arguments `src1, ..., srcN` (can be as many as needed) are source objects.
-- It copies the properties of all source objects `src1, ..., srcN` into the target `dest`. In other words, properties of all arguments starting from the second are copied into the first object.
-- The call returns `dest`.
+- Further arguments is a list of source objects.
 
-For instance, we can use it to merge several objects into one:
-```js
+It copies the properties of all source objects into the target `dest`, and then returns it as the result.
+
+For example, we have `user` object, let's add a couple of permissions to it:
+
+```js run
 let user = { name: "John" };
 
 let permissions1 = { canView: true };
@@ -181,6 +182,9 @@ Object.assign(user, permissions1, permissions2);
 */!*
 
 // now user = { name: "John", canView: true, canEdit: true }
+alert(user.name); // John
+alert(user.canView); // true
+alert(user.canEdit); // true
 ```
 
 If the copied property name already exists, it gets overwritten:
@@ -193,9 +197,9 @@ Object.assign(user, { name: "Pete" });
 alert(user.name); // now user = { name: "Pete" }
 ```
 
-We also can use `Object.assign` to replace `for..in` loop for simple cloning:
+We also can use `Object.assign` to perform a simple object cloning:
 
-```js
+```js run
 let user = {
   name: "John",
   age: 30
@@ -204,9 +208,12 @@ let user = {
 *!*
 let clone = Object.assign({}, user);
 */!*
+
+alert(clone.name); // John
+alert(clone.age); // 30
 ```
 
-It copies all properties of `user` into the empty object and returns it.
+Here it copies all properties of `user` into the empty object and returns it.
 
 There are also other methods of cloning an object, e.g. using the [spread syntax](info:rest-parameters-spread) `clone = {...user}`, covered later in the tutorial.
 

1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md

@@ -10,8 +10,8 @@ Is it possible to create functions `A` and `B` so that `new A() == new B()`?
 function A() { ... }
 function B() { ... }
 
-let a = new A;
-let b = new B;
+let a = new A();
+let b = new B();
 
 alert( a == b ); // true
 ```

1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md

@@ -6,7 +6,7 @@ importance: 5
 
 Create a constructor function `Calculator` that creates objects with 3 methods:
 
-- `read()` asks for two values using `prompt` and remembers them in object properties.
+- `read()` prompts for two values and saves them as object properties with names `a` and `b` respectively.
 - `sum()` returns the sum of these properties.
 - `mul()` returns the multiplication product of these properties.
 

1-js/04-object-basics/06-constructor-new/article.md

@@ -171,7 +171,7 @@ alert( new SmallUser().name );  // John
 Usually constructors don't have a `return` statement. Here we mention the special behavior with returning objects mainly for the sake of completeness.
 
 ````smart header="Omitting parentheses"
-By the way, we can omit parentheses after `new`, if it has no arguments:
+By the way, we can omit parentheses after `new`:
 
 ```js
 let user = new User; // <-- no parentheses

1-js/05-data-types/02-number/2-why-rounded-down/solution.md

@@ -28,6 +28,6 @@ Note that `63.5` has no precision loss at all. That's because the decimal part `
 
 
 ```js run
-alert( Math.round(6.35 * 10) / 10); // 6.35 -> 63.5 -> 64(rounded) -> 6.4
+alert( Math.round(6.35 * 10) / 10 ); // 6.35 -> 63.5 -> 64(rounded) -> 6.4
 ```
 

1-js/05-data-types/02-number/article.md

@@ -352,7 +352,7 @@ Please note that an empty or a space-only string is treated as `0` in all numeri
 
     ```js run
     alert( Number.isFinite(123) ); // true
-    alert( Number.isFinite(Infinity) ); //false
+    alert( Number.isFinite(Infinity) ); // false
     alert( Number.isFinite(2 / 0) ); // false
 
     // Note the difference:
@@ -367,7 +367,7 @@ In a way, `Number.isNaN` and `Number.isFinite` are simpler and more straightforw
 There is a special built-in method `Object.is` that compares values like `===`, but is more reliable for two edge cases:
 
 1. It works with `NaN`: `Object.is(NaN, NaN) === true`, that's a good thing.
-2. Values `0` and `-0` are different: `Object.is(0, -0) === false`, technically that's true, because internally the number has a sign bit that may be different even if all other bits are zeroes.
+2. Values `0` and `-0` are different: `Object.is(0, -0) === false`, technically that's correct, because internally the number has a sign bit that may be different even if all other bits are zeroes.
 
 In all other cases, `Object.is(a, b)` is the same as `a === b`.
 

1-js/05-data-types/03-string/1-ucfirst/solution.md

@@ -8,12 +8,7 @@ let newStr = str[0].toUpperCase() + str.slice(1);
 
 There's a small problem though. If `str` is empty, then `str[0]` is `undefined`, and as `undefined` doesn't have the `toUpperCase()` method, we'll get an error.
 
-There are two variants here:
-
-1. Use `str.charAt(0)`, as it always returns a string (maybe empty).
-2. Add a test for an empty string.
-
-Here's the 2nd variant:
+The easiest way out is to add a test for an empty string, like this:
 
 ```js run demo
 function ucFirst(str) {
@@ -24,4 +19,3 @@ function ucFirst(str) {
 
 alert( ucFirst("john") ); // John
 ```
-