From 22e67d2492b161e09f8ed1dc87e039630fb97bde Mon Sep 17 00:00:00 2001
From: Otmar Onderek <onderek@volny.cz>
Date: Mon, 18 Apr 2022 22:37:32 +0200
Subject: [PATCH 01/22] 1.2.13

---
 .../1-loop-last-value/solution.md             |  14 +-
 .../13-while-for/1-loop-last-value/task.md    |   4 +-
 .../2-which-value-while/solution.md           |  23 +-
 .../13-while-for/2-which-value-while/task.md  |  10 +-
 .../3-which-value-for/solution.md             |  14 +-
 .../13-while-for/3-which-value-for/task.md    |  10 +-
 .../13-while-for/4-for-even/solution.md       |   2 +-
 .../13-while-for/4-for-even/task.md           |   4 +-
 .../5-replace-for-while/solution.md           |   2 +-
 .../13-while-for/5-replace-for-while/task.md  |   6 +-
 .../6-repeat-until-correct/solution.md        |  14 +-
 .../6-repeat-until-correct/task.md            |   8 +-
 .../13-while-for/7-list-primes/solution.md    |  26 +-
 .../13-while-for/7-list-primes/task.md        |  14 +-
 1-js/02-first-steps/13-while-for/article.md   | 270 +++++++++---------
 15 files changed, 210 insertions(+), 211 deletions(-)

diff --git a/1-js/02-first-steps/13-while-for/1-loop-last-value/solution.md b/1-js/02-first-steps/13-while-for/1-loop-last-value/solution.md
index 43ee4aad3..92e28c94e 100644
--- a/1-js/02-first-steps/13-while-for/1-loop-last-value/solution.md
+++ b/1-js/02-first-steps/13-while-for/1-loop-last-value/solution.md
@@ -1,4 +1,4 @@
-The answer: `1`.
+Odpověď: `1`.
 
 ```js run
 let i = 3;
@@ -8,18 +8,18 @@ while (i) {
 }
 ```
 
-Every loop iteration decreases `i` by `1`. The check `while(i)` stops the loop when `i = 0`.
+Každá iterace cyklu sníží `i` o `1`. Ověření `while(i)` zastaví cyklus, když `i = 0`.
 
-Hence, the steps of the loop form the following sequence ("loop unrolled"):
+Jednotlivé kroky cyklu tedy vytvoří následující posloupnost:
 
 ```js
 let i = 3;
 
-alert(i--); // shows 3, decreases i to 2
+alert(i--); // zobrazí 3, sníží i na 2
 
-alert(i--) // shows 2, decreases i to 1
+alert(i--) // zobrazí 2, sníží i na 1
 
-alert(i--) // shows 1, decreases i to 0
+alert(i--) // zobrazí 1, sníží i na 0
 
-// done, while(i) check stops the loop
+// hotovo, ověření while(i) ukončí cyklus
 ```
diff --git a/1-js/02-first-steps/13-while-for/1-loop-last-value/task.md b/1-js/02-first-steps/13-while-for/1-loop-last-value/task.md
index 3b847dfa2..d9b36c548 100644
--- a/1-js/02-first-steps/13-while-for/1-loop-last-value/task.md
+++ b/1-js/02-first-steps/13-while-for/1-loop-last-value/task.md
@@ -2,9 +2,9 @@ importance: 3
 
 ---
 
-# Last loop value
+# Poslední hodnota v cyklu
 
-What is the last value alerted by this code? Why?
+Jaká je poslední hodnota, kterou vypíše tento kód? Proč?
 
 ```js
 let i = 3;
diff --git a/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md b/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
index 495359876..772267de7 100644
--- a/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
+++ b/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
@@ -1,30 +1,31 @@
-The task demonstrates how postfix/prefix forms can lead to different results when used in comparisons.
+Tato úloha ukazuje, jak mohou prefixová a postfixová forma vést k rozdílným výsledkům, když je použijeme v porovnání.
 
-1. **From 1 to 4**
+1. **Od 1 do 4**
 
     ```js run
     let i = 0;
     while (++i < 5) alert( i );
     ```
 
-    The first value is `i = 1`, because `++i` first increments `i` and then returns the new value. So the first comparison is `1 < 5` and the `alert` shows `1`.
+    První hodnota je `i = 1`, jelikož `++i` nejprve zvýší `i` a pak vrátí novou hodnotu. První porovnání je tedy `1 < 5` a `alert` zobrazí `1`.
 
-    Then follow `2, 3, 4…` -- the values show up one after another. The comparison always uses the incremented value, because `++` is before the variable.
+    Následují `2, 3, 4…` -- hodnoty se zobrazí jedna po druhé. Porovnání se vždy dívá na zvýšenou hodnotu, protože `++` je před proměnnou.
 
-    Finally, `i = 4` is incremented to `5`, the comparison `while(5 < 5)` fails, and the loop stops. So `5` is not shown.
-2. **From 1 to 5**
+    Nakonec `i = 4` se zvýší na `5`, porovnání `while(5 < 5)` neuspěje a cyklus skončí. Takže `5` se nezobrazí.
+    
+2. **Od 1 do 5**
 
     ```js run
     let i = 0;
     while (i++ < 5) alert( i );
     ```
 
-    The first value is again `i = 1`. The postfix form of `i++` increments `i` and then returns the *old* value, so the comparison `i++ < 5` will use `i = 0` (contrary to `++i < 5`).
+    První hodnota je opět `i = 1`. Postfixová forma `i++` zvýší `i` a pak vrátí *starou* hodnotu, takže porovnání `i++ < 5` se dívá na `i = 0` (na rozdíl od `++i < 5`).
 
-    But the `alert` call is separate. It's another statement which executes after the increment and the comparison. So it gets the current `i = 1`.
+    Avšak `alert` se volá odděleně. Je to další příkaz, který se spustí až po zvýšení a porovnání. Proto obdrží aktuální `i = 1`.
 
-    Then follow `2, 3, 4…`
+    Následují `2, 3, 4…`
 
-    Let's stop on `i = 4`. The prefix form `++i` would increment it and use `5` in the comparison. But here we have the postfix form `i++`. So it increments `i` to `5`, but returns the old value. Hence the comparison is actually `while(4 < 5)` -- true, and the control goes on to `alert`.
+    Zastavme se u `i = 4`. Prefixová forma `++i` by je zvýšila a v porovnání by použila `5`. Tady však máme postfixovou formu `i++`. Ta zvýší `i` na `5`, ale vrátí starou hodnotu. Proto se provede porovnání `while(4 < 5)` -- pravda, tudíž řízení přejde k `alert`.
 
-    The value `i = 5` is the last one, because on the next step `while(5 < 5)` is false.
+    Hodnota `i = 5` je poslední, jelikož další krok `while(5 < 5)` dává nepravdu.
diff --git a/1-js/02-first-steps/13-while-for/2-which-value-while/task.md b/1-js/02-first-steps/13-while-for/2-which-value-while/task.md
index 298213237..f26ed31a8 100644
--- a/1-js/02-first-steps/13-while-for/2-which-value-while/task.md
+++ b/1-js/02-first-steps/13-while-for/2-which-value-while/task.md
@@ -2,19 +2,19 @@ importance: 4
 
 ---
 
-# Which values does the while loop show?
+# Které hodnoty zobrazí cyklus while?
 
-For every loop iteration, write down which value it outputs and then compare it with the solution.
+Pro oba cykly si zapište hodnoty, které budou vypsány, a pak je porovnejte s řešením.
 
-Both loops `alert` the same values, or not?
+Vypíše `alert` v obou cyklech stejné hodnoty, nebo ne?
 
-1. The prefix form `++i`:
+1. Prefixová forma `++i`:
 
     ```js
     let i = 0;
     while (++i < 5) alert( i );
     ```
-2. The postfix form `i++`
+2. Postfixová forma `i++`
 
     ```js
     let i = 0;
