Jun 3, 2025 · Feb 6, 2025
diff --git a/...advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/solution.md b/...advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/solution.md

 Using `setInterval`:
 Pomocí `setInterval`:

 ```js run
 functionprintNumbers(from, to) {
  letcurrent =from;
 functionvypišČísla(začátek, konec) {
  letaktuální =začátek;

  lettimerId = setInterval(function() {
    alert(current);
    if (current ==to) {
      clearInterval(timerId);
  letidČasovače = setInterval(function() {
    alert(aktuální);
    if (aktuální ==konec) {
      clearInterval(idČasovače);
    }
 current++;
 aktuální++;
  }, 1000);
 }

 //usage:
 printNumbers(5, 10);
 //použití:
 vypišČísla(5, 10);
 ```

 Using nested `setTimeout`:
 Pomocí vnořeného `setTimeout`:


 ```js run
 functionprintNumbers(from, to) {
  letcurrent =from;
 functionvypišČísla(začátek, konec) {
  letaktuální =začátek;

  setTimeout(functiongo() {
    alert(current);
    if (current <to) {
      setTimeout(go, 1000);
  setTimeout(functionspusť() {
    alert(aktuální);
    if (aktuální <konec) {
      setTimeout(spusť, 1000);
    }
 current++;
 aktuální++;
  }, 1000);
 }

 //usage:
 printNumbers(5, 10);
 //použití:
 vypišČísla(5, 10);
 ```

 Note that in both solutions, there is an initial delay before the first output. The function is called after `1000ms` the first time.
 Všimněte si, že v obou řešeních je úvodní prodleva před prvním výstupem. Funkce je poprvé volána za `1000 ms`.

 If we also want the function to run immediately, then we can add an additional call on a separate line, like this:
 Jestliže chceme, aby se funkce spustila okamžitě, můžeme přidat další volání na samostatný řádek, například takto:

 ```js run
 functionprintNumbers(from, to) {
  letcurrent =from;
 functionvypišČísla(začátek, konec) {
  letaktuální =začátek;

  functiongo() {
    alert(current);
    if (current ==to) {
      clearInterval(timerId);
  functionspusť() {
    alert(aktuální);
    if (aktuální ==konec) {
      clearInterval(idČasovače);
    }
 current++;
 aktuální++;
  }

 *!*
 go();
 spusť();
 */!*
  lettimerId = setInterval(go, 1000);
  letidČasovače = setInterval(spusť, 1000);
 }

 printNumbers(5, 10);
 vypišČísla(5, 10);
 ```
diff --git a/.../06-advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/task.md b/.../06-advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/task.md

 ---

 #Output every second
 #Výstup každou sekundu

 Write a function `printNumbers(from, to)` that outputs a number every second, starting from `from` and ending with `to`.
 Napište funkci `vypišČísla(začátek, konec)`, která každou sekundu vypíše číslo, přičemž začne číslem `začátek` a skončí číslem `konec`.

 Make two variants of the solution.
 Vytvořte dvě varianty řešení.

 1.Using `setInterval`.
 2.Using nested `setTimeout`.
 1.Pomocí `setInterval`.
 2.Pomocí vnořeného `setTimeout`.
diff --git a/...06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/solution.md b/...06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/solution.md

 Any `setTimeout`will run only after the current code has finished.
 Každý `setTimeout`se spustí teprve po dokončení aktuálního kódu.

 The `i`will be the last one: `100000000`.
 Proměnná `i`bude obsahovat poslední hodnotu: `100000000`.

 ```js run
 let i = 0;

 setTimeout(() => alert(i), 100); // 100000000

 //assume that the time to execute this function is >100ms
 //předpokládáme, že doba běhu této funkce je větší než 100 ms
 for(let j = 0; j < 100000000; j++) {
  i++;
 }
diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/task.md b/1-js/06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/task.md

 ---

 #What will setTimeout show?
 #Co zobrazí setTimeout?

 In the code below there's a `setTimeout` call scheduled, then a heavy calculation is run, that takes more than 100ms to finish.
 V následujícím kódu je načasováno volání `setTimeout`, pak proběhne náročný výpočet, jehož dokončení bude trvat více než 100 ms.

 When will the scheduled function run?
 Kdy se načasovaná funkce spustí?

 1.After the loop.
 2.Before the loop.
 3.In the beginning of the loop.
 1.Po cyklu.
 2.Před cyklem.
 3.Na začátku cyklu.


 What is `alert` going to show?
 Co zobrazí `alert`?

 ```js
 let i = 0;

 setTimeout(() => alert(i), 100); // ?

 //assume that the time to execute this function is >100ms
 //předpokládáme, že doba výkonu této funkce je větší než 100 ms
 for(let j = 0; j < 100000000; j++) {
  i++;
 }
