Merge branch 'javascript-tutorial:master' into master

Author: otmon76

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

@@ -108,9 +108,15 @@ Např. `?.` v `uživatel?.adresa.ulice.name` umožňuje, aby `uživatel` byl bez
 ```warn header="Nepoužívejte volitelné zřetězení přehnaně často"
 Měli bychom používat `?.` jen tehdy, když je v pořádku, že něco neexistuje.
 
+<<<<<<< HEAD
 Například pokud podle logiky našeho kódování musí objekt `uživatel` existovat, ale `adresa` je volitelná, pak bychom měli psát `uživatel.adresa?.ulice`, ale ne `uživatel?.adresa?.ulice`.
 
 Pak pokud se v důsledku chyby stane, že `uživatel` bude nedefinovaný, uvidíme programátorskou chybu a opravíme ji. Jinak by se chyby v kódu mohly neohlásit i tehdy, když to není vhodné, a jejich ladění by bylo obtížnější.
+=======
+For example, if according to our code logic `user` object must exist, but `address` is optional, then we should write `user.address?.street`, but not `user?.address?.street`.
+
+Then, if `user` happens to be undefined, we'll see a programming error about it and fix it. Otherwise, if we overuse `?.`, coding errors can be silenced where not appropriate, and become more difficult to debug.
+>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
 ```
 
 ````warn header="Proměnná před `?.` musí být deklarovaná"