diff --git a/1-js/02-first-steps/13-while-for/3-which-value-for/solution.md b/1-js/02-first-steps/13-while-for/3-which-value-for/solution.md
index e2e28e75b..c09390f38 100644
--- a/1-js/02-first-steps/13-while-for/3-which-value-for/solution.md
+++ b/1-js/02-first-steps/13-while-for/3-which-value-for/solution.md
@@ -1,4 +1,4 @@
-**The answer: from `0` to `4` in both cases.**
+**Odpověď: od `0` do `4` v obou případech.**
 
 ```js run
 for (let i = 0; i < 5; ++i) alert( i );
@@ -6,12 +6,12 @@ for (let i = 0; i < 5; ++i) alert( i );
 for (let i = 0; i < 5; i++) alert( i );
 ```
 
-That can be easily deducted from the algorithm of `for`:
+Lze to snadno odvodit z algoritmu pro `for`:
 
-1. Execute once `i = 0` before everything (begin).
-2. Check the condition `i < 5`
-3. If `true` -- execute the loop body `alert(i)`, and then `i++`
+1. Nejdříve se jedenkrát vykoná `i = 0` (začátek).
+2. Ověří se podmínka `i < 5`.
+3. Je-li `true`, vykoná se tělo cyklu `alert(i)` a pak `i++`.
 
-The increment `i++` is separated from the condition check (2). That's just another statement.
+Zvýšení `i++` je odděleno od testu podmínky (2). Je to jen další příkaz.
 
-The value returned by the increment is not used here, so there's no difference between `i++` and `++i`.
+Hodnota vrácená zvýšením se tady nepoužívá, takže mezi `i++` a `++i` zde není žádný rozdíl.
diff --git a/1-js/02-first-steps/13-while-for/3-which-value-for/task.md b/1-js/02-first-steps/13-while-for/3-which-value-for/task.md
index bfefa63f5..137c8f2c2 100644
--- a/1-js/02-first-steps/13-while-for/3-which-value-for/task.md
+++ b/1-js/02-first-steps/13-while-for/3-which-value-for/task.md
@@ -2,18 +2,18 @@ importance: 4
 
 ---
 
-# Which values get shown by the "for" loop?
+# Které hodnoty zobrazí cyklus „for“?
 
-For each loop write down which values it is going to show. Then compare with the answer.
+Pro oba cykly zapište hodnoty, které budou zobrazeny, a pak je porovnejte s řešením.
 
-Both loops `alert` same values or not?
+Vypíše `alert` v obou cyklech stejné hodnoty, nebo ne?
 
-1. The postfix form:
+1. Postfixová forma:
 
     ```js
     for (let i = 0; i < 5; i++) alert( i );
     ```
-2. The prefix form:
+2. Prefixová forma:
 
     ```js
     for (let i = 0; i < 5; ++i) alert( i );
diff --git a/1-js/02-first-steps/13-while-for/4-for-even/solution.md b/1-js/02-first-steps/13-while-for/4-for-even/solution.md
index e8e66bb47..00758ebff 100644
--- a/1-js/02-first-steps/13-while-for/4-for-even/solution.md
+++ b/1-js/02-first-steps/13-while-for/4-for-even/solution.md
@@ -8,4 +8,4 @@ for (let i = 2; i <= 10; i++) {
 }
 ```
 
-We use the "modulo" operator `%` to get the remainder and check for the evenness here.
+K získání zbytku po dělení dvěma a ověření sudosti zde používáme operátor „modulo“ `%`.
diff --git a/1-js/02-first-steps/13-while-for/4-for-even/task.md b/1-js/02-first-steps/13-while-for/4-for-even/task.md
index ff34e7e40..059ea4b39 100644
--- a/1-js/02-first-steps/13-while-for/4-for-even/task.md
+++ b/1-js/02-first-steps/13-while-for/4-for-even/task.md
@@ -2,8 +2,8 @@ importance: 5
 
 ---
 
-# Output even numbers in the loop
+# Vypište sudá čísla v cyklu
 
-Use the `for` loop to output even numbers from `2` to `10`.
+Použitím cyklu `for` vypište sudá čísla od `2` do `10`.
 
 [demo]
diff --git a/1-js/02-first-steps/13-while-for/5-replace-for-while/solution.md b/1-js/02-first-steps/13-while-for/5-replace-for-while/solution.md
index 612cf559c..d83493c91 100644
--- a/1-js/02-first-steps/13-while-for/5-replace-for-while/solution.md
+++ b/1-js/02-first-steps/13-while-for/5-replace-for-while/solution.md
@@ -3,7 +3,7 @@
 ```js run
 let i = 0;
 while (i < 3) {
-  alert( `number ${i}!` );
+  alert( `číslo ${i}!` );
   i++;
 }
 ```
diff --git a/1-js/02-first-steps/13-while-for/5-replace-for-while/task.md b/1-js/02-first-steps/13-while-for/5-replace-for-while/task.md
index 0c69d9c2d..6f3ceb5f1 100644
--- a/1-js/02-first-steps/13-while-for/5-replace-for-while/task.md
+++ b/1-js/02-first-steps/13-while-for/5-replace-for-while/task.md
@@ -2,13 +2,13 @@ importance: 5
 
 ---
 
-# Replace "for" with "while"
+# Nahraďte cyklus „for“ cyklem „while“
 
-Rewrite the code changing the `for` loop to `while` without altering its behavior (the output should stay same).
+Přepište kód tak, že cyklus `for` zaměníte za cyklus `while`, aniž by se změnilo jeho chování (výstup má zůstat stejný).
 
 ```js run
 for (let i = 0; i < 3; i++) {
-  alert( `number ${i}!` );
+  alert( `číslo ${i}!` );
 }
 ```
 
diff --git a/1-js/02-first-steps/13-while-for/6-repeat-until-correct/solution.md b/1-js/02-first-steps/13-while-for/6-repeat-until-correct/solution.md
index c7de5f09b..3b021c198 100644
--- a/1-js/02-first-steps/13-while-for/6-repeat-until-correct/solution.md
+++ b/1-js/02-first-steps/13-while-for/6-repeat-until-correct/solution.md
@@ -1,15 +1,15 @@
 
 ```js run demo
-let num;
+let číslo;
 
 do {
-  num = prompt("Enter a number greater than 100?", 0);
-} while (num <= 100 && num);
+  číslo = prompt("Zadejte číslo větší než 100", 0);
+} while (číslo <= 100 && číslo);
 ```
 
-The loop `do..while` repeats while both checks are truthy:
+Cyklus `do..while` se opakuje, dokud jsou obě podmínky splněny:
 
-1. The check for `num <= 100` -- that is, the entered value is still not greater than `100`.
-2. The check `&& num` is false when `num` is `null` or an empty string. Then the `while` loop stops too.
+1. Podmínka `číslo <= 100` -- tedy že zadaná hodnota stále není větší než `100`.
+2. Podmínka `&& číslo` je nepravdivá, když `číslo` je `null` nebo prázdný řetězec. Pak se cyklus `while` rovněž zastaví.
 
-P.S. If `num` is `null` then `num <= 100` is `true`, so without the 2nd check the loop wouldn't stop if the user clicks CANCEL. Both checks are required.
+P.S. Jestliže `číslo` je `null`, pak `číslo <= 100` vydá `true`, takže bez druhé podmínky by se cyklus nezastavil, kdyby uživatel stiskl Storno. Obě podmínky jsou zapotřebí.
diff --git a/1-js/02-first-steps/13-while-for/6-repeat-until-correct/task.md b/1-js/02-first-steps/13-while-for/6-repeat-until-correct/task.md
index 0788ee76e..ebd4f935c 100644
--- a/1-js/02-first-steps/13-while-for/6-repeat-until-correct/task.md
+++ b/1-js/02-first-steps/13-while-for/6-repeat-until-correct/task.md
@@ -2,12 +2,12 @@ importance: 5
 
 ---
 
-# Repeat until the input is correct
+# Opakujte, dokud vstup nebude správně
 
-Write a loop which prompts for a number greater than `100`. If the visitor enters another number -- ask them to input again.
+Napište cyklus, který se bude ptát na číslo větší než `100`. Pokud návštěvník zadá jiné číslo, zeptejte se ho znovu.
 
-The loop must ask for a number until either the visitor enters a number greater than `100` or cancels the input/enters an empty line.
+Cyklus se musí ptát na číslo tak dlouho, až návštěvník zadá číslo větší než `100` nebo zruší vstup či zadá prázdný řádek.
 
