otmon76 · otmon76 · Jan 16, 2025 · Sep 29, 2022 · Sep 29, 2022 · Sep 29, 2022
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
@@ -0,0 +1 @@
+github: iliakan
diff --git a/1-js/01-getting-started/1-intro/article.md b/1-js/01-getting-started/1-intro/article.md
@@ -35,7 +35,7 @@ Výše uvedené pojmy je dobré si pamatovat, protože se používají ve vývoj
 Enginy jsou složité, ale jejich základy jsou jednoduché.
 
 1. Engine (v případě prohlížeče zahrnutý do něj) načte („rozebere“, „parsuje“) skript.
-2. Pak přeloží („zkompiluje“) skript do strojového jazyka.
+2. Pak přeloží („zkompiluje“) skript do strojového kódu.
 3. A pak se strojový kód hezky rychle spustí.
 
 Při každém kroku procesu engine aplikuje optimalizace. Dokonce sleduje, jak zkompilovaný skript běží, analyzuje data, která jím protékají, a podle těchto znalostí dále optimalizuje strojový kód.
@@ -59,7 +59,7 @@ Například JavaScript v prohlížeči může:
 
 ## Co NEMŮŽE JavaScript v prohlížeči dělat?
 
-Schopnosti JavaScriptu v prohlížeči jsou omezeny v zájmu bezpečnosti uživatele. Cílem je zabránit zlé webové stránce v přístupu k soukromým informacím nebo v poškození uživatelových dat.
+Schopnosti JavaScriptu v prohlížeči jsou omezeny, aby byla chráněna bezpečnost uživatele. Cílem je zabránit zlé webové stránce v přístupu k soukromým informacím nebo v poškození uživatelových dat.
 
 Příklady takových omezení:
 
