Merge pull request #50 from javascript-tutorial/sync-71da17e5

Sync with upstream @ 71da17e

Author: otmon76

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

@@ -46,13 +46,25 @@ Kromě běžných čísel obsahuje JavaScript i tzv. „speciální číselné h
     alert( "to není číslo" / 2 ); // NaN, takové dělení je chybné
     ```
 
+<<<<<<< HEAD
     `NaN` je „lepkavé“. Jakákoli operace provedená s `NaN` vrátí opět `NaN`:
 
     ```js run
     alert( "to není číslo" / 2 + 5 ); // NaN
     ```
 
     Je-li tedy někde v matematickém výrazu `NaN`, přenese se až do jeho celkového výsledku.
+=======
+    `NaN` is sticky. Any further mathematical operation on `NaN` returns `NaN`:
+
+    ```js run
+    alert( NaN + 1 ); // NaN
+    alert( 3 * NaN ); // NaN
+    alert( "not a number" / 2 - 1 ); // NaN
+    ```
+
+    So, if there's a `NaN` somewhere in a mathematical expression, it propagates to the whole result (there's only one exception to that: `NaN ** 0` is `1`).
+>>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
 
 ```smart header="Matematické operace jsou bezpečné"
 Veškeré matematické výpočty v JavaScriptu jsou „bezpečné“. Můžeme provádět cokoli: dělit nulou, zacházet s řetězci neobsahujícími číslo jako s čísly a podobně.

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

