Jun 4, 2025 · Mar 2, 2025 · Mar 19, 2025
diff --git a/1-js/11-async/03-promise-chaining/01-then-vs-catch/solution.md b/1-js/11-async/03-promise-chaining/01-then-vs-catch/solution.md
 The short answer is: **no, they are not equal**:
 Stručná odpověď zní: **ne, nejsou ekvivalentní**:

 The difference is that if an error happens in`f1`, then it is handled by`.catch` here:
 Rozdíl je v tom, že pokud ve`f1` nastane chyba, je zde ošetřena funkcí`.catch`:

 ```js run
 promise
 příslib
  .then(f1)
  .catch(f2);
 ```

 ...But not here:
 ...Ale zde ne:

 ```js run
 promise
 příslib
  .then(f1, f2);
 ```

 That's because an error is passed down the chain, and in the second code piece there's no chain below`f1`.
 Je to proto, že chyba je předána řetězem, ale ve druhém uvedeném kódu za`f1` žádný řetěz není.

 In other words, `.then`passes results/errors to the next `.then/catch`.So in the first example, there's a`catch` below, and in the second one there isn't, so the error is unhandled.
 Jinými slovy, `.then`předá výsledky nebo chyby dalšímu `.then/catch`.V prvním příkladu je za ním`catch`, ale ve druhém není, takže chyba zůstane neošetřena.
diff --git a/1-js/11-async/03-promise-chaining/01-then-vs-catch/task.md b/1-js/11-async/03-promise-chaining/01-then-vs-catch/task.md
 #Promise: thenversus catch
 #Příslib: thenoproti catch

 Are these code fragments equal? In other words, do they behave the same way in any circumstances, for any handler functions?
 Jsou tyto fragmenty kódu ekvivalentní? Jinými slovy, chovají se zcela stejně za každých okolností a pro jakékoli handlery?

 ```js
 promise.then(f1).catch(f2);
 příslib.then(f1).catch(f2);
 ```

 Versus:
 Oproti:

 ```js
 promise.then(f1, f2);
 příslib.then(f1, f2);
 ```
diff --git a/1-js/11-async/03-promise-chaining/article.md b/1-js/11-async/03-promise-chaining/article.md
diff --git a/1-js/11-async/03-promise-chaining/head.html b/1-js/11-async/03-promise-chaining/head.html
 <script>
 functionloadScript(src) {
 functionnačtiSkript(src) {
  return new Promise(function(resolve, reject) {
    letscript = document.createElement('script');
 script.src = src;
    letskript = document.createElement('script');
 skript.src = src;

 script.onload = () => resolve(script);
 script.onerror = () => reject(new Error("Script load error: " + src));
 skript.onload = () => resolve(skript);
 skript.onerror = () => reject(new Error("Chyba při načítání skriptu: " + src));

    document.head.append(script);
    document.head.append(skript);
  });
 }
 </script>
diff --git a/1-js/11-async/03-promise-chaining/one.js b/1-js/11-async/03-promise-chaining/one.js
 functionone() {
 functionjedna() {
  alert(1);
 }
diff --git a/1-js/11-async/03-promise-chaining/promise-handler-variants.svg b/1-js/11-async/03-promise-chaining/promise-handler-variants.svg
Original file line number	Diff line number	Diff line change
		@@ -1,20 +1,20 @@
		The short answer is: no, they are not equal:
		Stručná odpověď zní: ne, nejsou ekvivalentní:

		The difference is that if an error happens in`f1`, then it is handled by`.catch` here:
		Rozdíl je v tom, že pokud ve`f1` nastane chyba, je zde ošetřena funkcí`.catch`:

		```js run
		promise
		příslib
		.then(f1)
		.catch(f2);
		```

		...But not here:
		...Ale zde ne:

		```js run
		promise
		příslib
		.then(f1, f2);
		```

		That's because an error is passed down the chain, and in the second code piece there's no chain below`f1`.
		Je to proto, že chyba je předána řetězem, ale ve druhém uvedeném kódu za`f1` žádný řetěz není.

		In other words, `.then`passes results/errors to the next `.then/catch`.So in the first example, there's a`catch` below, and in the second one there isn't, so the error is unhandled.
		Jinými slovy, `.then`předá výsledky nebo chyby dalšímu `.then/catch`.V prvním příkladu je za ním`catch`, ale ve druhém není, takže chyba zůstane neošetřena.
Original file line number	Diff line number	Diff line change
		@@ -1,13 +1,13 @@
		#Promise: thenversus catch
		#Příslib: thenoproti catch

		Are these code fragments equal? In other words, do they behave the same way in any circumstances, for any handler functions?
		Jsou tyto fragmenty kódu ekvivalentní? Jinými slovy, chovají se zcela stejně za každých okolností a pro jakékoli handlery?

		```js
		promise.then(f1).catch(f2);
		příslib.then(f1).catch(f2);
		```

		Versus:
		Oproti:

		```js
		promise.then(f1, f2);
		příslib.then(f1, f2);
		```
Original file line number	Diff line number	Diff line change
		@@ -1,13 +1,13 @@
		<script>
		functionloadScript(src) {
		functionnačtiSkript(src) {
		return new Promise(function(resolve, reject) {
		letscript = document.createElement('script');
		script.src = src;
		letskript = document.createElement('script');
		skript.src = src;

		script.onload = () => resolve(script);
		script.onerror = () => reject(new Error("Script load error: " + src));
		skript.onload = () => resolve(skript);
		skript.onerror = () => reject(new Error("Chyba při načítání skriptu: " + src));

		document.head.append(script);
		document.head.append(skript);
		});
		}
		</script>
Expand Down