@@ -127,15 +133,23 @@ Proměnná musí být deklarovaná (tj. `let/const/var uživatel` nebo jako para
 
 Jak bylo řečeno, `?.` okamžitě pozastaví („vyzkratuje“) vyhodnocování, jestliže levá část neexistuje.
 
+<<<<<<< HEAD
 Jestliže tedy následují další volání funkcí nebo vedlejší efekty, neprovedou se.
+=======
+So, if there are any further function calls or operations to the right of `?.`, they won't be made.
+>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
 
 Například:
 
 ```js run
 let uživatel = null;
 let x = 0;
 
+<<<<<<< HEAD
 uživatel?.řekniAhoj(x++); // „řekniAhoj“ se neprovede, takže výkon se nedostane ke x++
+=======
+user?.sayHi(x++); // no "user", so the execution doesn't reach sayHi call and x++
+>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
 
 alert(x); // 0, hodnota se nezvýšila
 ```
@@ -179,7 +193,11 @@ let uživatel1 = {
   křestníJméno: "Jan"
 };
 
+<<<<<<< HEAD
 let uživatel2 = null; 
+=======
+let user2 = null;
+>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
 
 alert( uživatel1?.[klíč] ); // Jan
 alert( uživatel2?.[klíč] ); // undefined

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

@@ -47,7 +47,11 @@ Nyní zapišme něco velmi malého. Třeba 1 mikrosekundu (jednu milióntinu sek
 let mcs = 0.000001;
 ```
 
+<<<<<<< HEAD
 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:
+=======
+Just like before, using `"e"` can help. If we'd like to avoid writing the zeroes explicitly, we could write the same as:
+>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
 
 ```js
 let mcs = 1e-6; // šest nul nalevo od 1
@@ -156,7 +160,11 @@ Existují dva způsoby, jak to udělat:
 
 1. Násobit a dělit.
 
+<<<<<<< HEAD
     Abychom například zaokrouhlili číslo na 2. číslici za desetinnou čárkou, můžeme toto číslo vynásobit `100` (nebo vyšší mocninou 10), zavolat zaokrouhlovací funkci a pak je znovu vydělit.
+=======
+    For example, to round the number to the 2nd digit after the decimal, we can multiply the number by `100`, call the rounding function and then divide it back.
+>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
     ```js run
     let číslo = 1.23456;
 
@@ -184,21 +192,33 @@ Existují dva způsoby, jak to udělat:
     alert( číslo.toFixed(5) ); // "12.34000", přidají se nuly, aby číslic bylo přesně 5
     ```
 
+<<<<<<< HEAD
     Můžeme jej převést na číslo pomocí unárního plus nebo volání `Number()`: `+číslo.toFixed(5)`.
+=======
+    We can convert it to a number using the unary plus or a `Number()` call, e.g write `+num.toFixed(5)`.
+>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
 
 ## Nepřesné výpočty
 
 Číslo je vnitřně reprezentováno v 64-bitovém formátu [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754-2008_revision), takže se ukládá přesně do 64 bitů: 52 z nich se používá k uložení číslic, v 11 z nich je uložena pozice desetinné čárky (u celých čísel jsou tyto bity nulové) a 1 bit je pro znaménko.
 
+<<<<<<< HEAD
 Je-li číslo příliš velké, překročí toto 64-bitové úložiště a stane se z něj nekonečno:
+=======
+If a number is really huge, it may overflow the 64-bit storage and become a special numeric value `Infinity`:
+>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
 
 ```js run
 alert( 1e500 ); // Infinity (nekonečno)
 ```
 
 Co může být trochu méně zřejmé, ale stává se poměrně často, je ztráta přesnosti.
 
+<<<<<<< HEAD
 Uvažujme tento (nepravdivý!) test:
+=======
+Consider this (falsy!) equality test:
+>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
 
 ```js run
 alert( 0.1 + 0.2 == 0.3 ); // *!*false*/!*
@@ -212,13 +232,21 @@ Zvláštní! Co tedy je, když ne `0.3`?
 alert( 0.1 + 0.2 ); // 0.30000000000000004
 ```
 
+<<<<<<< HEAD
 Ouvej! Tohle má větší důsledky než jen zdejší nekorektní porovnání. Představme si, že vytváříme elektronický obchod a návštěvník si do košíku uloží zboží za `$0.10` a za `$0.20`. Celková cena pak bude `$0.30000000000000004`. To každého překvapí.
+=======
+Ouch! Imagine you're making an e-shopping site and the visitor puts `$0.10` and `$0.20` goods into their cart. The order total will be `$0.30000000000000004`. That would surprise anyone.
+>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
 
 Ale proč se to děje?
 
 Číslo je v paměti uloženo ve své binární podobě, jako posloupnost bitů -- jedniček a nul. Ale desetinná čísla jako `0.1` nebo `0.2`, která v desítkové soustavě vypadají jednoduše, jsou ve své binární podobě ve skutečnosti nekonečná.
 
+<<<<<<< HEAD
 Jinými slovy, co je `0.1`? Je to jedna děleno deseti `1/10`, jedna desetina. V desítkové soustavě lze taková čísla snadno reprezentovat. Srovnejme si to s jednou třetinou: `1/3`. Z ní se stane nekonečné desetinné číslo `0.33333(3)`.
+=======
+What is `0.1`? It is one divided by ten `1/10`, one-tenth. In decimal numeral system such numbers are easily representable. Compare it to one-third: `1/3`. It becomes an endless fraction `0.33333(3)`.
+>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
 
 Je tedy zaručeno, že dělení mocninami `10` bude v desítkové soustavě fungovat dobře, ale dělení třemi ne. Ze stejného důvodu je v binární soustavě zaručeno, že bude fungovat dělení mocninami `2`, ale z `1/10` se stane nekonečné binární číslo.
 

1-js/09-classes/03-static-properties-methods/article.md

@@ -1,9 +1,15 @@
 
 # Statické vlastnosti a metody
 
+<<<<<<< HEAD
 Metodu můžeme přiřadit samotné funkci třídy namísto jejímu `„prototype"`. Takové metody se nazývají *statické*.
 
 Ve třídě jsou předznamenány klíčovým slovem `static`, například:
+=======
+We can also assign a method to the class as a whole. Such methods are called *static*.
+
+In a class declaration, they are prepended by `static` keyword, like this:
+>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
 
 ```js run
 class Uživatel {
@@ -31,9 +37,17 @@ Uživatel.statickáMetoda(); // true
 
 Hodnota `this` ve volání `Uživatel.statickáMetoda()` je samotný třídní konstruktor `Uživatel` (podle pravidla „objekt před tečkou“).
 
+<<<<<<< HEAD
 Statické metody se obvykle používají k implementaci funkcí, které patří třídě, ale žádnému jejímu konkrétnímu objektu.
 
 Například máme objekty třídy `Článek` a potřebujeme funkci, která je bude porovnávat. Přirozené řešení by bylo přidat metodu `Článek.porovnej`, například:
+=======
+Usually, static methods are used to implement functions that belong to the class as a whole, but not to any particular object of it.
+
+For instance, we have `Article` objects and need a function to compare them.
+
+A natural solution would be to add `Article.compare` static method:
+>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
 
 ```js run
 class Článek {
@@ -63,17 +77,29 @@ let články = [
 alert( články[0].titulek ); // CSS
 ```
 
+<<<<<<< HEAD
 Zde metoda `Článek.porovnej` stojí „nad“ články jako způsob jejich porovnávání. Není to metoda článku, ale metoda celé třídy.
 
 Jiným příkladem může být tzv. „tovární“ metoda. Představme si, že potřebujeme několik způsobů, jak vytvořit článek:
+=======
+Here `Article.compare` method stands "above" articles, as a means to compare them. It's not a method of an article, but rather of the whole class.
+
+Another example would be a so-called "factory" method.
+
+Let's say, we need multiple ways to create an article:
+>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
 
 1. Vytvořit jej ze zadaných parametrů (`titulek`, `datum` atd.).
 2. Vytvořit prázdný článek s dnešním datem.
 3. ...nebo nějak jinak.
 
 První způsob můžeme implementovat konstruktorem. A pro druhý můžeme vytvořit statickou metodu třídy.
 
+<<<<<<< HEAD
 Například `Článek.vytvořDnešní()` zde:
+=======
+Such as `Article.createTodays()` here:
+>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
 
 ```js run
 class Článek {
@@ -100,9 +126,15 @@ Nyní pokaždé, když budeme potřebovat vytvořit dnešní přehled, můžeme
 Statické metody se také používají ve třídách vztažených k databázím pro hledání/ukládání/odstraňování záznamů z databáze, například:
 
 ```js
+<<<<<<< HEAD
 // předpokládejme, že Článek je speciální třída pro práci s články
 // statická metoda pro odstranění článku:
 Článek.odstraň({id: 12345});
+=======
+// assuming Article is a special class for managing articles
+// static method to remove the article by id:
+Article.remove({id: 12345});
+>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
 ```
 
 ## Statické vlastnosti