@@ -70,9 +70,9 @@ Příklady takových omezení:
 	Existují způsoby, jak komunikovat s kamerou, mikrofonem nebo jinými zařízeními, ale ty vyžadují výslovné svolení uživatele. Stránka s povoleným JavaScriptem tedy nemůže bez vědomí uživatele zapnout webovou kameru, nasnímat okolí a nahrávku poslat do [NSA](https://cs.wikipedia.org/wiki/Národní_bezpečnostní_agentura).
 - Různé záložky a okna o sobě navzájem obvykle nevědí. Někdy ano, například tehdy, když jedno okno používá JavaScript k otevření druhého. Ale ani v tomto případě JavaScript z jedné stránky nemůže přistupovat k jiné, pokud pocházejí z různých webových sídel (z jiné domény, protokolu nebo portu).
 
-	Tento postup se nazývá „politika stejného původu“. Je možné ji obejít tak, že *obě stránky* souhlasí s výměnou dat a obsahují speciální JavaScriptový kód, který to umožňuje. V tomto tutoriálu to budeme probírat.
+	Tento postup se nazývá „politika stejného původu“. Je možné ji obejít tak, že *obě stránky* musí souhlasit s výměnou dat a musí obsahovat speciální JavaScriptový kód, který to umožňuje. V tomto tutoriálu to budeme probírat.
 
-	Toto omezení je zde opět pro bezpečnost uživatele. Stránka z `http://anysite.com`, kterou uživatel otevřel, nesmí mít možnost přistupovat k jiné záložce prohlížeče s URL `http://gmail.com` a krást odtamtud informace.
+	Toto omezení je zde opět pro bezpečnost uživatele. Stránka z `http://anysite.com`, kterou uživatel otevřel, nesmí mít možnost přistupovat k jiné záložce prohlížeče s URL například `http://gmail.com` a krást odtamtud informace.
 - JavaScript může jednoduše komunikovat po síti se serverem, z něhož přišla aktuální stránka, ale jeho schopnost získávat data z jiných sídel/domén je značně omezená. Přestože je to možné, vyžaduje to výslovný souhlas (uvedený v HTTP hlavičce) vzdálené strany. I to je bezpečnostní omezení.
 
 ![](limitations.svg)
@@ -92,7 +92,7 @@ JavaScript je jediná prohlížečová technologie, která má všechny tyto tř
 
 To vše činí JavaScript unikátním. To vše je důvodem, proč je dnes nejrozšířenějším nástrojem pro vytváření prohlížečových rozhraní.
 
-Při tom všem však JavaScript umožňuje vytvářet i servery, mobilní aplikace a podobně.
+Při tom všem však lze JavaScript použít i k vytváření serverů, mobilních aplikací a podobně.
 
 ## Jazyky „nad“ JavaScriptem
 
@@ -113,7 +113,7 @@ Příklady takových jazyků:
 - [Brython](https://brython.info/) je transpiler Pythonu do JavaScriptu, který umožňuje psát aplikace v čistém Pythonu bez JavaScriptu.
 - [Kotlin](https://kotlinlang.org/docs/reference/js-overview.html) je moderní, stručný a bezpečný programovací jazyk, jehož cílem může být prohlížeč nebo Node.
 
-Jsou i další. Samozřejmě i když používáme některý z transpilovaných jazyků, měli bychom znát i JavaScript, abychom skutečně porozuměli tomu, co se děje.
+Jsou i další. Samozřejmě i když používáme některý z těchto transpilovaných jazyků, měli bychom znát i JavaScript, abychom skutečně porozuměli tomu, co se děje.
 
 ## Shrnutí
 

diff --git a/1-js/01-getting-started/3-code-editors/article.md b/1-js/01-getting-started/3-code-editors/article.md
@@ -29,7 +29,7 @@ Hlavní rozdíl mezi „textovým editorem“ a „IDE“ je, že „IDE“ prac
 
 V praxi mají textové editory obvykle velké množství zásuvných modulů a rozšíření včetně syntaktických analyzátorů a automatického doplňování na adresářové úrovni, takže mezi textovými editory a vývojovými prostředími neexistuje pevně daná hranice.
 
-Vaši pozornost si zasluhují následující možnosti:
+Možností je mnoho, například:
 
 - [Sublime Text](http://www.sublimetext.com) (různé platformy, shareware).
 - [Notepad++](https://notepad-plus-plus.org/) (Windows, zdarma).
@@ -41,4 +41,9 @@ Ve výše uvedených seznamech jsou zmíněny editory, které já nebo moji př
 
 Svět je velký a existují v něm i jiné skvělé editory. Vyberte si prosím ten, který se vám nejvíce líbí.
 
-Výběr editoru, stejně jako výběr každého nástroje, je individuální záležitost a závisí na projektech, zvyklostech a osobním vkusu každého vývojáře.
+Výběr editoru, stejně jako výběr kteréhokoli jiného nástroje, je individuální záležitost a závisí na vašich projektech, zvyklostech a osobním vkusu.
+
+Autorovo osobní mínění:
+
+- Když vyvíjím převážně frontend, používám [Visual Studio Code](https://code.visualstudio.com/).
+- Jinak, pokud je to většinou jiný jazyk/platforma a částečně frontend, zvažte jiné editory, například XCode (Mac), Visual Studio (Windows) nebo rodinu Jetbrains (Webstorm, PHPStorm, RubyMine atd. v závislosti na jazyce).
diff --git a/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md b/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md
@@ -12,13 +12,14 @@ const datumNarození = '18.04.1982';
 const věk = nějakýKód(datumNarození);
 ```
 
-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ží).
+Zde máme konstantu `datumNarození` a také konstantu `věk`.
+
+Konstanta `věk` se vypočítá z konstanty `datumNarození` pomocí `nějakýKód()`, což znamená volání funkce, které jsme zatím nevysvětlili (ale brzy tak učiníme!), ale na podrobnostech zde nezáleží, podstatné je, že `věk` se vypočítá nějak podle `datumNarození`.
 
 Bylo by správné použít pro název proměnné `datumNarození` velká písmena? A pro `věk`? Nebo dokonce pro obě?
 
 ```js
-const DATUM_NAROZENÍ = '18.04.1982'; // velkými písmeny?
+const DATUM_NAROZENÍ = '18.04.1982'; // napsat DATUM_NAROZENÍ velkými písmeny?
 
-const VĚK = nějakýKód(DATUM_NAROZENÍ); // velkými písmeny?
+const VĚK = nějakýKód(DATUM_NAROZENÍ); // napsat VĚK velkými písmeny?
 ```
-
diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md
@@ -151,11 +151,11 @@ Proměnnou bychom tedy měli deklarovat jen jednou a pak se na ni odkazovat bez
 ````
 
 ```smart header="Funkcionální jazyky"
-Stojí za zmínku, že existují [funkcionální](https://cs.wikipedia.org/wiki/Funkcionální_programování) programovací jazyky, například [Scala](http://www.scala-lang.org/) nebo [Erlang](http://www.erlang.org/), které nedovolují měnit hodnotu proměnných.
+Stojí za zmínku, že existují tzv. [čistě funkcionální](https://en.wikipedia.org/wiki/Purely_functional_programming) programovací jazyky, například [Haskell](https://cs.wikipedia.org/wiki/Haskell_(programovací_jazyk)), které nedovolují měnit hodnotu proměnných.
 
 Když je v takových jazycích hodnota jednou uložena „do krabičky“, zůstane tam navždy. Pokud chceme uložit něco jiného, jazyk nás přinutí vytvořit novou krabičku (deklarovat novou proměnnou). Nemůžeme znovu použít starou.
 
-Ačkoli to na první pohled může vypadat trochu zvláštně, i v takových jazycích je seriózní programování docela dobře možné. Kromě toho existují oblasti, např. paralelní výpočty, v nichž právě toto omezení přináší určité výhody. Prostudovat si takový jazyk (i když jej neplánujete v dohledné době používat) se doporučuje k rozšíření obzorů.
+Ačkoli to na první pohled může vypadat trochu zvláštně, i v takových jazycích je seriózní programování docela dobře možné. Kromě toho existují oblasti, např. paralelní výpočty, v nichž právě toto omezení přináší určité výhody.
 ```
 
 ## Názvy proměnných [#variable-naming]
@@ -198,7 +198,7 @@ Proměnné s názvy `jablko` a `JABLKO` jsou dvě různé proměnné.
 ```
 
 ````smart header="Nelatinská písmena jsou povolena, ale nedoporučují se"
-Je dovoleno použít písmena z jakéhokoli jazyka, včetně písmen z kyrilice nebo dokonce čínských znaků, třeba takto:
+Je dovoleno použít písmena z jakéhokoli jazyka, včetně písmen z kyrilice, čínských znaků a podobně, třeba takto:
 
 ```js
 let имя = '...';
@@ -289,7 +289,7 @@ Výhody:
 
 Kdy bychom měli používat pro konstantu velká písmena a kdy bychom ji měli pojmenovat obvyklým způsobem? Ujasníme si to.
 
-Být „konstanta“ znamená prostě to, že hodnota proměnné se nikdy nezmění. Existují však konstanty, které jsou známy již před spuštěním programu (například hexadecimální hodnota červené barvy), a pak jsou konstanty, které se *vypočítají* až za běhu programu, ale jejich vypočtená hodnota se nikdy nezmění.
+Být „konstanta“ znamená prostě to, že hodnota proměnné se nikdy nezmění. Některé konstanty jsou však známy již před spuštěním programu (například hexadecimální hodnota červené barvy) a pak jsou konstanty, které se *vypočítají* až za běhu programu, ale jejich vypočtená hodnota se nikdy nezmění.
 
 Příklad:
 

diff --git a/1-js/02-first-steps/05-types/article.md b/1-js/02-first-steps/05-types/article.md
@@ -95,12 +95,6 @@ const bigInt = 1234567890123456789012345678901234567890n;
 
 Protože čísla typu `BigInt` potřebujeme jen málokdy, nebudeme je tady probírat, ale věnujeme jim zvláštní kapitolu <info:bigint>. Až budete tak velká čísla potřebovat, přečtěte si ji.
 
-```smart header="Otázka kompatibility"
-Právě nyní je `BigInt` podporován ve Firefoxu/Chrome/Edge/Safari, ale ne v IE.
-```
-
-Nahlédnutím do [*MDN* tabulky kompatibility pro 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.
@@ -224,7 +218,7 @@ Typ `symbol` se používá k vytváření unikátních identifikátorů pro obje
 
 ## Operátor typeof [#type-typeof]
 
-Operátor `typeof` vrací typ argumentu. Je užitečný, když chceme hodnoty různých typů zpracovávat různě anebo si jen chceme typ rychle ověřit.
+Operátor `typeof` vrací typ operandu. Je užitečný, když chceme hodnoty různých typů zpracovávat různě anebo si jen chceme typ rychle ověřit.
 
 Volání `typeof x` vrátí řetězec s názvem typu:
 

diff --git a/1-js/02-first-steps/07-type-conversions/article.md b/1-js/02-first-steps/07-type-conversions/article.md
@@ -70,7 +70,7 @@ Pravidla pro konverzi na číslo:
 |`undefined`|`NaN`|
 |`null`|`0`|
 |<code>true</code>&nbsp;a&nbsp;<code>false</code> | `1` a `0` |
-| `řetězec` | Odstraní se bílé znaky (mezery, tabulátory, konce řádku) ze začátku a konce. Je-li výsledný řetězec prázdný, výsledkem je `0`. Jinak se číslo „přečte“ z řetězce. Při chybě je vydáno `NaN`. |
+| `řetězec` | Odstraní se bílé znaky (mezery, tabulátory `\t`, konce řádku `\n` atd.) ze začátku a konce. Je-li výsledný řetězec prázdný, výsledkem je `0`. Jinak se číslo „přečte“ z řetězce. Při chybě je vydáno `NaN`. |
 
 Příklady:
 
@@ -130,7 +130,7 @@ Konverze se řídí těmito pravidly:
 |`undefined`|`NaN`|
 |`null`|`0`|
 |<code>true&nbsp;/&nbsp;false</code> | `1 / 0` |
-| `řetězec` | Načte se „doslovně“, bílé znaky na obou stranách se ignorují. Z prázdného řetězce se stane `0`. Při chybě je vydáno `NaN`. |
+| `řetězec` | Načte se „doslovně“, bílé znaky (mezery, tabulátory `\t`, konce řádku `\n` atd.) na obou stranách se ignorují. Z prázdného řetězce se stane `0`. Při chybě je vydáno `NaN`. |
 
 **`Konverze na boolean`** -- Nastává při logických operacích. Můžeme ji provést pomocí `Boolean(hodnota)`.
 

diff --git a/1-js/02-first-steps/08-operators/3-primitive-conversions-questions/solution.md b/1-js/02-first-steps/08-operators/3-primitive-conversions-questions/solution.md
@@ -16,10 +16,10 @@ undefined + 1 = NaN // (6)
 " \t \n" - 2 = -2 // (7)
 ```
 
-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.
+1. Sčítání s řetězcem `"" + 1` převede `1` na řetězec: `"" + 1 = "1"` a pak budeme mít `"1" + 0`, 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`.
+5. Z `null` se po konverzi na číslo stane `0`.
+6. Z `undefined` se po konverzi na číslo stane `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`.
diff --git a/1-js/02-first-steps/08-operators/article.md b/1-js/02-first-steps/08-operators/article.md
@@ -52,6 +52,7 @@ Příklad:
 ```js run
 alert( 5 % 2 ); // 1, zbytek po dělení 5 děleno 2
 alert( 8 % 3 ); // 2, zbytek po dělení 8 děleno 3
+alert( 8 % 4 ); // 0, zbytek po dělení 8 děleno 4
 ```
 
 ### Umocňování **
@@ -195,18 +196,18 @@ Následuje výtažek z [tabulky priorit](https://developer.mozilla.org/en-US/doc
 | Priorita | Název | Znak |
 |----------|-------|------|
 | ... | ... | ... |
-| 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í | `-` |
+| 14 | unární plus | `+` |
+| 14 | unární negace | `-` |
+| 13 | umocňování | `**` |
+| 12 | násobení | `*` |
+| 12 | dělení | `/` |
+| 11 | sčítání | `+` |
+| 11 | odčítání | `-` |
 | ... | ... | ... |
 | 2 | přiřazení | `=` |
 | ... | ... | ... |
 
-Jak vidíme, „unární plus“ má prioritu `15`, která je vyšší než priorita `12` „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.
+Jak vidíme, „unární plus“ má prioritu `14`, která je vyšší než priorita `11` „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í
 
@@ -304,9 +305,9 @@ Tyto operátory mají stejnou prioritu jako běžné přiřazení, takže se pro
 ```js run
 let n = 2;
 
-n *= 3 + 5;
+n *= 3 + 5; // napřed se provede část vpravo, totéž jako n *= 8
 
-alert( n ); // 16  (napřed se provede část vpravo, totéž jako n *= 8)
+alert( n ); // 16
 ```
 
 ## Inkrementace a dekrementace

diff --git a/1-js/02-first-steps/10-ifelse/article.md b/1-js/02-first-steps/10-ifelse/article.md
@@ -68,7 +68,7 @@ if (podmínka) {
 
 ## Klauzule „else“
 
-Příkaz `if` může obsahovat nepovinný blok „else“, který se vykoná, když podmínka je nepravdivá.
+Příkaz `if` může obsahovat nepovinný blok `else`, který se vykoná, když podmínka je nepravdivá.
 
 Příklad:
 ```js run
@@ -181,9 +181,9 @@ alert( zpráva );
 Na první pohled může být obtížné pochopit, o co tady jde. Po bližším prozkoumání však vidíme, že to je jen obyčejná posloupnost testů:
 
 1. První otazník ověří, zda `věk < 3`.
-2. Pokud ano, vrátí `'Nazdar, mimino!'`. Jinak pokračuje výrazem za dvojtečkou `:` a ověří `věk < 18`.
-3. Pokud to platí, vrátí `'Ahoj!'`. Jinak pokračuje výrazem za další dvojtečkou `:` a ověří `věk < 100`.
-4. Pokud to platí, vrátí `'Dobrý den!'`. Jinak pokračuje výrazem za poslední dvojtečkou `:` a vrátí `'To je ale vysoký věk!'`.
+2. Pokud ano, vrátí `'Nazdar, mimino!'`. Jinak pokračuje výrazem za dvojtečkou ":" a ověří `věk < 18`.
+3. Pokud to platí, vrátí `'Ahoj!'`. Jinak pokračuje výrazem za další dvojtečkou ":" a ověří `věk < 100`.
+4. Pokud to platí, vrátí `'Dobrý den!'`. Jinak pokračuje výrazem za poslední dvojtečkou ":" a vrátí `'To je ale vysoký věk!'`.
 
 Při použití `if..else` by to vypadalo následovně:
 

diff --git a/1-js/02-first-steps/12-nullish-coalescing-operator/article.md b/1-js/02-first-steps/12-nullish-coalescing-operator/article.md
@@ -29,15 +29,15 @@ Například zde zobrazíme `anonym`, jestliže proměnná `uživatel` není defi
 ```js run
 let uživatel;
 
-alert(uživatel ?? "anonym"); // anonym (uživatel není definován)
+alert(uživatel ?? "Anonym"); // Anonym (uživatel má hodnotu undefined)
 ```
 
 Zde je příklad, kde má proměnná `uživatel` přiřazenou hodnotu:
 
 ```js run
 let uživatel = "Jan";
 
-alert(uživatel ?? "anonym"); // Jan (uživatel je definován)
+alert(uživatel ?? "Anonym"); // Jan (uživatel nemá hodnotu null/undefined)
 ```
 
 Můžeme také použít sekvenci `??` k výběru první hodnoty ze seznamu, která není `null/undefined`.
@@ -105,7 +105,7 @@ V praxi je nulová výška často platnou hodnotou, takže by neměla být nahra
 
 ## Priorita
 
-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`.
+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 `3`.
 
 To znamená, že operátor koalescence `??` se stejně jako `||` vyhodnocuje před `=` a `?`, ale až po většině ostatních operací, například  `+`, `*`.
 

diff --git a/1-js/02-first-steps/15-function-basics/article.md b/1-js/02-first-steps/15-function-basics/article.md
@@ -24,7 +24,7 @@ Napřed je uvedeno klíčové slovo `function`, pak *název funkce*, potom máme
 
 ```js
 function název(parametr1, parametr2, ... parametrN) {
-  ...tělo...
+  // tělo
 }
 ```
 
@@ -209,6 +209,12 @@ zobrazZprávu("Anna"); // Anna: text není zadán
 
 Jestliže argument k parametru `text` nebude předán, bude mít hodnotu `"text není zadán"`.
 
+Výchozí hodnota bude nastavena i tehdy, když parametr existuje, ale je striktně roven `undefined`, například:
+
+```js
+showMessage("Anna", undefined); // Anna: text není zadán
+```
+
 Zde `"text není zadán"` je řetězec, ale může to být složitější výraz, který se vyhodnotí a přiřadí jen tehdy, jestliže argument chybí. Je tedy možné i toto:
 
 ```js run
@@ -258,7 +264,7 @@ function zobrazZprávu(odKoho, text) {
 ````
 
 ### Alternativní výchozí argumenty
-Někdy má smysl nenastavovat výchozí hodnoty argumentů v deklaraci funkce, ale až později.
+Někdy má smysl nastavovat výchozí hodnoty argumentů až později po deklaraci funkce.
 
 Abychom během provádění funkce ověřili, zda argument byl předán, můžeme jej porovnat s `undefined`:
 
@@ -453,7 +459,7 @@ Tyto příklady předpokládají běžný význam prefixů. Se svým týmem se m
 ```smart header="Ultrakrátké názvy funkcí"
 Funkce, které se používají *velmi často*, mají někdy ultrakrátké názvy.
 
-Například knihovna [jQuery](http://jquery.com) definuje funkci s názvem `$`. Knihovna [Lodash](http://lodash.com/) má svou ústřední funkci pojmenovanou `_`.
+Například knihovna [jQuery](https://jquery.com) definuje funkci s názvem `$`. Knihovna [Lodash](https://lodash.com/) má svou ústřední funkci pojmenovanou `_`.
 
 To jsou však výjimky. Obecně by názvy funkcí měly být stručné a popisné.
 ```