Merge pull request #51 from otmon76/master

changes from English version implemented

Author: otmon76

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

@@ -117,12 +117,6 @@ Jsou i další. Samozřejmě i když používáme některý z transpilovaných j
 
 ## Shrnutí
 
-<<<<<<< HEAD
 - JavaScript byl původně vytvořen jako jazyk určený výhradně pro prohlížeč, ale dnes se používá i v mnoha jiných prostředích.
 - Dnes si JavaScript vydobyl unikátní postavení jako nejrozsáhleji přijímaný prohlížečový jazyk s plnou integrací s HTML/CSS.
 - Existuje mnoho jazyků, které jsou „transpilovány“ do JavaScriptu a poskytují určité vlastnosti. Až zvládnete JavaScript, doporučujeme vám, abyste se na ně alespoň krátce podívali.
-=======
-- JavaScript was initially created as a browser-only language, but it is now used in many other environments as well.
-- Today, JavaScript has a unique position as the most widely-adopted browser language, fully integrated with HTML/CSS.
-- There are many languages that get "transpiled" to JavaScript and provide certain features. It is recommended to take a look at them, at least briefly, after mastering JavaScript.
->>>>>>> 4541b7af7584014a676da731f6e8774da5e059f6

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

@@ -40,31 +40,22 @@ Kromě běžných čísel obsahuje JavaScript i tzv. „speciální číselné h
     ```js run
     alert( Infinity ); // Infinity
     ```
+    
 - `NaN` (z anglického „not a number“ -- není číslo) představuje výpočetní chybu. Je to výsledek nekorektní nebo nedefinované matematické operace, například:
 
     ```js run
     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
+    alert( "to není číslo" / 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
+    Je-li tedy někde v matematickém výrazu `NaN`, přenese se až do jeho celkového výsledku (jediná výjimka: `NaN ** 0` je `1`).
 
 ```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ě.
@@ -98,7 +89,6 @@ Právě nyní je `BigInt` podporován ve Firefoxu/Chrome/Edge/Safari, ale ne v I
 Nahlédnutím do [*MDN* tabulky kompatibility BigInt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#Browser_compatibility) zjistíte, které verze prohlížeče jej podporují.
 
 ## Řetězec
-=======
 
 Řetězec (anglicky string) v JavaScriptu musí být uzavřen do uvozovek.
 
@@ -112,7 +102,7 @@ JavaScript rozeznává tři druhy uvozovek.
 
 1. Dvojité uvozovky: `"Ahoj"`.
 2. Jednoduché uvozovky (apostrofy): `'Ahoj'`.
-3. Obrácené čárky (gravisy): <code>&#96;Hello&#96;</code>.
+3. Obrácené čárky (gravisy): <code>&#96;Ahoj&#96;</code>.
 
 Dvojité uvozovky a apostrofy jsou „obyčejné“ uvozovky. V JavaScriptu mezi nimi není prakticky žádný rozdíl.
 
@@ -253,10 +243,10 @@ Poslední tři řádky možná vyžadují podrobnější vysvětlení:
 2. Výsledkem `typeof null` je `"object"`. Toto je oficiálně přiznaná chyba chování `typeof`, která pochází z pravěku JavaScriptu a byla v něm ponechána kvůli kompatibilitě. Ve skutečnosti `null` není objekt. Je to speciální hodnota, která má svůj vlastní typ.
 3. Výsledkem `typeof alert` je `"function"`, protože `alert` je funkce. Funkce prostudujeme v dalších kapitolách, kde také uvidíme, že v JavaScriptu není žádný speciální typ „funkce“. Funkce jsou typu objekt. Avšak `typeof` s nimi zachází jinak a vrátí `"function"`. To také pochází z pravěku JavaScriptu. Technicky není toto chování korektní, ale v praxi může být užitečné.
 
-```smart header="Syntaxe `typeof(x)` syntax"
+```smart header="Syntaxe `typeof(x)`"
 Můžete narazit i na jinou syntaxi: `typeof(x)`. To je totéž jako `typeof x`.
 
-Abychom to objasnili: `typeof` je operátor, ne funkce. Závorky zde uvedené nejsou součástí `typeof`. Je to druh závorek používaný pro seskupování v matematice.
+Abychom to objasnili: `typeof` je operátor, ne funkce. Závorky zde uvedené nejsou součástí `typeof`. Je to stejný druh závorek, který se v matematice používá pro seskupování.
 
 Zpravidla takové závorky obsahují matematický výraz, např. `(2 + 2)`, ale zde obsahují jen jediný argument `(x)`. Syntakticky umožňují vyhnout se mezeře mezi operátorem `typeof` a jeho argumentem. Některým lidem se to líbí.
 

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

@@ -193,41 +193,22 @@ 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í | `**` |
-| 15 | násobení | `*` |
-| 15 | dělení | `/` |
-| 13 | sčítání | `+` |
-| 13 | odčítání | `-` |
+| 15 | unární plus | `+` |
+| 15 | unární negace | `-` |
+| 14 | umocňování | `**` |
+| 13 | násobení | `*` |
+| 13 | dělení | `/` |
+| 12 | sčítání | `+` |
+| 12 | odčítání | `-` |
 | ... | ... | ... |
-| 3 | přiřazení | `=` |
+| 2 | přiřazení | `=` |
 | ... | ... | ... |
 
-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
+Jak vidíme, „unární plus“ má prioritu `15`, 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.
 
 ## 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
+Všimněte si, že přiřazení `=` je také operátor. V tabulce priorit je uveden s velmi nízkou prioritou `2`.
 
 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,11 +106,7 @@ 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
+Priorita operátoru `??` je stejná jako `||`. Oba operátory mají v [tabulce MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table) prioritu `4`.
 
 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,11 +12,7 @@ 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,11 +33,7 @@ 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í.
 
@@ -90,11 +86,7 @@ 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/06-constructor-new/article.md

@@ -1,10 +1,6 @@
 # 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,11 +25,7 @@ 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/02-number/article.md

@@ -44,7 +44,7 @@ Jinými slovy, `e` toto číslo násobí číslem `1` se zadaným počtem nul.
 Nyní zapišme něco velmi malého. Třeba 1 mikrosekundu (jednu milióntinu sekundy):
 
 ```js
-let mсs = 0.000001;
+let mcs = 0.000001;
 ```
 
 Stejně jako předtím nám může pomoci použití `"e"`. Jestliže se chceme vyhnout explicitnímu zápisu nul, můžeme zapsat totéž jako:

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

@@ -27,17 +27,10 @@ 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
+4. Výsledek `next()` musí mít tvar `{done: Boolean, value: cokoli}`, kde `done=true` znamená, že cyklus má skončit, v opačném případě je `value` jeho další hodnotou.
 
 Zde je úplná implementace objektu `interval` s komentáři:
 
@@ -50,19 +43,11 @@ 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
+  // 2. Od této chvíle for..of pracuje jen s níže uvedeným objektem iterátoru 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() {
@@ -284,11 +269,7 @@ 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: