Merge pull request #60 from otmon76/master

changes from English version

Author: otmon76

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

@@ -1,4 +1,4 @@
-
+ 
 # Volitelné zřetězení „?.“
 
 [recent browser="new"]
@@ -108,22 +108,16 @@ 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
+Pak pokud se stane, že `uživatel` bude nedefinovaný, ohlásí se programátorská chyba a my ji opravíme. Kdybychom však přehnaně používali `?.`, mohly by se chyby v kódu neohlásit i tehdy, když to není vhodné, a jejich ladění by bylo obtížnější.
 ```
 
 ````warn header="Proměnná před `?.` musí být deklarovaná"
 Pokud proměnná `uživatel` vůbec neexistuje, pak `uživatel?.cokoli` ohlásí chybu:
 
 ```js run
-// ReferenceError: uživatel is not defined
+// ReferenceError: uživatel není definován
 uživatel?.adresa;
 ```
 Proměnná musí být deklarovaná (tj. `let/const/var uživatel` nebo jako parametr funkce). Volitelné zřetězení funguje jen pro deklarované proměnné.
@@ -133,23 +127,15 @@ 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
+Jestliže tedy za pozastaveným `?.` vpravo následují další volání funkcí nebo operace, nevykonají se.
 
 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
+uživatel?.řekniAhoj(x++); // „uživatel“ není, takže výkon se nedostane k volání řekniAhoj a x++
 
 alert(x); // 0, hodnota se nezvýšila
 ```
@@ -193,11 +179,7 @@ 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,11 +47,7 @@ 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
@@ -160,11 +156,8 @@ 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
+    Abychom například zaokrouhlili číslo na 2. číslici za desetinnou čárkou, můžeme toto číslo vynásobit `100`, zavolat zaokrouhlovací funkci a pak je znovu vydělit.
+
     ```js run
     let číslo = 1.23456;
 
@@ -192,33 +185,21 @@ 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
+    Můžeme jej převést na číslo pomocí unárního plus nebo volání `Number()`, např. napsat `+číslo.toFixed(5)`.
 
 ## 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
+Je-li číslo opravdu obrovské, může toto 64-bitové úložiště překročit a stát se speciální číselnou hodnotou `Infinity` (nekonečno):
 
 ```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
+Uvažujme tento (nepravdivý!) test rovnosti:
 
 ```js run
 alert( 0.1 + 0.2 == 0.3 ); // *!*false*/!*
@@ -232,21 +213,13 @@ 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
+Ouvej! 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í.
 
 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
+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)`.
 
 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,15 +1,9 @@
 
 # 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é*.
+Metodu můžeme také přiřadit samotné třídě jako celku. 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
+V deklaraci třídy jsou předznamenány klíčovým slovem `static`, například:
 
 ```js run
 class Uživatel {
@@ -37,17 +31,11 @@ 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.
+Statické metody se obvykle používají k implementaci funkcí, které patří třídě jako celku, ale nepatří žádnému jejímu konkrétnímu objektu.
 
-For instance, we have `Article` objects and need a function to compare them.
+Například máme objekty třídy `Článek` a potřebujeme funkci, která je bude porovnávat.
 
-A natural solution would be to add `Article.compare` static method:
->>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
+Přirozené řešení by bylo přidat statickou metodu `Článek.porovnej`:
 
 ```js run
 class Článek {
@@ -77,29 +65,19 @@ 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.
+Jiným příkladem může být tzv. „tovární“ metoda.
 
-Let's say, we need multiple ways to create an article:
->>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
+Dejme tomu, že potřebujeme více způsobů, jak vytvořit článek:
 
 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 {
@@ -126,15 +104,9 @@ 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:
+// statická metoda pro odstranění článku podle jeho id:
 Č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