-Here we can assume that the visitor only inputs numbers. There's no need to implement a special handling for a non-numeric input in this task.
+Zde můžeme předpokládat, že uživatel zadává pouze čísla. V této úloze nemusíte implementovat zvláštní zacházení s nečíselnými vstupy.
 
 [demo]
diff --git a/1-js/02-first-steps/13-while-for/7-list-primes/solution.md b/1-js/02-first-steps/13-while-for/7-list-primes/solution.md
index b4b64b6fa..6fcd617dd 100644
--- a/1-js/02-first-steps/13-while-for/7-list-primes/solution.md
+++ b/1-js/02-first-steps/13-while-for/7-list-primes/solution.md
@@ -1,29 +1,29 @@
-There are many algorithms for this task.
+Pro tuto úlohu existuje mnoho algoritmů.
 
-Let's use a nested loop:
+Použijeme vnořený cyklus:
 
 ```js
-For each i in the interval {
-  check if i has a divisor from 1..i
-  if yes => the value is not a prime
-  if no => the value is a prime, show it
+pro každé i v intervalu {
+  ověř, zda i má dělitele mezi 1..i
+  pokud ano => i není prvočíslo
+  pokud ne => i je prvočíslo, zobraz ho
 }
 ```
 
-The code using a label:
+Kód s použitím návěští:
 
 ```js run
 let n = 10;
 
-nextPrime:
-for (let i = 2; i <= n; i++) { // for each i...
+dalšíPrvočíslo:
+for (let i = 2; i <= n; i++) { // pro každé i...
 
-  for (let j = 2; j < i; j++) { // look for a divisor..
-    if (i % j == 0) continue nextPrime; // not a prime, go next i
+  for (let j = 2; j < i; j++) { // hledáme dělitele...
+    if (i % j == 0) continue dalšíPrvočíslo; // není to prvočíslo, přejdeme k dalšímu i
   }
 
-  alert( i ); // a prime
+  alert( i ); // je to prvočíslo
 }
 ```
 