Original file line number	Diff line number	Diff line change
		@@ -1,64 +1,64 @@

		Using `setInterval`:
		Pomocí `setInterval`:

		```js run
		functionprintNumbers(from, to) {
		letcurrent =from;
		functionvypišČísla(začátek, konec) {
		letaktuální =začátek;

		lettimerId = setInterval(function() {
		alert(current);
		if (current ==to) {
		clearInterval(timerId);
		letidČasovače = setInterval(function() {
		alert(aktuální);
		if (aktuální ==konec) {
		clearInterval(idČasovače);
		}
		current++;
		aktuální++;
		}, 1000);
		}

		//usage:
		printNumbers(5, 10);
		//použití:
		vypišČísla(5, 10);
		```

		Using nested `setTimeout`:
		Pomocí vnořeného `setTimeout`:


		```js run
		functionprintNumbers(from, to) {
		letcurrent =from;
		functionvypišČísla(začátek, konec) {
		letaktuální =začátek;

		setTimeout(functiongo() {
		alert(current);
		if (current <to) {
		setTimeout(go, 1000);
		setTimeout(functionspusť() {
		alert(aktuální);
		if (aktuální <konec) {
		setTimeout(spusť, 1000);
		}
		current++;
		aktuální++;
		}, 1000);
		}

		//usage:
		printNumbers(5, 10);
		//použití:
		vypišČísla(5, 10);
		```

		Note that in both solutions, there is an initial delay before the first output. The function is called after `1000ms` the first time.
		Všimněte si, že v obou řešeních je úvodní prodleva před prvním výstupem. Funkce je poprvé volána za `1000 ms`.

		If we also want the function to run immediately, then we can add an additional call on a separate line, like this:
		Jestliže chceme, aby se funkce spustila okamžitě, můžeme přidat další volání na samostatný řádek, například takto:

		```js run
		functionprintNumbers(from, to) {
		letcurrent =from;
		functionvypišČísla(začátek, konec) {
		letaktuální =začátek;

		functiongo() {
		alert(current);
		if (current ==to) {
		clearInterval(timerId);
		functionspusť() {
		alert(aktuální);
		if (aktuální ==konec) {
		clearInterval(idČasovače);
		}
		current++;
		aktuální++;
		}

		!
		go();
		spusť();
		/!
		lettimerId = setInterval(go, 1000);
		letidČasovače = setInterval(spusť, 1000);
		}

		printNumbers(5, 10);
		vypišČísla(5, 10);
		```
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,11 +2,11 @@ importance: 5

		---

		#Output every second
		#Výstup každou sekundu

		Write a function `printNumbers(from, to)` that outputs a number every second, starting from `from` and ending with `to`.
		Napište funkci `vypišČísla(začátek, konec)`, která každou sekundu vypíše číslo, přičemž začne číslem `začátek` a skončí číslem `konec`.

		Make two variants of the solution.
		Vytvořte dvě varianty řešení.

		1.Using `setInterval`.
		2.Using nested `setTimeout`.
		1.Pomocí `setInterval`.
		2.Pomocí vnořeného `setTimeout`.
Original file line number	Diff line number	Diff line change
		@@ -1,14 +1,14 @@

		Any `setTimeout`will run only after the current code has finished.
		Každý `setTimeout`se spustí teprve po dokončení aktuálního kódu.

		The `i`will be the last one: `100000000`.
		Proměnná `i`bude obsahovat poslední hodnotu: `100000000`.

		```js run
		let i = 0;

		setTimeout(() => alert(i), 100); // 100000000

		//assume that the time to execute this function is >100ms
		//předpokládáme, že doba běhu této funkce je větší než 100 ms
		for(let j = 0; j < 100000000; j++) {
		i++;
		}
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,25 +2,25 @@ importance: 5

		---

		#What will setTimeout show?
		#Co zobrazí setTimeout?

		In the code below there's a `setTimeout` call scheduled, then a heavy calculation is run, that takes more than 100ms to finish.
		V následujícím kódu je načasováno volání `setTimeout`, pak proběhne náročný výpočet, jehož dokončení bude trvat více než 100 ms.

		When will the scheduled function run?
		Kdy se načasovaná funkce spustí?

		1.After the loop.
		2.Before the loop.
		3.In the beginning of the loop.
		1.Po cyklu.
		2.Před cyklem.
		3.Na začátku cyklu.


		What is `alert` going to show?
		Co zobrazí `alert`?

		```js
		let i = 0;

		setTimeout(() => alert(i), 100); // ?

		//assume that the time to execute this function is >100ms
		//předpokládáme, že doba výkonu této funkce je větší než 100 ms
		for(let j = 0; j < 100000000; j++) {
		i++;
		}
Expand Down