You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Asynchronous iteration allow us to iterate over data that comes asynchronously, on-demand. Like, for instance, when we download something chunk-by-chunk over a network. And asynchronous generators make it even more convenient.
4
+
Asynchronní iterace nám umožňuje iterovat nad daty, která přicházejí asynchronně, na požádání. Například když něco stahujeme po částech ze sítě. A asynchronní generátory nám to ještě usnadňují.
5
5
6
-
Let's see a simple example first, to grasp the syntax, and then review a real-life use case.
6
+
Nejprve se podíváme na jednoduchý příklad, abychom pochopili syntaxi, a pak si prohlédneme případ použití z reálného života.
7
7
8
-
## Recall iterables
8
+
## Připomínka iterovatelných objektů
9
9
10
-
Let's recall the topic about iterables.
10
+
Připomeňme si téma iterovatelných objektů.
11
11
12
-
The idea is that we have an object, such as `range` here:
12
+
Myšlenkou je, že máme objekt, například `rozsah` zde:
13
13
```js
14
-
letrange= {
15
-
from:1,
16
-
to:5
14
+
letrozsah= {
15
+
začátek:1,
16
+
konec:5
17
17
};
18
18
```
19
19
20
-
...And we'd like to use `for..of` loop on it, such as `for(value of range)`, to get values from `1`to`5`.
20
+
...A rádi bychom nad ním používali cyklus `for..of`, např. `for(hodnota of rozsah)`, kterým budeme získávat hodnoty od `1`do`5`.
21
21
22
-
In other words, we want to add an *iteration ability* to the object.
22
+
Jinými slovy, chceme přidat objektu *schopnost iterace*.
23
23
24
-
That can be implemented using a special method with the name`Symbol.iterator`:
24
+
To můžeme implementovat pomocí speciální metody s názvem`Symbol.iterator`:
25
25
26
-
-This method is called in by the `for..of` construct when the loop is started, and it should return an object with the `next` method.
27
-
-For each iteration, the `next()`method is invoked for the next value.
28
-
-The`next()`should return a value in the form `{done: true/false, value:<loop value>}`, where`done:true`means the end of the loop.
26
+
-Tato metoda je volána konstruktem `for..of`, když je cyklus zahájen, a měla by vrátit objekt obsahující metodu `next`.
27
+
-Při každé iteraci je metoda `next()`volána pro další hodnotu.
28
+
-Metoda`next()`by měla vrátit hodnotu ve tvaru `{done: true/false, value:<hodnota cyklu>}`, kde`done:true`znamená konec cyklu.
29
29
30
-
Here's an implementation for the iterable `range`:
30
+
Zde je implementace iterovatelného objektu `rozsah`:
31
31
32
32
```js run
33
-
letrange= {
34
-
from:1,
35
-
to:5,
33
+
letrozsah= {
34
+
začátek:1,
35
+
konec:5,
36
36
37
37
*!*
38
-
[Symbol.iterator]() { //called once, in the beginning of for..of
38
+
[Symbol.iterator]() { //voláno jednou, na začátku for..of
39
39
*/!*
40
40
return {
41
-
current:this.from,
42
-
last:this.to,
41
+
aktuální:this.začátek,
42
+
poslední:this.konec,
43
43
44
44
*!*
45
-
next() { //called every iteration, to get the next value
45
+
next() { //voláno při každé iteraci pro získání další hodnoty
46
46
*/!*
47
-
if (this.current<=this.last) {
48
-
return { done:false, value:this.current++ };
47
+
if (this.aktuální<=this.poslední) {
48
+
return { done:false, value:this.aktuální++ };
49
49
} else {
50
50
return { done:true };
51
51
}
@@ -54,54 +54,54 @@ let range = {
54
54
}
55
55
};
56
56
57
-
for(letvalueofrange) {
58
-
alert(value); // 1 then 2, then 3, then 4, then 5
57
+
for(lethodnotaofrozsah) {
58
+
alert(hodnota); // 1, pak 2, pak 3, pak 4, pak 5
59
59
}
60
60
```
61
61
62
-
If anything is unclear, please visit the chapter [](info:iterable), it gives all the details about regular iterables.
62
+
Pokud vám něco není jasné, prosíme navštivte kapitolu [](info:iterable), která vysvětluje všechny podrobnosti o běžných iterovatelných objektech.
63
63
64
-
## Async iterables
64
+
## Asynchronní iterovatelné objekty
65
65
66
-
Asynchronous iteration is needed when values come asynchronously: after`setTimeout`or another kind of delay.
66
+
Asynchronní iteraci potřebujeme, když hodnoty přicházejí asynchronně: po`setTimeout`nebo prodlevě jiného druhu.
67
67
68
-
The most common case is that the object needs to make a network request to deliver the next value, we'll see a real-life example of it a bit later.
68
+
Nejběžnějším případem je, že objekt potřebuje k doručení další hodnoty vytvořit síťový požadavek. Příklad z reálného života uvidíme o něco později.
2.Metoda`next()`by měla vrátit příslib (aby byl splněn další hodnotou).
74
+
-Zajistí to klíčové slovo `async`. Můžeme jednoduše vytvořit`async next()`.
75
+
3.K iteraci nad takovým objektem bychom měli používat cyklus `for await (let prvek of iterovatelnýObjekt)`.
76
+
-Všimněte si slova `await`.
77
77
78
-
As a starting example, let's make an iterable `range` object, similar like the one before, but now it will return values asynchronously, one per second.
78
+
Jako počáteční příklad vytvořme iterovatelný objekt `rozsah`. Bude podobný tomu předchozímu, ale nyní bude vracet hodnoty asynchronně, jednu za sekundu.
79
79
80
-
All we need to do is to perform a few replacements in the code above:
80
+
Vše, co musíme udělat, je provést několik náhrad ve výše uvedeném kódu:
As we can see, the structure is similar to regular iterators:
124
+
Jak vidíme, tato struktura se podobá obyčejným iterátorům:
125
125
126
-
1.To make an object asynchronously iterable, it must have a method`Symbol.asyncIterator``(1)`.
127
-
2.This method must return the object with`next()` method returning a promise`(2)`.
128
-
3.The`next()`method doesn't have to be `async`, it may be a regular method returning a promise, but`async`allows us to use `await`, so that's convenient. Here we just delay for a second`(3)`.
129
-
4.To iterate, we use `for await(let value of range)``(4)`, namely add "await" after "for". It calls `range[Symbol.asyncIterator]()`once, and then its `next()` for values.
126
+
1.Abychom učinili objekt asynchronně iterovatelným, musí obsahovat metodu`Symbol.asyncIterator``(1)`.
127
+
2.Tato metoda musí vracet objekt s metodou`next()`, která vrací příslib`(2)`.
128
+
3.Metoda`next()`nemusí být `async`, může to být běžná metoda vracející příslib, ale`async`nám umožňuje použít `await`, takže je vhodné. Zde prostě sekundu počkáme`(3)`.
129
+
4.K iteraci použijeme `for await(let hodnota of rozsah)``(4)`, jmenovitě přidáme „await“ za „for“. Tento cyklus jedenkrát volá `rozsah[Symbol.asyncIterator]()`a pak pro získávání hodnot volá jeho `next()`.
130
130
131
-
Here's a small table with the differences:
131
+
Uvedeme malou tabulku s rozdíly:
132
132
133
-
||Iterators|Async iterators|
133
+
||Iterátory|Asynchronní iterátory|
134
134
|-------|-----------|-----------------|
135
-
| Object method to provide iterator|`Symbol.iterator`|`Symbol.asyncIterator`|
136
-
|`next()`return value is| any value|`Promise`|
137
-
|to loop, use|`for..of`|`for await..of`|
135
+
Objektová metoda, která poskytne iterátor | `Symbol.iterator` | `Symbol.asyncIterator` |
136
+
|Návratová hodnota `next()`je | libovolná hodnota|`Promise`|
137
+
|K iteraci se používá|`for..of`|`for await..of`|
138
138
139
-
````warn header="The spread syntax `...`doesn't work asynchronously"
140
-
Features that require regular, synchronous iterators, don't work with asynchronous ones.
Prvky jazyka, které vyžadují obvyklé, synchronní iterátory, nefungují s asynchronními.
141
141
142
-
For instance, a spread syntax won't work:
142
+
Nebude fungovat například roztažená syntaxe:
143
143
```js
144
-
alert( [...range] ); //Error, no Symbol.iterator
144
+
alert( [...rozsah] ); //Chyba, není Symbol.iterator
145
145
```
146
146
147
-
That's natural, as it expects to find `Symbol.iterator`, not`Symbol.asyncIterator`.
147
+
To je přirozené, protože ta očekává `Symbol.iterator`, ne`Symbol.asyncIterator`.
148
148
149
-
It's also the case for`for..of`: the syntax without `await`needs`Symbol.iterator`.
149
+
To je také případ cyklu`for..of`: syntaxe bez `await`potřebuje`Symbol.iterator`.
150
150
````
151
151
152
-
## Recall generators
152
+
## Připomínka generátorů
153
153
154
-
Now let's recall generators, as they allow to make iteration code much shorter. Most of the time, when we'd like to make an iterable, we'll use generators.
154
+
Nyní si připomeňme generátory, protože ty nám umožňují iterační kód značně zkrátit. Když bychom rádi vytvořili iterovatelný objekt, většinou použijeme generátory.
155
155
156
-
For sheer simplicity, omitting some important stuff, they are "functions that generate (yield) values". They are explained in detail in the chapter [](info:generators).
156
+
Pro zjednodušení, když vypustíme některé důležité věci, to jsou „funkce, které generují (vydávají) hodnoty“. Jsou podrobně vysvětleny v kapitole [](info:generators).
157
157
158
-
Generators are labelled with `function*` (note the star) and use `yield` to generate a value, then we can use `for..of` to loop over them.
158
+
Generátory jsou označeny jako `function*` (všimněte si hvězdičky) a ke generování hodnot používají `yield`. Pak nad nimi můžeme procházet cyklem `for..of`.
159
159
160
-
This example generates a sequence of values from `start` to `end`:
160
+
Tento příklad generuje posloupnost hodnot od `začátek` po `konec`:
161
161
162
162
```js run
163
-
function* generateSequence(start, end) {
164
-
for (let i = start; i <= end; i++) {
163
+
function* generujPosloupnost(začátek, konec) {
164
+
for (let i = začátek; i <= konec; i++) {
165
165
yield i;
166
166
}
167
167
}
168
168
169
-
for(let value of generateSequence(1, 5)) {
170
-
alert(value); // 1, then 2, then 3, then 4, then 5
169
+
for(let hodnota of generujPosloupnost(1, 5)) {
170
+
alert(hodnota); // 1, pak 2, pak 3, pak 4, pak 5
171
171
}
172
172
```
173
173
174
-
As we already know, to make an object iterable, we should add `Symbol.iterator` to it.
174
+
Jak už víme, abychom učinili objekt iterovatelným, měli bychom do něj přidat `Symbol.iterator`.
175
175
176
176
```js
177
-
let range = {
178
-
from: 1,
179
-
to: 5,
177
+
let rozsah = {
178
+
začátek: 1,
179
+
konec: 5,
180
180
*!*
181
181
[Symbol.iterator]() {
182
-
return <object with next to make range iterable>
182
+
return <objekt s metodou next, aby rozsah byl iterovatelný>
183
183
}
184
184
*/!*
185
185
}
186
186
```
187
187
188
-
A common practice for `Symbol.iterator` is to return a generator, it makes the code shorter, as you can see:
188
+
Běžnou praxí pro `Symbol.iterator` je vrátit generátor, tím se kód zkrátí, jak vidíte:
189
189
190
190
```js run
191
-
let range = {
192
-
from: 1,
193
-
to: 5,
191
+
let rozsah = {
192
+
začátek: 1,
193
+
konec: 5,
194
194
195
-
*[Symbol.iterator]() { // a shorthand for [Symbol.iterator]: function*()
196
-
for(let value = this.from; value <= this.to; value++) {
197
-
yield value;
195
+
*[Symbol.iterator]() { // zkratka pro [Symbol.iterator]: function*()
196
+
for(let hodnota = this.začátek; hodnota <= this.konec; hodnota++) {
197
+
yield hodnota;
198
198
}
199
199
}
200
200
};
201
201
202
-
for(let value of range) {
203
-
alert(value); // 1, then 2, then 3, then 4, then 5
202
+
for(let hodnota of rozsah) {
203
+
alert(hodnota); // 1, pak 2, pak 3, pak 4, pak 5
204
204
}
205
205
```
206
206
207
-
Please see the chapter [](info:generators) if you'd like more details.
207
+
Pokud by vás zajímaly další podrobnosti, přečtěte si prosíme kapitolu [](info:generators).
208
208
209
-
In regular generators we can't use `await`. All values must come synchronously, as required by the `for..of` construct.
209
+
V obyčejných generátorech nemůžeme používat `await`. Všechny hodnoty musejí přicházet synchronně, jak vyžaduje konstrukt `for..of`.
210
210
211
-
What if we'd like to generate values asynchronously? From network requests, for instance.
211
+
Co kdybychom chtěli generovat hodnoty asynchronně, například ze síťových požadavků?
212
212
213
-
Let's switch to asynchronous generators to make it possible.
213
+
Přejděme k asynchronním generátorům, které nám to umožní.
214
214
215
-
## Async generators (finally)
215
+
## Asynchronní generátory (konečně)
216
216
217
-
For most practical applications, when we'd like to make an object that asynchronously generates a sequence of values, we can use an asynchronous generator.
217
+
Když chceme vytvořit objekt, který asynchronně generuje posloupnost hodnot, ve většině praktických aplikací můžeme použít asynchronní generátor.
218
218
219
-
The syntax is simple: prepend `function*` with `async`. That makes the generator asynchronous.
219
+
Syntaxe je jednoduchá: před `function*` uvedeme `async`. To učiní generátor asynchronním.
220
220
221
-
And then use `for await (...)` to iterate over it, like this:
221
+
A pak k iteraci nad ním použijeme `for await (...)`, například:
await new Promise(resolve => setTimeout(resolve, 1000));
229
+
// Hurá, můžeme použít await!
230
+
await new Promise(splň => setTimeout(splň, 1000));
231
231
*/!*
232
232
233
233
yield i;
@@ -237,181 +237,181 @@ And then use `for await (...)` to iterate over it, like this:
237
237
238
238
(async () => {
239
239
240
-
let generator = generateSequence(1, 5);
241
-
for *!*await*/!* (let value of generator) {
242
-
alert(value); // 1, then 2, then 3, then 4, then 5 (with delay between)
240
+
let generátor = generujPosloupnost(1, 5);
241
+
for *!*await*/!* (let hodnota of generátor) {
242
+
alert(hodnota); // 1, pak 2, pak 3, pak 4, pak 5 (s prodlevou mezi nimi)
243
243
}
244
244
245
245
})();
246
246
```
247
247
248
-
As the generator is asynchronous, we can use `await` inside it, rely on promises, perform network requests and so on.
248
+
Jelikož je generátor asynchronní, můžeme uvnitř něj používat `await`, spoléhat se na přísliby, provádět síťové požadavky a podobně.
249
249
250
-
````smart header="Under-the-hood difference"
251
-
Technically, if you're an advanced reader who remembers the details about generators, there's an internal difference.
250
+
````smart header="Rozdíl pod kapotou"
251
+
Jestliže jste pokročilý čtenář a pamatujete si podrobnosti o generátorech, je tady technicky vnitřní rozdíl.
252
252
253
-
For async generators, the `generator.next()` method is asynchronous, it returns promises.
253
+
U asynchronních generátorů je metoda `generátor.next()` asynchronní, vrací přísliby.
254
254
255
-
In a regular generator we'd use `result = generator.next()` to get values. In an async generator, we should add `await`, like this:
255
+
V obyčejném generátoru bychom k získávání hodnot použili `výsledek = generator.next()`. V asynchronním generátoru bychom měli přidat `await`, například takto:
256
256
257
257
```js
258
-
result = await generator.next(); // result = {value: ..., done: true/false}
258
+
výsledek = await generator.next(); // výsledek = {value: ..., done: true/false}
259
259
```
260
-
That's why async generators work with `for await...of`.
260
+
Z tohoto důvodu asynchronní generátory fungují s `for await...of`.
261
261
````
262
262
263
-
### Async iterable range
263
+
### Asynchronní iterovatelný rozsah
264
264
265
-
Regular generators can be used as `Symbol.iterator`to make the iteration code shorter.
265
+
Jako `Symbol.iterator`můžeme používat obyčejné generátory, aby byl iterační kód kratší.
266
266
267
-
Similar to that, async generators can be used as `Symbol.asyncIterator`to implement the asynchronous iteration.
267
+
Obdobně můžeme jako `Symbol.asyncIterator`používat asynchronní generátory, abychom implementovali asynchronní iteraci.
268
268
269
-
For instance, we can make the `range` object generate values asynchronously, once per second, by replacing synchronous `Symbol.iterator`with asynchronous`Symbol.asyncIterator`:
269
+
Například můžeme přimět objekt `rozsah`, aby generoval hodnoty asynchronně, jednu za sekundu, nahrazením synchronního `Symbol.iterator`za asynchronní`Symbol.asyncIterator`:
270
270
271
271
```js run
272
-
letrange= {
273
-
from:1,
274
-
to:5,
272
+
letrozsah= {
273
+
začátek:1,
274
+
konec:5,
275
275
276
-
//this line is same as [Symbol.asyncIterator]: async function*() {
276
+
//tento řádek je totéž jako [Symbol.asyncIterator]: async function*() {
alert(value); // 1, then 2, then 3, then 4, then 5
292
+
for*!*await*/!* (lethodnotaofrozsah) {
293
+
alert(hodnota); // 1, pak 2, pak 3, pak 4, pak 5
294
294
}
295
295
296
296
})();
297
297
```
298
298
299
-
Now values come with a delay of 1 second between them.
299
+
Nyní hodnoty přicházejí s prodlevou 1 sekunda mezi sebou.
300
300
301
301
```smart
302
-
Technically, we can add both `Symbol.iterator` and `Symbol.asyncIterator` to the object, so it's both synchronously (`for..of`) and asynchronously (`for await..of`) iterable.
302
+
Technicky můžeme do objektu přidat `Symbol.iterator` i `Symbol.asyncIterator` současně, bude tedy iterovatelný jak synchronně (`for..of`), tak asynchronně (`for await..of`).
303
303
304
-
In practice though, that would be a weird thing to do.
304
+
V praxi by to však bylo podivné.
305
305
```
306
306
307
-
## Real-life example: paginated data
307
+
## Příklad z reálného života: stránkovaná data
308
308
309
-
So far we've seen basic examples, to gain understanding. Now let's review a real-life use case.
309
+
Dosud jsme viděli základní příklady, abychom tomu porozuměli. Nyní se podívejme na případ použití z reálného života.
310
310
311
-
There are many online services that deliver paginated data. For instance, when we need a list of users, a request returns a pre-defined count (e.g. 100 users) - "one page", and provides a URL to the next page.
311
+
Existuje mnoho online služeb, které doručují stránkovaná data. Například když potřebujeme seznam uživatelů, požadavek vrátí předdefinovaný počet (např. 100 uživatelů) -- „jednu stránku“ a poskytne URL další stránky.
312
312
313
-
This pattern is very common. It's not about users, but just about anything.
313
+
Tento vzorec je zcela běžný. Neplatí to jen pro uživatele, ale v zásadě pro cokoli.
314
314
315
-
For instance, GitHub allows us to retrieve commits in the same, paginated fashion:
315
+
Například GitHub nám umožňuje získávat commity stejným způsobem, po stránkách:
316
316
317
-
-We should make a request to `fetch`in the form `https://api.github.com/repos/<repo>/commits`.
318
-
-It responds with a JSON of 30 commits, and also provides a link to the next page in the `Link`header.
319
-
-Then we can use that link for the next request, to get more commits, and so on.
317
+
-Měli bychom vytvořit požadavek do `fetch`ve tvaru `https://api.github.com/repos/<úložiště>/commits`.
318
+
-GitHub odpoví JSONem se 30 commity a také nám v hlavičce `Link`poskytne odkaz na další stránku.
319
+
-Tento odkaz pak můžeme použít pro další požadavek, k získání dalších commitů, a tak dále.
320
320
321
-
For our code, we'd like to have a simpler way to get commits.
321
+
V našem kódu bychom rádi měli jednodušší způsob, jak získávat commity.
322
322
323
-
Let's make a function `fetchCommits(repo)` that gets commits for us, making requests whenever needed. And let it care about all pagination stuff. For us it'll be a simple async iteration`for await..of`.
323
+
Vytvořme funkci `stáhniCommity(úložiště)`, která nám bude načítat commity a bude vytvářet požadavky, kdykoli budou zapotřebí. A nechme ji, aby se postarala o všechny záležitosti ohledně stránkování. Pro nás to bude jednoduchá asynchronní iterace`for await..of`.
for(let commit ofbody) { // (4) yield commits one by one, until the page ends
352
+
for(let commit oftělo) { // (4) vydáme commity jeden po druhém, dokud stránka neskončí
353
353
yield commit;
354
354
}
355
355
}
356
356
}
357
357
```
358
358
359
-
More explanations about how it works:
359
+
Podrobnější vysvětlení, jak to funguje:
360
360
361
-
1. We use the browser [fetch](info:fetch) method to download the commits.
361
+
1. K načtení commitů používáme metodu prohlížeče [fetch](info:fetch).
362
362
363
-
- The initial URL is`https://api.github.com/repos/<repo>/commits`, and the next page will be in the `Link` header of the response.
364
-
-The`fetch`method allows us to supply authorization and other headers if needed --here GitHub requires`User-Agent`.
365
-
2.The commits are returned inJSON format.
366
-
3.We should get the next page URL from the `Link`header of the response. It has a special format, so we use a regular expression forthat (we will learn this feature in [Regular expressions](info:regular-expressions)).
367
-
-The next page URL may look like `https://api.github.com/repositories/93253246/commits?page=2`. It's generated by GitHub itself.
368
-
4. Then we yield the received commits one by one, and when they finish, the next `while(url)` iteration will trigger, making one more request.
363
+
- Úvodní URL je`https://api.github.com/repos/<úložiště>/commits` a další stránka bude v hlavičce odpovědi `Link`.
364
+
-Metoda`fetch`nám umožňuje poskytnout autorizaci a další hlavičky, pokud jsou zapotřebí --zde GitHub vyžaduje hlavičku`User-Agent`.
365
+
2.Commity jsou vráceny ve formátuJSON.
366
+
3.Z hlavičky `Link`odpovědi bychom měli získat URL další stránky. Hlavička má speciální formát, takže pro ni použijeme regulární výraz (o tomto prvku jazyka se dozvíme v kapitole [Regulární výrazy](info:regular-expressions)).
367
+
-URL další stránky může vypadat jako `https://api.github.com/repositories/93253246/commits?page=2`. Generuje je samotný GitHub.
368
+
4.Pak budeme vydávat získané commity jeden po druhém, a když dojdou, spustí se další iterace `while(url)`, která vytvoří další požadavek.
369
369
370
-
An example of use (shows commit authors in console):
370
+
Příklad použití (zobrazí na konzoli autory commitů):
371
371
372
372
```js run
373
373
(async () => {
374
374
375
-
let count = 0;
375
+
let počet = 0;
376
376
377
-
for await (const commit of fetchCommits('javascript-tutorial/en.javascript.info')) {
377
+
for await (const commit of stáhniCommity('javascript-tutorial/en.javascript.info')) {
378
378
379
379
console.log(commit.author.login);
380
380
381
-
if (++count == 100) { // let's stop at100commits
381
+
if (++počet == 100) { // zastavíme se po 100 commitech
382
382
break;
383
383
}
384
384
}
385
385
386
386
})();
387
387
388
-
//Note: If you are running this in an external sandbox, you'll need to paste here the function fetchCommits described above
388
+
// Poznámka: Pokud tohle spouštíte v externím pískovišti, musíte sem zkopírovat výše uvedenou funkci stáhniCommity
389
389
```
390
390
391
-
That's just what we wanted.
391
+
To je přesně to, co jsme chtěli.
392
392
393
-
The internal mechanics of paginated requests is invisible from the outside. For us it's just an async generator that returns commits.
393
+
Vnitřní mechaniky stránkovaných požadavků jsou zvnějšku neviditelné. Pro nás je to prostě jen asynchronní generátor, který vrací commity.
394
394
395
-
## Summary
395
+
## Shrnutí
396
396
397
-
Regular iterators and generators work fine with the data that doesn't take time to generate.
397
+
Obyčejné iterátory a generátory fungují dobře s daty, jejichž generování netrvá dlouhou dobu.
398
398
399
-
When we expect the data to come asynchronously, with delays, their async counterparts can be used, and `for await..of`instead of`for..of`.
399
+
Když očekáváme, že data budou přicházet asynchronně s prodlevami, můžeme použít jejich asynchronní protějšky a `for await..of`místo`for..of`.
400
400
401
-
Syntax differences between async and regular iterators:
401
+
Syntaktické rozdíly mezi asynchronními a běžnými iterátory:
402
402
403
-
||Iterable | Async Iterable|
403
+
||Iterovatelný objekt | Asynchronní iterovatelný objekt|
404
404
|-------|-----------|-----------------|
405
-
|Method to provide iterator|`Symbol.iterator`|`Symbol.asyncIterator`|
406
-
|`next()`return value is|`{value:…, done: true/false}`|`Promise` that resolves to`{value:…, done: true/false}`|
|Návratová hodnota `next()`je |`{value:…, done: true/false}`|`Promise`, který se splní s`{value:…, done: true/false}`|
407
407
408
-
Syntax differences between async and regular generators:
408
+
Syntaktické rozdíly mezi asynchronními a běžnými generátory:
409
409
410
-
||Generators|Async generators|
410
+
||Generátory|Asynchronní generátory|
411
411
|-------|-----------|-----------------|
412
-
|Declaration|`function*`|`async function*`|
413
-
|`next()`return value is|`{value:…, done: true/false}`|`Promise` that resolves to`{value:…, done: true/false}`|
412
+
|Deklarace|`function*`|`async function*`|
413
+
|Návratová hodnota `next()`je |`{value:…, done: true/false}`|`Promise`, který se splní s`{value:…, done: true/false}`|
414
414
415
-
In web-development we often meet streams of data, when it flows chunk-by-chunk. For instance, downloading or uploading a big file.
415
+
Při vývoji webů se často setkáváme s proudy dat, která přitékají po částech, například při stahování nebo odesílání velkého souboru.
416
416
417
-
We can use async generators to process such data. It's also noteworthy that in some environments, like in browsers, there's also another API called Streams, that provides special interfaces to work with such streams, to transform the data and to pass it from one stream to another (e.g. download from one place and immediately send elsewhere).
417
+
Ke zpracování takových dat můžeme používat asynchronní generátory. Stojí také za zmínku, že v některých prostředích, např. v prohlížečích, existuje i dalšíAPInazvané Streams, které poskytuje speciální rozhraní pro práci s takovými proudy (streamy), pro transformaci dat a jejich předávání z jednoho proudu do druhého (např. při stahování z jednoho místa a okamžitém odesílání jinam).
0 commit comments