-There's a lot of space to optimize it. For instance, we could look for the divisors from `2` to square root of `i`. But anyway, if we want to be really efficient for large intervals, we need to change the approach and rely on advanced maths and complex algorithms like [Quadratic sieve](https://en.wikipedia.org/wiki/Quadratic_sieve), [General number field sieve](https://en.wikipedia.org/wiki/General_number_field_sieve) etc.
+Je zde mnoho prostoru k optimalizaci. Můžeme se například dívat jen na dělitele od `2` do odmocniny `i`. Kdybychom však chtěli být opravdu efektivní i pro velké intervaly, museli bychom změnit přístup a zaměřit se na vysokou matematiku a složité algoritmy, např. [kvadratické síto](https://en.wikipedia.org/wiki/Quadratic_sieve), [Obecné číselné teoretické síto (GNFS)](https://en.wikipedia.org/wiki/General_number_field_sieve) atd.
diff --git a/1-js/02-first-steps/13-while-for/7-list-primes/task.md b/1-js/02-first-steps/13-while-for/7-list-primes/task.md
index 6344b9f6f..e61b644bb 100644
--- a/1-js/02-first-steps/13-while-for/7-list-primes/task.md
+++ b/1-js/02-first-steps/13-while-for/7-list-primes/task.md
@@ -2,16 +2,16 @@ importance: 3
 
 ---
 
-# Output prime numbers
+# Vypište prvočísla
 
-An integer number greater than `1` is called a [prime](https://en.wikipedia.org/wiki/Prime_number) if it cannot be divided without a remainder by anything except `1` and itself.
+Celé číslo větší než `1` se nazývá [prvočíslo](https://cs.wikipedia.org/wiki/Prvočíslo), jestliže není dělitelné beze zbytku jiným celým číslem než `1` a sebou samým.
 
-In other words, `n > 1` is a prime if it can't be evenly divided by anything except `1` and `n`.
+Jinými slovy, číslo `n > 1` je prvočíslo, jestliže není dělitelné beze zbytku jiným číslem než `1` a `n`.
 
-For example, `5` is a prime, because it cannot be divided without a remainder by `2`, `3` and `4`.
+Například `5` je prvočíslo, protože není dělitelné beze zbytku číslem `2`, `3` ani `4`.
 
-**Write the code which outputs prime numbers in the interval from `2` to `n`.**
+**Napište kód, který vypíše všechna prvočísla v intervalu od `2` do `n`.**
 
-For `n = 10` the result will be `2,3,5,7`.
+Například pro `n = 10` bude výsledek `2,3,5,7`.
 
-P.S. The code should work for any `n`, not be hard-tuned for any fixed value.
+P.S. Kód by měl fungovat pro jakékoli `n`. Neměl by být vyladěn jen pro nějakou pevnou hodnotu.
diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index a7a211569..550c2946a 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -1,54 +1,52 @@
-# Loops: while and for
+# Cykly: while a for
 
-We often need to repeat actions.
+Často potřebujeme opakovat některé akce. Například vypsat ze seznamu jedno zboží po druhém nebo jen vykonat stejný kód pro každé z čísel od 1 do 10.
 
-For example, outputting goods from a list one after another or just running the same code for each number from 1 to 10.
+Způsob, jak opakovat stejný kód několikrát, poskytují *cykly* neboli *smyčky*.
 
-*Loops* are a way to repeat the same code multiple times.
+## Cyklus „while“
 
-## The "while" loop
-
-The `while` loop has the following syntax:
+Cyklus `while` má následující syntaxi:
 
 ```js
-while (condition) {
-  // code
-  // so-called "loop body"
+while (podmínka) {
+  // kód
+  // tzv. „tělo cyklu“
 }
 ```
 
-While the `condition` is truthy, the `code` from the loop body is executed.
+Dokud je `podmínka` pravdivá, `kód` z těla cyklu se bude vykonávat.
 
-For instance, the loop below outputs `i` while `i < 3`:
+Například tento cyklus vypisuje proměnnou `i` tak dlouho, dokud je `i < 3`:
 
 ```js run
 let i = 0;
-while (i < 3) { // shows 0, then 1, then 2
+while (i < 3) { // zobrazí 0, pak 1, pak 2
   alert( i );
   i++;
 }
 ```
 
-A single execution of the loop body is called *an iteration*. The loop in the example above makes three iterations.
+Jedno vykonání těla cyklu se nazývá *iterace*. Cyklus v uvedeném příkladu vykoná tři iterace.
 
-If `i++` was missing from the example above, the loop would repeat (in theory) forever. In practice, the browser provides ways to stop such loops, and in server-side JavaScript, we can kill the process.
+Kdyby v tomto příkladu chyběl příkaz `i++`, cyklus by se vykonával (teoreticky) donekonečna. V praxi prohlížeče poskytují způsoby, jak takový cyklus zastavit, a v JavaScriptu na serverové straně můžeme proces zastavit („shodit“) sami.
 
-Any expression or variable can be a loop condition, not just comparisons: the condition is evaluated and converted to a boolean by `while`.
+Platnou podmínkou cyklu může být jakákoli proměnná nebo výraz, nejenom porovnání: příkaz `while` podmínku vyhodnotí a převede na typ boolean.
 
-For instance, a shorter way to write `while (i != 0)` is `while (i)`:
+Například `while (i != 0)` se dá napsat kratším způsobem jako `while (i)`:
 
 ```js run
 let i = 3;
 *!*
-while (i) { // when i becomes 0, the condition becomes falsy, and the loop stops
+while (i) { // když i bude 0, podmínka bude nepravdivá a cyklus skončí
 */!*
   alert( i );
   i--;
 }
 ```
 
-````smart header="Curly braces are not required for a single-line body"
-If the loop body has a single statement, we can omit the curly braces `{…}`:
+````smart header="Tělo tvořené jedním příkazem nemusí mít složené závorky"
+Obsahuje-li tělo cyklu jen jediný příkaz, můžeme složené závorky `{…}` vynechat:
 
 ```js run
 let i = 3;
@@ -58,19 +56,19 @@ while (i) alert(i--);
 ```
 ````
 
-## The "do..while" loop
+## Cyklus „do..while“
 
-The condition check can be moved *below* the loop body using the `do..while` syntax:
+Ověření podmínky můžeme přesunout až *za* tělo cyklu, použijeme-li syntaxi `do..while`:
 
 ```js
 do {
-  // loop body
-} while (condition);
+  // tělo cyklu
+} while (podmínka);
 ```
 
-The loop will first execute the body, then check the condition, and, while it's truthy, execute it again and again.
+Cyklus nejprve vykoná tělo, pak ověří podmínku, a dokud je pravdivá, bude vykonávat tělo znovu a znovu.
 
-For example:
+Příklad:
 
 ```js run
 let i = 0;
@@ -80,109 +78,109 @@ do {
 } while (i < 3);
 ```
 
-This form of syntax should only be used when you want the body of the loop to execute **at least once** regardless of the condition being truthy. Usually, the other form is preferred: `while(…) {…}`.
+Tuto formu syntaxe byste měli používat jen tehdy, když chcete, aby se tělo cyklu vykonalo vždy **aspoň jednou**, bez ohledu na pravdivost podmínky. Obvykle se dává přednost předchozí formě: `while(…) {…}`.
 
-## The "for" loop
+## Cyklus „for“
 
-The `for` loop is more complex, but it's also the most commonly used loop.
+Cyklus `for` je složitější, ale také nejčastěji používaný.
 
-It looks like this:
+Vypadá takto:
 
 ```js
-for (begin; condition; step) {
-  // ... loop body ...
+for (začátek; podmínka; krok) {
+  // ... tělo cyklu ...
 }
 ```
 
-Let's learn the meaning of these parts by example. The loop below runs `alert(i)` for `i` from `0` up to (but not including) `3`:
+Význam jednotlivých částí si objasníme na příkladu. Níže uvedený cyklus vykoná `alert(i)` pro `i` od `0` až do (ale ne včetně) `3`:
 
 ```js run
-for (let i = 0; i < 3; i++) { // shows 0, then 1, then 2
+for (let i = 0; i < 3; i++) { // zobrazí 0, pak 1, pak 2
   alert(i);
 }
 ```
 
-Let's examine the `for` statement part-by-part:
+Prozkoumáme příkaz `for` po částech:
 
-| part  |          |                                                                            |
+| část  |          |                                                                            |
 |-------|----------|----------------------------------------------------------------------------|
-| begin | `let i = 0`    | Executes once upon entering the loop.                                      |
-| condition | `i < 3`| Checked before every loop iteration. If false, the loop stops.              |
-| body | `alert(i)`| Runs again and again while the condition is truthy.                         |
-| step| `i++`      | Executes after the body on each iteration. |
+| začátek | `i = 0`    | Vykoná se jednou po vstupu do cyklu.                                      |
+| podmínka | `i < 3`| Kontroluje se před každou iterací cyklu. Je-li nepravdivá, cyklus skončí.              |
+| tělo | `alert(i)`| Vykonává se stále znovu, dokud je podmínka pravdivá.                         |
+| krok | `i++`      | Vykoná se po těle cyklu při každé iteraci. |
 
-The general loop algorithm works like this:
+Všeobecný algoritmus cyklu funguje takto:
 
 ```
-Run begin
-→ (if condition → run body and run step)
-→ (if condition → run body and run step)
-→ (if condition → run body and run step)
+Vykonej začátek
+→ (platí-li podmínka → vykonej tělo a vykonej krok)
+→ (platí-li podmínka → vykonej tělo a vykonej krok)
+→ (platí-li podmínka → vykonej tělo a vykonej krok)
 → ...
 ```
 
-That is, `begin` executes once, and then it iterates: after each `condition` test, `body` and `step` are executed.
+To znamená, že `začátek` se vykoná jednou a pak se iteruje: po každém testu `podmínky` se vykonají `tělo` a `krok`.
 
-If you are new to loops, it could help to go back to the example and reproduce how it runs step-by-step on a piece of paper.
+Jestliže s cykly teprve začínáte, pomůže vám vrátit se k příkladu a na papíře si krok po kroku projít, jak se vykoná.
 
-Here's exactly what happens in our case:
+V našem případě se stane přesně toto:
 
 ```js
 // for (let i = 0; i < 3; i++) alert(i)
 
-// run begin
+// vykonej začátek
 let i = 0
-// if condition → run body and run step
+// platí-li podmínka → vykonej tělo a vykonej krok
 if (i < 3) { alert(i); i++ }
-// if condition → run body and run step
+// platí-li podmínka → vykonej tělo a vykonej krok
 if (i < 3) { alert(i); i++ }
-// if condition → run body and run step
+// platí-li podmínka → vykonej tělo a vykonej krok
 if (i < 3) { alert(i); i++ }
-// ...finish, because now i == 3
+// ...konec, protože nyní je i == 3
 ```
 
-````smart header="Inline variable declaration"
-Here, the "counter" variable `i` is declared right in the loop. This is called an "inline" variable declaration. Such variables are visible only inside the loop.
+````smart header="Inline deklarace proměnné"
+„Čítačová“ proměnná `i` je zde deklarována rovnou v cyklu. To se nazývá „inline“ (na místě) deklarace proměnné. Takové proměnné jsou viditelné jen uvnitř cyklu.
 
 ```js run
 for (*!*let*/!* i = 0; i < 3; i++) {
   alert(i); // 0, 1, 2
 }
-alert(i); // error, no such variable
+alert(i); // chyba, tato proměnná neexistuje
 ```
 
-Instead of defining a variable, we could use an existing one:
+Namísto definice nové proměnné můžeme použít existující:
 
 ```js run
 let i = 0;
 
-for (i = 0; i < 3; i++) { // use an existing variable
+for (i = 0; i < 3; i++) { // použijeme existující proměnnou
   alert(i); // 0, 1, 2
 }
 
-alert(i); // 3, visible, because declared outside of the loop
+alert(i); // 3, je viditelná, protože byla deklarována mimo cyklus
 ```
 
 ````
 
 
-### Skipping parts
+### Vynechávání částí
 
-Any part of `for` can be skipped.
+Kteroukoli část `for` můžeme vynechat.
 
-For example, we can omit `begin` if we don't need to do anything at the loop start.
+Například můžeme vynechat `začátek`, jestliže nechceme na začátku cyklu nic provádět.
 
-Like here:
+Například zde:
 
 ```js run
-let i = 0; // we have i already declared and assigned
+let i = 0; // už máme proměnnou i deklarovanou a přiřazenou
 
-for (; i < 3; i++) { // no need for "begin"
+for (; i < 3; i++) { // nepotřebujeme „začátek“
   alert( i ); // 0, 1, 2
 }
 ```
 
-We can also remove the `step` part:
+Můžeme vynechat i část `krok`:
 
 ```js run
 let i = 0;
@@ -192,32 +190,32 @@ for (; i < 3;) {
 }
 ```
 
-This makes the loop identical to `while (i < 3)`.
+Pak bude cyklus identický jako `while (i < 3)`.
 
-We can actually remove everything, creating an infinite loop:
+Ve skutečnosti můžeme vynechat všechno a vytvořit tím nekonečnou smyčku:
 
 ```js
 for (;;) {
-  // repeats without limits
+  // opakuje se neustále
 }
 ```
 
-Please note that the two `for` semicolons `;` must be present. Otherwise, there would be a syntax error.
+Všimněte si, že dva středníky `;` ve `for` musejí být uvedeny, jinak nastane syntaktická chyba.
 
-## Breaking the loop
+## Opuštění smyčky
 
-Normally, a loop exits when its condition becomes falsy.
+Za běžných okolností se cyklus ukončí, když jeho podmínka přestane být splněna.
 
-But we can force the exit at any time using the special `break` directive.
+Kdykoli si však můžeme ukončení vynutit použitím speciální direktivy `break`.
 
-For example, the loop below asks the user for a series of numbers, "breaking" when no number is entered:
+Například níže uvedený cyklus se uživatele ptá na sérii čísel, a když uživatel žádné číslo nezadá, cyklus skončí:
 
 ```js run
 let sum = 0;
 
 while (true) {
 
-  let value = +prompt("Enter a number", '');
+  let value = +prompt("Zadejte číslo", '');
 
 *!*
   if (!value) break; // (*)
@@ -226,35 +224,35 @@ while (true) {
   sum += value;
 
 }
-alert( 'Sum: ' + sum );
+alert( 'Součet: ' + sum );
 ```
 
-The `break` directive is activated at the line `(*)` if the user enters an empty line or cancels the input. It stops the loop immediately, passing control to the first line after the loop. Namely, `alert`.
+Direktiva `break` na řádku `(*)` se aktivuje, jestliže uživatel zadá prázdný řádek nebo zruší vstup. Okamžitě ukončí cyklus a předá řízení na první řádek za cyklem, konkrétně `alert`.
 
-The combination "infinite loop + `break` as needed" is great for situations when a loop's condition must be checked not in the beginning or end of the loop, but in the middle or even in several places of its body.
+Kombinace „nekonečná smyčka + `break`, když je zapotřebí“ je výhodná v situacích, kdy potřebujeme podmínku cyklu ověřovat ne na začátku nebo na konci cyklu, ale uprostřed cyklu nebo dokonce na několika místech jeho těla.
 
-## Continue to the next iteration [#continue]
+## Pokračování k další iteraci [#continue]
 
-The `continue` directive is a "lighter version" of `break`. It doesn't stop the whole loop. Instead, it stops the current iteration and forces the loop to start a new one (if the condition allows).
+Direktiva `continue` je „slabší verzí“ `break`. Nezastaví celý cyklus, ale zastaví jen právě probíhající iteraci a přinutí cyklus začít novou (jestliže podmínka platí).
 
-We can use it if we're done with the current iteration and would like to move on to the next one.
+Můžeme ji použít, když jsme hotovi s právě probíhající iterací a rádi bychom okamžitě přešli k další.
 
-The loop below uses `continue` to output only odd values:
+Níže uvedený cyklus využívá `continue` k vypsání jen lichých hodnot:
 
 ```js run no-beautify
 for (let i = 0; i < 10; i++) {
 
-  // if true, skip the remaining part of the body
+  // je-li podmínka pravdivá, přeskočíme zbytek těla
   *!*if (i % 2 == 0) continue;*/!*
 
-  alert(i); // 1, then 3, 5, 7, 9
+  alert(i); // 1, pak 3, 5, 7, 9
 }
 ```
 
-For even values of `i`, the `continue` directive stops executing the body and passes control to the next iteration of `for` (with the next number). So the `alert` is only called for odd values.
+Pro sudé hodnoty `i` direktiva `continue` ukončí vykonávání těla a předá řízení další iteraci `for` (s dalším číslem). Proto se `alert` bude volat jedině pro liché hodnoty.
 
-````smart header="The `continue` directive helps decrease nesting"
-A loop that shows odd values could look like this:
+````smart header="Direktiva `continue` pomáhá redukovat vnoření"
+Cyklus, který zobrazuje liché hodnoty, by mohl vypadat i takto:
 
 ```js run
 for (let i = 0; i < 10; i++) {
@@ -266,15 +264,15 @@ for (let i = 0; i < 10; i++) {
 }
 ```
 
-From a technical point of view, this is identical to the example above. Surely, we can just wrap the code in an `if` block instead of using `continue`.
+Z technického pohledu je to stejné jako výše uvedený příklad. Bezpochyby můžeme namísto použití `continue` vnořit kód do bloku `if`.
 
-But as a side-effect, this created one more level of nesting (the `alert` call inside the curly braces). If the code inside of `if` is longer than a few lines, that may decrease the overall readability.
+Jako vedlejší efekt jsme však vytvořili jednu další úroveň vnoření (volání `alert` uvnitř složených závorek). Je-li kód uvnitř `if` delší než několik řádků, může to snížit jeho celkovou čitelnost.
 ````
 
-````warn header="No `break/continue` to the right side of '?'"
-Please note that syntax constructs that are not expressions cannot be used with the ternary operator `?`. In particular, directives such as `break/continue` aren't allowed there.
+````warn header="`break/continue` nesmějí být na pravé straně „?“"
+Všimněte si, že syntaktické konstrukce, které nejsou výrazy, nelze použít s ternárním operátorem „?“. Konkrétně tam nejsou povoleny direktivy jako `break/continue`.
 
-For example, if we take this code:
+Například vezměme si tento kód:
 
 ```js
 if (i > 5) {
@@ -284,114 +282,114 @@ if (i > 5) {
 }
 ```
 
-...and rewrite it using a question mark:
+...a přepišme jej pomocí otazníku:
 
 
 ```js no-beautify
-(i > 5) ? alert(i) : *!*continue*/!*; // continue isn't allowed here
+(i > 5) ? alert(i) : *!*continue*/!*; // continue tady nesmí být
 ```
 
-...it stops working: there's a syntax error.
+...přestane to fungovat: nastane syntaktická chyba.
 
-This is just another reason not to use the question mark operator `?` instead of `if`.
+To je další důvod, proč nepoužívat operátor otazníku `?` namísto `if`.
 ````
 
-## Labels for break/continue
+## Návěští pro break/continue
 
-Sometimes we need to break out from multiple nested loops at once.
+Někdy se potřebujeme dostat ven z několika vnořených cyklů najednou.
 
-For example, in the code below we loop over `i` and `j`, prompting for the coordinates `(i, j)` from `(0,0)` to `(2,2)`:
+Například v níže uvedeném kódu vykonáváme cyklus nad `i` a `j`, který se ptá na hodnoty `(i, j)` od `(0,0)` do `(2,2)`:
 
 ```js run no-beautify
 for (let i = 0; i < 3; i++) {
 
   for (let j = 0; j < 3; j++) {
 
-    let input = prompt(`Value at coords (${i},${j})`, '');
+    let vstup = prompt(`Hodnota na souřadnicích (${i},${j})`, '');
 
-    // what if we want to exit from here to Done (below)?
+    // co když chceme vyskočit odtud až na „Hotovo“ níže?
   }
 }
 
-alert('Done!');
+alert('Hotovo!');
 ```
 
-We need a way to stop the process if the user cancels the input.
+Potřebujeme způsob, jak tento proces zastavit, jestliže uživatel zruší vstup.
 
-The ordinary `break` after `input` would only break the inner loop. That's not sufficient -- labels, come to the rescue!
+Pouhé `break` po `vstup` by ukončilo jen vnitřní cyklus. To nám však nestačí. Návěští, pojďte nám na pomoc!
 
-A *label* is an identifier with a colon before a loop:
+*Návěští* je identifikátor s dvojtečkou před cyklem:
 ```js
-labelName: for (...) {
+názevNávěští: for (...) {
   ...
 }
 ```
 
-The `break <labelName>` statement in the loop below breaks out to the label:
+Příkaz `break <názevNávěští>` v níže uvedeném cyklu vyskočí až z návěští:
 
 ```js run no-beautify
-*!*outer:*/!* for (let i = 0; i < 3; i++) {
+*!*vnější:*/!* for (let i = 0; i < 3; i++) {
 
   for (let j = 0; j < 3; j++) {
 
-    let input = prompt(`Value at coords (${i},${j})`, '');
+    let vstup = prompt(`Hodnota na souřadnicích (${i},${j})`, '');
 
-    // if an empty string or canceled, then break out of both loops
-    if (!input) *!*break outer*/!*; // (*)
+    // je-li zadán prázdný řetězec nebo zrušen vstup, vyskočí se z obou cyklů
+    if (!vstup) *!*break vnější*/!*; // (*)
 
-    // do something with the value...
+    // provedeme něco s hodnotou...
   }
 }
-alert('Done!');
+alert('Hotovo!');
 ```
 
-In the code above, `break outer` looks upwards for the label named `outer` and breaks out of that loop.
+Ve výše uvedeném kódu `break vnější` najde návěští s názvem `vnější` a vyskočí z jeho cyklu.
 
-So the control goes straight from `(*)` to `alert('Done!')`.
+Řízení se tedy předá přímo z `(*)` na `alert('Hotovo!')`.
 
-We can also move the label onto a separate line:
+Můžeme návěští umístit i na samostatný řádek:
 
 ```js no-beautify
-outer:
+vnější:
 for (let i = 0; i < 3; i++) { ... }
 ```
 
-The `continue` directive can also be used with a label. In this case, code execution jumps to the next iteration of the labeled loop.
+Návěští můžeme použít i v direktivě `continue`. V takovém případě výkon kódu přeskočí k další iteraci cyklu s uvedeným návěštím.
 
-````warn header="Labels do not allow to \"jump\" anywhere"
-Labels do not allow us to jump into an arbitrary place in the code.
+````warn header="Návěští nám neumožňují „skákat“ kamkoli!"
+Návěští nám neumožňují skákat na libovolné místo v kódu.
 
-For example, it is impossible to do this:
+Například nejde udělat toto:
 ```js
-break label; // jump to the label below (doesn't work)
+break návěští; // skok na návěští níže (nebude fungovat)
 
-label: for (...)
+návěští: for (...)
 ```
 
-A `break` directive must be inside a code block. Technically, any labelled code block will do, e.g.:
+Direktiva `break` musí být uvnitř kódového bloku. Technicky to může být jakýkoli kódový blok s návěštím, např.:
 ```js
-label: {
+návěští: {
   // ...
-  break label; // works
+  break návěští; // funguje to
   // ...
 }
 ```
 
-...Although, 99.9% of the time `break` is used inside loops, as we've seen in the examples above.
+...Avšak v 99,9% případů se `break` používá uvnitř cyklů, jak jsme viděli ve výše uvedených příkladech.
 
-A `continue` is only possible from inside a loop.
+Direktiva `continue` může být jedině uvnitř cyklu.
 ````
 
-## Summary
+## Shrnutí
 
-We covered 3 types of loops:
+Uvedli jsme tři druhy cyklů:
 
-- `while` -- The condition is checked before each iteration.
-- `do..while` -- The condition is checked after each iteration.
-- `for (;;)` -- The condition is checked before each iteration, additional settings available.
+- `while` -- Podmínka se ověří před každou iterací.
+- `do..while` -- Podmínka se ověří po každé iteraci.
+- `for (;;)` -- Podmínka se ověří před každou iterací, jsou možná i další nastavení.
 
-To make an "infinite" loop, usually the `while(true)` construct is used. Such a loop, just like any other, can be stopped with the `break` directive.
+K vytvoření „nekonečné“ smyčky se obvykle používá konstrukce `while(true)`. Takovou smyčku lze zastavit direktivou `break`, stejně jako každou jinou.
 
-If we don't want to do anything in the current iteration and would like to forward to the next one, we can use the `continue` directive.
+Pokud nechceme už nic provádět v současné iteraci a chceme rovnou přejít k další, použijeme direktivu `continue`.
 
-`break/continue` support labels before the loop. A label is the only way for `break/continue` to escape a nested loop to go to an outer one.
+`break/continue` podporují návěští před cyklem. Návěští je jediný způsob, jak může `break/continue` ve vnořeném cyklu vyskočit z vnějšího cyklu.

From ac45f55d63a13a7480e17f7c67b8a69854306b91 Mon Sep 17 00:00:00 2001
From: otmon76 <66325539+otmon76@users.noreply.github.com>
Date: Thu, 23 Jun 2022 20:28:56 +0200
Subject: [PATCH 02/22] Update 1-js/02-first-steps/13-while-for/article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Daniel Pomajbík <60559058+danipoma@users.noreply.github.com>
---
 1-js/02-first-steps/13-while-for/article.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index 550c2946a..6ea9405fe 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -1,6 +1,8 @@
 # Cykly: while a for
 
-Často potřebujeme opakovat některé akce. Například vypsat ze seznamu jedno zboží po druhém nebo jen vykonat stejný kód pro každé z čísel od 1 do 10.
+Často potřebujeme opakovat některé akce. 
+
+Například vypsat ze seznamu jedno zboží po druhém nebo jen vykonat stejný kód pro každé z čísel od 1 do 10.
 
 Způsob, jak opakovat stejný kód několikrát, poskytují *cykly* neboli *smyčky*.
 

From 604a3a3bd692d3997fe51e9d7c8c39a3aafdc02a Mon Sep 17 00:00:00 2001
From: otmon76 <66325539+otmon76@users.noreply.github.com>
Date: Thu, 23 Jun 2022 20:29:06 +0200
Subject: [PATCH 03/22] Update 1-js/02-first-steps/13-while-for/article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Daniel Pomajbík <60559058+danipoma@users.noreply.github.com>
---
 1-js/02-first-steps/13-while-for/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index 6ea9405fe..1f6493bb5 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -29,7 +29,7 @@ while (i < 3) { // zobrazí 0, pak 1, pak 2
 }
 ```
 
-Jedno vykonání těla cyklu se nazývá *iterace*. Cyklus v uvedeném příkladu vykoná tři iterace.
+Jedno vykonání těla cyklu se nazývá *iterace*. Cyklus ve výše uvedeném příkladu vykoná tři iterace.
 
 Kdyby v tomto příkladu chyběl příkaz `i++`, cyklus by se vykonával (teoreticky) donekonečna. V praxi prohlížeče poskytují způsoby, jak takový cyklus zastavit, a v JavaScriptu na serverové straně můžeme proces zastavit („shodit“) sami.
 

From d1cfebfa25d49b575f571311546300a55ee35d6a Mon Sep 17 00:00:00 2001
From: otmon76 <66325539+otmon76@users.noreply.github.com>
Date: Thu, 23 Jun 2022 20:29:23 +0200
Subject: [PATCH 04/22] Update 1-js/02-first-steps/13-while-for/article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Daniel Pomajbík <60559058+danipoma@users.noreply.github.com>
---
 1-js/02-first-steps/13-while-for/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index 1f6493bb5..dc6e4b51a 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -106,7 +106,7 @@ Prozkoumáme příkaz `for` po částech:
 
 | část  |          |                                                                            |
 |-------|----------|----------------------------------------------------------------------------|
-| začátek | `i = 0`    | Vykoná se jednou po vstupu do cyklu.                                      |
+| začátek | `let i = 0`    | Vykoná se jednou po vstupu do cyklu.                                      |
 | podmínka | `i < 3`| Kontroluje se před každou iterací cyklu. Je-li nepravdivá, cyklus skončí.              |
 | tělo | `alert(i)`| Vykonává se stále znovu, dokud je podmínka pravdivá.                         |
 | krok | `i++`      | Vykoná se po těle cyklu při každé iteraci. |

From 5f77e5d0097171f84c137d182796869d7682efc6 Mon Sep 17 00:00:00 2001
From: otmon76 <66325539+otmon76@users.noreply.github.com>
Date: Thu, 23 Jun 2022 20:29:33 +0200
Subject: [PATCH 05/22] Update 1-js/02-first-steps/13-while-for/article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Daniel Pomajbík <60559058+danipoma@users.noreply.github.com>
---
 1-js/02-first-steps/13-while-for/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index dc6e4b51a..21dacb3c5 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -121,7 +121,7 @@ Vykonej začátek
 → ...
 ```
 
-To znamená, že `začátek` se vykoná jednou a pak se iteruje: po každém testu `podmínky` se vykonají `tělo` a `krok`.
+To znamená, že `začátek` se vykoná jednou a pak se iteruje: po každém testu `podmínky` se vykoná `tělo` a `krok`.
 
 Jestliže s cykly teprve začínáte, pomůže vám vrátit se k příkladu a na papíře si krok po kroku projít, jak se vykoná.
 

From 6b7ec81a14e58e9321422ddceb09d7bdae813a70 Mon Sep 17 00:00:00 2001
From: otmon76 <66325539+otmon76@users.noreply.github.com>
Date: Thu, 23 Jun 2022 20:29:41 +0200
Subject: [PATCH 06/22] Update 1-js/02-first-steps/13-while-for/article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Daniel Pomajbík <60559058+danipoma@users.noreply.github.com>
---
 1-js/02-first-steps/13-while-for/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index 21dacb3c5..70bf7a806 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -192,7 +192,7 @@ for (; i < 3;) {
 }
 ```
 
-Pak bude cyklus identický jako `while (i < 3)`.
+Pak bude cyklus stejný jako `while (i < 3)`.
 
 Ve skutečnosti můžeme vynechat všechno a vytvořit tím nekonečnou smyčku:
 

From 8cfd1f4a7172d7f861e610f4b652a08f2be8b250 Mon Sep 17 00:00:00 2001
From: otmon76 <66325539+otmon76@users.noreply.github.com>
Date: Thu, 23 Jun 2022 20:29:51 +0200
Subject: [PATCH 07/22] Update 1-js/02-first-steps/13-while-for/article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Daniel Pomajbík <60559058+danipoma@users.noreply.github.com>
---
 1-js/02-first-steps/13-while-for/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index 70bf7a806..2357c5f05 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -213,7 +213,7 @@ Kdykoli si však můžeme ukončení vynutit použitím speciální direktivy `b
 Například níže uvedený cyklus se uživatele ptá na sérii čísel, a když uživatel žádné číslo nezadá, cyklus skončí:
 
 ```js run
-let sum = 0;
+let součet = 0;
 
 while (true) {
 

From 5d83267077aa567665c24b66dd4b79d264996d6d Mon Sep 17 00:00:00 2001
From: otmon76 <66325539+otmon76@users.noreply.github.com>
Date: Thu, 23 Jun 2022 20:30:04 +0200
Subject: [PATCH 08/22] Update 1-js/02-first-steps/13-while-for/article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Daniel Pomajbík <60559058+danipoma@users.noreply.github.com>
---
 1-js/02-first-steps/13-while-for/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index 2357c5f05..58825db08 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -217,7 +217,7 @@ let součet = 0;
 
 while (true) {
 
-  let value = +prompt("Zadejte číslo", '');
+  let hodnota = +prompt("Zadejte číslo", '');
 
 *!*
   if (!value) break; // (*)

From 91b1ce157441c0567915adee109167d5923c5522 Mon Sep 17 00:00:00 2001
From: otmon76 <66325539+otmon76@users.noreply.github.com>
Date: Thu, 23 Jun 2022 20:30:12 +0200
Subject: [PATCH 09/22] Update 1-js/02-first-steps/13-while-for/article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Daniel Pomajbík <60559058+danipoma@users.noreply.github.com>
---
 1-js/02-first-steps/13-while-for/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index 58825db08..1cf8d809a 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -220,7 +220,7 @@ while (true) {
   let hodnota = +prompt("Zadejte číslo", '');
 
 *!*
-  if (!value) break; // (*)
+  if (!hodnota) break; // (*)
 */!*
 
   sum += value;

From 9dae4f5d8eb1b9a40326d4b3c6e5191e5e07f898 Mon Sep 17 00:00:00 2001
From: otmon76 <66325539+otmon76@users.noreply.github.com>
Date: Thu, 23 Jun 2022 20:30:21 +0200
Subject: [PATCH 10/22] Update 1-js/02-first-steps/13-while-for/article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Daniel Pomajbík <60559058+danipoma@users.noreply.github.com>
---
 1-js/02-first-steps/13-while-for/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index 1cf8d809a..933c05163 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -223,7 +223,7 @@ while (true) {
   if (!hodnota) break; // (*)
 */!*
 
-  sum += value;
+  součet += hodnota;
 
 }
 alert( 'Součet: ' + sum );

From 3f5b4112cd974bd532540f89f90d5374684c1aef Mon Sep 17 00:00:00 2001
From: otmon76 <66325539+otmon76@users.noreply.github.com>
Date: Thu, 23 Jun 2022 20:30:28 +0200
Subject: [PATCH 11/22] Update 1-js/02-first-steps/13-while-for/article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Daniel Pomajbík <60559058+danipoma@users.noreply.github.com>
---
 1-js/02-first-steps/13-while-for/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index 933c05163..1393b78ce 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -226,7 +226,7 @@ while (true) {
   součet += hodnota;
 
 }
-alert( 'Součet: ' + sum );
+alert( 'Součet: ' + součet );
 ```
 
 Direktiva `break` na řádku `(*)` se aktivuje, jestliže uživatel zadá prázdný řádek nebo zruší vstup. Okamžitě ukončí cyklus a předá řízení na první řádek za cyklem, konkrétně `alert`.

From 365b2706de9009779128568c5ddaa55dae7d4962 Mon Sep 17 00:00:00 2001
From: otmon76 <66325539+otmon76@users.noreply.github.com>
Date: Thu, 23 Jun 2022 20:30:44 +0200
Subject: [PATCH 12/22] Update 1-js/02-first-steps/13-while-for/article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Daniel Pomajbík <60559058+danipoma@users.noreply.github.com>
---
 1-js/02-first-steps/13-while-for/article.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index 1393b78ce..2aa95a6b5 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -268,8 +268,7 @@ for (let i = 0; i < 10; i++) {
 
 Z technického pohledu je to stejné jako výše uvedený příklad. Bezpochyby můžeme namísto použití `continue` vnořit kód do bloku `if`.
 
-Jako vedlejší efekt jsme však vytvořili jednu další úroveň vnoření (volání `alert` uvnitř složených závorek). Je-li kód uvnitř `if` delší než několik řádků, může to snížit jeho celkovou čitelnost.
-````
+Jako vedlejší efekt jsme však vytvořili jednu další úroveň vnoření (volání `alert` uvnitř složených závorek). Je-li kód uvnitř `if` delší než pár řádků, může to snížit jeho celkovou čitelnost.
 
 ````warn header="`break/continue` nesmějí být na pravé straně „?“"
 Všimněte si, že syntaktické konstrukce, které nejsou výrazy, nelze použít s ternárním operátorem „?“. Konkrétně tam nejsou povoleny direktivy jako `break/continue`.

From e4315be1a2b1e9118d2c0ca8d3a75b7706b0da41 Mon Sep 17 00:00:00 2001
From: otmon76 <66325539+otmon76@users.noreply.github.com>
Date: Thu, 23 Jun 2022 20:31:04 +0200
Subject: [PATCH 13/22] Update 1-js/02-first-steps/13-while-for/article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Daniel Pomajbík <60559058+danipoma@users.noreply.github.com>
---
 1-js/02-first-steps/13-while-for/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index 2aa95a6b5..5a47db300 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -273,7 +273,7 @@ Jako vedlejší efekt jsme však vytvořili jednu další úroveň vnoření (vo
 ````warn header="`break/continue` nesmějí být na pravé straně „?“"
 Všimněte si, že syntaktické konstrukce, které nejsou výrazy, nelze použít s ternárním operátorem „?“. Konkrétně tam nejsou povoleny direktivy jako `break/continue`.
 
-Například vezměme si tento kód:
+Vezměme si například tento kód:
 
 ```js
 if (i > 5) {

From 657a6005de2f58b7b6ed97490ab9483b65da43cc Mon Sep 17 00:00:00 2001
From: otmon76 <66325539+otmon76@users.noreply.github.com>
Date: Thu, 23 Jun 2022 20:31:27 +0200
Subject: [PATCH 14/22] Update 1-js/02-first-steps/13-while-for/article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Daniel Pomajbík <60559058+danipoma@users.noreply.github.com>
---
 1-js/02-first-steps/13-while-for/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index 5a47db300..d5b65de3f 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -326,7 +326,7 @@ názevNávěští: for (...) {
 }
 ```
 
-Příkaz `break <názevNávěští>` v níže uvedeném cyklu vyskočí až z návěští:
+Příkaz `break <názevNávěští>` v níže uvedeném cyklu vyskočí z uvedeného návěští:
 
 ```js run no-beautify
 *!*vnější:*/!* for (let i = 0; i < 3; i++) {

From e6c02a3e2cec92977c409cc50e78fd7cac383eb5 Mon Sep 17 00:00:00 2001
From: otmon76 <66325539+otmon76@users.noreply.github.com>
Date: Thu, 23 Jun 2022 20:31:39 +0200
Subject: [PATCH 15/22] Update 1-js/02-first-steps/13-while-for/article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Daniel Pomajbík <60559058+danipoma@users.noreply.github.com>
---
 1-js/02-first-steps/13-while-for/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index d5b65de3f..f50e3e89f 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -355,7 +355,7 @@ vnější:
 for (let i = 0; i < 3; i++) { ... }
 ```
 
-Návěští můžeme použít i v direktivě `continue`. V takovém případě výkon kódu přeskočí k další iteraci cyklu s uvedeným návěštím.
+Návěští můžeme použít i v direktivě `continue`. V takovém případě se zbytek kódu přeskočí a další iterace bude v cyklu s uvedeným návěštím.
 
 ````warn header="Návěští nám neumožňují „skákat“ kamkoli!"
 Návěští nám neumožňují skákat na libovolné místo v kódu.

From be6052f2298ae7f23c439a9f9de0c30a082cb5af Mon Sep 17 00:00:00 2001
From: otmon76 <66325539+otmon76@users.noreply.github.com>
Date: Thu, 23 Jun 2022 20:31:47 +0200
Subject: [PATCH 16/22] Update 1-js/02-first-steps/13-while-for/article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Daniel Pomajbík <60559058+danipoma@users.noreply.github.com>
---
 1-js/02-first-steps/13-while-for/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index f50e3e89f..ff6a8b6a0 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -367,7 +367,7 @@ break návěští; // skok na návěští níže (nebude fungovat)
 návěští: for (...)
 ```
 
-Direktiva `break` musí být uvnitř kódového bloku. Technicky to může být jakýkoli kódový blok s návěštím, např.:
+Direktiva `break` musí být uvnitř kódového bloku. Technicky to může být jakýkoli blok kódu s návěštím, např.:
 ```js
 návěští: {
   // ...

From 4e96419516c2399955b5b16bdb7afb8a27ae5ac9 Mon Sep 17 00:00:00 2001
From: otmon76 <66325539+otmon76@users.noreply.github.com>
Date: Thu, 23 Jun 2022 20:31:54 +0200
Subject: [PATCH 17/22] Update 1-js/02-first-steps/13-while-for/article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Daniel Pomajbík <60559058+danipoma@users.noreply.github.com>
---
 1-js/02-first-steps/13-while-for/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index ff6a8b6a0..afc923ab3 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -371,7 +371,7 @@ Direktiva `break` musí být uvnitř kódového bloku. Technicky to může být
 ```js
 návěští: {
   // ...
-  break návěští; // funguje to
+  break návěští; // toto funguje
   // ...
 }
 ```

From 7d3a5f3d7fe3fb4f73b3079f30d6a568fc296697 Mon Sep 17 00:00:00 2001
From: otmon76 <66325539+otmon76@users.noreply.github.com>
Date: Thu, 23 Jun 2022 20:32:00 +0200
Subject: [PATCH 18/22] Update
 1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Daniel Pomajbík <60559058+danipoma@users.noreply.github.com>
---
 .../02-first-steps/13-while-for/2-which-value-while/solution.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md b/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
index 772267de7..95383503f 100644
--- a/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
+++ b/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
@@ -1,4 +1,4 @@
-Tato úloha ukazuje, jak mohou prefixová a postfixová forma vést k rozdílným výsledkům, když je použijeme v porovnání.
+Tato úloha ukazuje, jak může prefixová a postfixová notace vést k rozdílným výsledkům, když je použijeme v porovnání.
 
 1. **Od 1 do 4**
 

From 7e040faa3663972545fdb212cbed7d0effd1569c Mon Sep 17 00:00:00 2001
From: otmon76 <66325539+otmon76@users.noreply.github.com>
Date: Thu, 23 Jun 2022 20:32:10 +0200
Subject: [PATCH 19/22] Update
 1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Daniel Pomajbík <60559058+danipoma@users.noreply.github.com>
---
 .../02-first-steps/13-while-for/2-which-value-while/solution.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md b/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
index 95383503f..4e2db6db0 100644
--- a/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
+++ b/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
@@ -20,7 +20,7 @@ Tato úloha ukazuje, jak může prefixová a postfixová notace vést k rozdíln
     while (i++ < 5) alert( i );
     ```
 
-    První hodnota je opět `i = 1`. Postfixová forma `i++` zvýší `i` a pak vrátí *starou* hodnotu, takže porovnání `i++ < 5` se dívá na `i = 0` (na rozdíl od `++i < 5`).
+    První hodnota je opět `i = 1`. Postfixová notace `i++` zvýší `i` a pak vrátí *starou* hodnotu, takže porovnání `i++ < 5` se dívá na `i = 0` (na rozdíl od `++i < 5`).
 
     Avšak `alert` se volá odděleně. Je to další příkaz, který se spustí až po zvýšení a porovnání. Proto obdrží aktuální `i = 1`.
 

From 010b94b23cad02f7c6950a5e4cfbdd3b8351e2c2 Mon Sep 17 00:00:00 2001
From: otmon76 <66325539+otmon76@users.noreply.github.com>
Date: Thu, 23 Jun 2022 20:32:18 +0200
Subject: [PATCH 20/22] Update
 1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Daniel Pomajbík <60559058+danipoma@users.noreply.github.com>
---
 .../02-first-steps/13-while-for/2-which-value-while/solution.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md b/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
index 4e2db6db0..041b86dd9 100644
--- a/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
+++ b/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
@@ -26,6 +26,6 @@ Tato úloha ukazuje, jak může prefixová a postfixová notace vést k rozdíln
 
     Následují `2, 3, 4…`
 
-    Zastavme se u `i = 4`. Prefixová forma `++i` by je zvýšila a v porovnání by použila `5`. Tady však máme postfixovou formu `i++`. Ta zvýší `i` na `5`, ale vrátí starou hodnotu. Proto se provede porovnání `while(4 < 5)` -- pravda, tudíž řízení přejde k `alert`.
+    Zastavme se u `i = 4`. Prefixová notace `++i` by je zvýšila a v porovnání by použila `5`. Tady však máme postfixovou notaci `i++`. Ta zvýší `i` na `5`, ale vrátí starou hodnotu. Proto se provede porovnání `while(4 < 5)` -- pravda, tudíž řízení přejde k `alert`.
 
     Hodnota `i = 5` je poslední, jelikož další krok `while(5 < 5)` dává nepravdu.

From 5d9d5ff9923160585d3e5babe16df2ccf2c96a61 Mon Sep 17 00:00:00 2001
From: otmon76 <66325539+otmon76@users.noreply.github.com>
Date: Thu, 23 Jun 2022 20:32:28 +0200
Subject: [PATCH 21/22] Update
 1-js/02-first-steps/13-while-for/2-which-value-while/task.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Daniel Pomajbík <60559058+danipoma@users.noreply.github.com>
---
 1-js/02-first-steps/13-while-for/2-which-value-while/task.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/1-js/02-first-steps/13-while-for/2-which-value-while/task.md b/1-js/02-first-steps/13-while-for/2-which-value-while/task.md
index f26ed31a8..8aa466ea0 100644
--- a/1-js/02-first-steps/13-while-for/2-which-value-while/task.md
+++ b/1-js/02-first-steps/13-while-for/2-which-value-while/task.md
@@ -8,8 +8,7 @@ Pro oba cykly si zapište hodnoty, které budou vypsány, a pak je porovnejte s
 
 Vypíše `alert` v obou cyklech stejné hodnoty, nebo ne?
 
-1. Prefixová forma `++i`:
-
+1. Prefixová notace `++i`:
     ```js
     let i = 0;
     while (++i < 5) alert( i );

From f8fe05a7b4ac9f7b45eb07ba085a184e475c1c1f Mon Sep 17 00:00:00 2001
From: otmon76 <66325539+otmon76@users.noreply.github.com>
Date: Thu, 23 Jun 2022 20:32:34 +0200
Subject: [PATCH 22/22] Update
 1-js/02-first-steps/13-while-for/2-which-value-while/task.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Daniel Pomajbík <60559058+danipoma@users.noreply.github.com>
---
 1-js/02-first-steps/13-while-for/2-which-value-while/task.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/13-while-for/2-which-value-while/task.md b/1-js/02-first-steps/13-while-for/2-which-value-while/task.md
index 8aa466ea0..3a7fff489 100644
--- a/1-js/02-first-steps/13-while-for/2-which-value-while/task.md
+++ b/1-js/02-first-steps/13-while-for/2-which-value-while/task.md
@@ -13,7 +13,7 @@ Vypíše `alert` v obou cyklech stejné hodnoty, nebo ne?
     let i = 0;
     while (++i < 5) alert( i );
     ```
-2. Postfixová forma `i++`
+2. Postfixová notace `i++`
 
     ```js
     let i = 0;