@@ -193,6 +193,7 @@ Následuje výtažek z [tabulky priorit](https://developer.mozilla.org/en-US/doc
 | Priorita | Název | Znak |
 |----------|-------|------|
 | ... | ... | ... |
+<<<<<<< HEAD
 | 17 | unární plus | `+` |
 | 17 | unární negace | `-` |
 | 16 | umocňování | `**` |
@@ -205,10 +206,28 @@ Následuje výtažek z [tabulky priorit](https://developer.mozilla.org/en-US/doc
 | ... | ... | ... |
 
 Jak vidíme, „unární plus“ má prioritu `17`, která je vyšší než priorita `13` „sčítání“ (binární plus). To je důvod, proč se ve výrazu `"+jablka + +pomeranče"` unární plusy vyhodnotí před sčítáním.
+=======
+| 15 | unary plus | `+` |
+| 15 | unary negation | `-` |
+| 14 | exponentiation | `**` |
+| 13 | multiplication | `*` |
+| 13 | division | `/` |
+| 12 | addition | `+` |
+| 12 | subtraction | `-` |
+| ... | ... | ... |
+| 2 | assignment | `=` |
+| ... | ... | ... |
+
+As we can see, the "unary plus" has a priority of `15` which is higher than the `13` of "addition" (binary plus). That's why, in the expression `"+apples + +oranges"`, unary pluses work before the addition.
+>>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
 
 ## Přiřazení
 
+<<<<<<< HEAD
 Všimněte si, že přiřazení `=` je také operátor. V tabulce priorit je uveden s velmi nízkou prioritou `3`.
+=======
+Let's note that an assignment `=` is also an operator. It is listed in the precedence table with the very low priority of `2`.
+>>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
 
 To je důvod, proč při přiřazení proměnné, např. `x = 2 * 2 + 1`, se nejprve provedou výpočty a až potom se vyhodnotí `=`, které uloží výsledek do `x`.
 

1-js/02-first-steps/12-nullish-coalescing-operator/article.md

@@ -106,7 +106,11 @@ V praxi je nulová výška často platnou hodnotou, takže by neměla být nahra
 
 ## Priorita
 
+<<<<<<< HEAD
 Priorita operátoru `??` je přibližně stejná jako `||`, jen o něco nižší. Je rovna `5` v [tabulce MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table), zatímco `||` má prioritu `6`.
+=======
+The precedence of the `??` operator is the same as `||`. They both equal `4` in the [MDN table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table).
+>>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
 
 To znamená, že operátor koalescence `??` se stejně jako `||` vyhodnocuje před `=` a `?`, ale až po většině ostatních operací, například  `+`, `*`.
 

1-js/02-first-steps/16-function-expressions/article.md

@@ -12,7 +12,11 @@ function řekniAhoj() {
 
 Existuje i jiná syntaxe pro vytváření funkce, která se nazývá *funkční výraz*.
 
+<<<<<<< HEAD
 Ten nám umožňuje vytvořit novou funkci uprostřed libovolného výrazu.
+=======
+It allows us to create a new function in the middle of any expression.
+>>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
 
 Například:
 

1-js/02-first-steps/17-arrow-functions-basics/article.md

@@ -33,7 +33,11 @@ let součet = function(a, b) {
 alert( součet(1, 2) ); // 3
 ```
 
+<<<<<<< HEAD
 Jak vidíte, `(a, b) => a + b` znamená funkci, která přijímá dva argumenty pojmenované `a` a `b`. Když je vykonána, vyhodnotí výraz `a + b` a vrátí jeho výsledek.
+=======
+As you can see, `(a, b) => a + b` means a function that accepts two arguments named `a` and `b`. Upon the execution, it evaluates the expression `a + b` and returns the result.
+>>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
 
 - Máme-li pouze jeden argument, můžeme závorky kolem něj vynechat, čímž se zápis ještě zkrátí.
 
@@ -86,7 +90,11 @@ Například takto:
 let součet = (a, b) => {  // složená závorka uvozuje víceřádkovou funkci
   let výsledek = a + b;
 *!*
+<<<<<<< HEAD
   return výsledek; // když používáme složené závorky, musíme výslovně uvést „return“
+=======
+  return result; // if we use curly braces, then we need an explicit "return"
+>>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
 */!*
 };
 

1-js/04-object-basics/04-object-methods/8-chain-calls/_js.view/solution.js

@@ -9,7 +9,13 @@ let žebřík = {
     this.stupeň--;
     return this;
   },
+<<<<<<< HEAD
   zobrazStupeň: function() { 
     alert(this.stupeň);
+=======
+  showStep: function() { 
+    alert(this.step);
+    return this;
+>>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
   }
 };

1-js/04-object-basics/04-object-methods/8-chain-calls/_js.view/test.js

@@ -32,6 +32,14 @@ describe('Žebřík', function() {
   it('dolů().nahoru().nahoru().nahoru() ', function() {
     assert.equal(žebřík.dolů().nahoru().nahoru().nahoru().stupeň, 2);
   });
+
+  it('showStep() should return this', function() {
+    assert.equal(ladder.showStep(), ladder);
+  });
+ 
+  it('up().up().down().showStep().down().showStep()', function () {
+    assert.equal(ladder.up().up().down().showStep().down().showStep().step, 0)
+  });
 
   after(function() {
     žebřík.stupeň = 0;

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

@@ -1,6 +1,10 @@
 # Konstruktor, operátor „new“
 
+<<<<<<< HEAD
 Obvyklá syntaxe `{...}` nám umožňuje vytvořit jeden objekt. Často však potřebujeme vytvořit mnoho podobných objektů, např. více uživatelů, položek menu a podobně.
+=======
+The regular `{...}` syntax allows us to create one object. But often we need to create many similar objects, like multiple users or menu items and so on.
+>>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
 
 To můžeme učinit pomocí konstruktorů a operátoru `"new"`.
 

1-js/04-object-basics/07-optional-chaining/article.md

@@ -25,7 +25,11 @@ To je očekávaný výsledek. JavaScript takto funguje. Když `uživatel.adresa`
 
 V mnoha praktických případech bychom však zde raději získali `undefined` místo chyby (což znamená „žádná ulice“).
 
+<<<<<<< HEAD
 ...A jiný příklad. Při vývoji webů můžeme pomocí speciálního volání metody, např. `document.querySelector('.elem')`, získat objekt, který odpovídá určitému prvku webové stránky. Když na stránce takový prvek není, metoda vrací `null`.
+=======
+...and another example. In Web development, we can get an object that corresponds to a web page element using a special method call, such as `document.querySelector('.elem')`, and it returns `null` when there's no such element.
+>>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
 
 ```js run
 // document.querySelector('.elem') je null, pokud tam žádný prvek není

1-js/05-data-types/06-iterable/article.md

@@ -27,10 +27,17 @@ let interval = {
 
 Abychom učinili objekt `interval` iterovatelným (a tím zprovoznili `for..of`), musíme do tohoto objektu přidat metodu nazvanou `Symbol.iterator` (speciální vestavěný symbol právě pro tento účel).
 
+<<<<<<< HEAD
 1. Když `for..of` začne, jedenkrát tuto metodu zavolá (nebo ohlásí chybu, není-li nalezena). Metoda musí vracet *iterátor* -- objekt obsahující metodu `next`.
 2. Nadále `for..of` pracuje *pouze s tímto vráceným objektem*.
 3. Když `for..of` chce další hodnotu, volá na tomto objektu `next()`.
 4. Výsledek `next()` musí mít tvar `{done: Boolean, value: cokoli}`, kde `done=true` znamená, že iterace skončila, v opačném případě je další hodnotou `value`.
+=======
+1. When `for..of` starts, it calls that method once (or errors if not found). The method must return an *iterator* -- an object with the method `next`.
+2. Onward, `for..of` works *only with that returned object*.
+3. When `for..of` wants the next value, it calls `next()` on that object.
+4. The result of `next()` must have the form `{done: Boolean, value: any}`, where `done=true` means that the loop is finished, otherwise `value` is the next value.
+>>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
 
 Zde je úplná implementace objektu `interval` s komentáři:
 
@@ -43,11 +50,19 @@ let interval = {
 // 1. volání for..of nejprve zavolá tuto funkci
 interval[Symbol.iterator] = function() {
 
+<<<<<<< HEAD
   // ...tato funkce vrátí objekt iterátoru:
   // 2. Od této chvíle for..of pracuje jen s tímto iterátorem a ptá se ho na další hodnoty
   return {
     aktuální: this.začátek,
     poslední: this.konec,
+=======
+  // ...it returns the iterator object:
+  // 2. Onward, for..of works only with the iterator object below, asking it for next values
+  return {
+    current: this.from,
+    last: this.to,
+>>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
 
     // 3. next() je volána cyklem for..of při každé iteraci
     next() {
@@ -269,7 +284,11 @@ for (let znak of str) {
 alert(znaky);
 ```
 
+<<<<<<< HEAD
 ...Ale je to kratší.
+=======
+...But it is shorter.
+>>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
 
 Můžeme na ní dokonce postavit metodu `slice`, která bude rozpoznávat surrogate pairy: