JavaScript & Node.js Iterators Explained

Reiterating
JavaScript &
Node.js iterators
Luciano Mammino ( )
@loige
loige.link/iter RomaJS - June 16, 2021
1

How many ways do you
know to "do iteration" in
JavaScript & Node.js? 😰
@loige
3

for i / for...in / for...of
@loige
4

Array.forEach / Array.map / Array.flatMap
/ Array.reduce / Array.reduceRight /
Array.filter / Array.find /
Array.findIndex / Array.entries /
Array.values / Array.every / Array.some
@loige
6

Object.keys / Object.values /
Object.entries
@loige
7

Iterators / Generators
@loige
8

Spread operator
[...iterable]
@loige
9

Async iterators / Async generators
@loige
11

That was 28 diﬀerent concepts! 😳
@loige
13

📝AGENDA
Iteration protocols... What? Why?
Syntax review
Iteration protocols
Iterator protocol
Iterable protocol
Generator functions
Async iterator protocol
Async iterable protocol
Tips & tricks
@loige
14

Let me introduce myself...
@loige
15

I'm Luciano ( 🍕🍝) 👋
@loige
15

Senior Architect
@loige
15

Senior Architect
nodejsdp.link
Co-Author of Node.js Design Patterns 👉
@loige
15

Senior Architect
nodejsdp.link
Co-Author of Node.js Design Patterns 👉
Connect with me:

(blog)
(twitter)
(twitch)
(github)
loige.co
@loige
loige
lmammino
@loige
15

We are business focused
technologists that deliver.
| |
Accelerated Serverless AI as a Service Platform Modernisation
WE ARE HIRING: Do you want to ?
work with us
@loige 16

Iteration protocols
what? why? 🤔
@loige
An attempt at standardizing "iteration" behaviors
providing a consistent and interoperable API
Use for...of, for await...of and spread operator.
You can also create lazy iterators
You can also deal with async iteration
You can create your own custom iterators/iterables
17

const judokas = [
'Driulis Gonzalez Morales',
'Ilias Iliadis',
'Tadahiro Nomura',
'Anton Geesink',
'Teddy Riner',
'Ryoko Tani'
]
for (const judoka of judokas) {
console.log(judoka)
}
1
2
3
4
5
6
7
8
9
10
11
12
@loige
for...of
19

const judokas = [
'Ilias Iliadis',
'Tadahiro Nomura',
'Anton Geesink',
'Teddy Riner',
'Ryoko Tani'
]
console.log(judoka)
}
1
2
3
4
5
6
7
8
9
10
11
12
const judokas = [
'Ilias Iliadis',
'Tadahiro Nomura',
'Anton Geesink',
'Teddy Riner',
'Ryoko Tani'
]
1
2
3
4
5
6
7
8
9
10
console.log(judoka)
11
}
12
@loige
for...of
Driulis Gonzalez Morales
Ilias Iliadis
Tadahiro Nomura
Anton Geesink
Teddy Riner
Ryoko Tani
OUTPUT
19

const judokas = [
'Ilias Iliadis',
'Tadahiro Nomura',
'Anton Geesink',
'Teddy Riner',
'Ryoko Tani'
]
console.log(judoka)
}
1
2
3
4
5
6
7
8
9
10
11
12
const judokas = [
'Ilias Iliadis',
'Tadahiro Nomura',
'Anton Geesink',
'Teddy Riner',
'Ryoko Tani'
]
1
2
3
4
5
6
7
8
9
10
console.log(judoka)
11
}
12
}
const judokas = [
1
2
'Ilias Iliadis',
3
'Tadahiro Nomura',
4
'Anton Geesink',
5
'Teddy Riner',
6
'Ryoko Tani'
7
]
8
9
10
console.log(judoka)
11
12
@loige
for...of
Ilias Iliadis
Tadahiro Nomura
Anton Geesink
Teddy Riner
Ryoko Tani
OUTPUT
19

const judokas = [
'Ilias Iliadis',
'Tadahiro Nomura',
'Anton Geesink',
'Teddy Riner',
'Ryoko Tani'
]
console.log(judoka)
}
1
2
3
4
5
6
7
8
9
10
11
12
const judokas = [
'Ilias Iliadis',
'Tadahiro Nomura',
'Anton Geesink',
'Teddy Riner',
'Ryoko Tani'
]
1
2
3
4
5
6
7
8
9
10
console.log(judoka)
11
}
12
}
const judokas = [
1
2
'Ilias Iliadis',
3
'Tadahiro Nomura',
4
'Anton Geesink',
5
'Teddy Riner',
6
'Ryoko Tani'
7
]
8
9
10
console.log(judoka)
11
12
console.log(judoka)
const judokas = [
1
2
'Ilias Iliadis',
3
'Tadahiro Nomura',
4
'Anton Geesink',
5
'Teddy Riner',
6
'Ryoko Tani'
7
]
8
9
10
11
}
12
@loige
for...of
Ilias Iliadis
Tadahiro Nomura
Anton Geesink
Teddy Riner
Ryoko Tani
OUTPUT
19

const judokas = [
'Ilias Iliadis',
'Tadahiro Nomura',
'Anton Geesink',
'Teddy Riner',
'Ryoko Tani'
]
console.log(judoka)
}
1
2
3
4
5
6
7
8
9
10
11
12
const judokas = [
'Ilias Iliadis',
'Tadahiro Nomura',
'Anton Geesink',
'Teddy Riner',
'Ryoko Tani'
]
1
2
3
4
5
6
7
8
9
10
console.log(judoka)
11
}
12
}
const judokas = [
1
2
'Ilias Iliadis',
3
'Tadahiro Nomura',
4
'Anton Geesink',
5
'Teddy Riner',
6
'Ryoko Tani'
7
]
8
9
10
console.log(judoka)
11
12
console.log(judoka)
const judokas = [
1
2
'Ilias Iliadis',
3
'Tadahiro Nomura',
4
'Anton Geesink',
5
'Teddy Riner',
6
'Ryoko Tani'
7
]
8
9
10
11
}
12
const judokas = [
'Ilias Iliadis',
'Tadahiro Nomura',
'Anton Geesink',
'Teddy Riner',
'Ryoko Tani'
]
console.log(judoka)
}
1
2
3
4
5
6
7
8
9
10
11
12
@loige
for...of
Ilias Iliadis
Tadahiro Nomura
Anton Geesink
Teddy Riner
Ryoko Tani
OUTPUT
19

const judoka = 'Ryoko Tani'
for (const char of judoka) {
console.log(char)
}
1
2
3
4
5
@loige
for...of (with strings)
20

const judoka = 'Ryoko Tani'
for (const char of judoka) {
console.log(char)
}
1
2
3
4
5
@loige
for...of (with strings)
R
y
o
k
o
T
a
n
i
OUTPUT
20

const medals = new Set([
'gold',
'silver',
'bronze'
])
for (const medal of medals) {
console.log(medal)
}
1
2
3
4
5
6
7
8
9
@loige
for...of (with Set)
21

const medals = new Set([
'gold',
'silver',
'bronze'
])
for (const medal of medals) {
console.log(medal)
}
1
2
3
4
5
6
7
8
9
@loige
for...of (with Set)

gold
silver
bronze
OUTPUT
21

const medallists = new Map([
['Teddy Riner', 33],
['Driulis Gonzalez Morales', 16],
['Ryoko Tani', 16],
['Ilias Iliadis', 15]
])
for (const [judoka, medals] of medallists) {
console.log(`${judoka} has won ${medals} medals`)
}
1
2
3
4
5
6
7
8
9
10
@loige
for...of (with Map)
22

const medallists = new Map([
['Teddy Riner', 33],
['Driulis Gonzalez Morales', 16],
['Ryoko Tani', 16],
['Ilias Iliadis', 15]
])
}
1
2
3
4
5
6
7
8
9
10
@loige
for...of (with Map)
Teddy Riner has won 33 medals
Driulis Gonzalez Morales has won 16 medals
Ryoko Tani has won 16 medals
Ilias Iliadis has won 15 medals
OUTPUT
22

const medallists = {
'Teddy Riner': 33,
'Driulis Gonzalez Morales': 16,
'Ryoko Tani': 16,
'Ilias Iliadis': 15
}
for (const [judoka, medals] of Object.entries(medallists))
}
1
2
3
4
5
6
7
8
9
10
@loige
for...of (with object & Object.entries)
23

'Teddy Riner': 33,
'Ryoko Tani': 16,
'Ilias Iliadis': 15
}
for (const [judoka, medals] of Object.entries(medallists))
}
1
2
3
4
5
6
7
8
9
10
@loige
for...of (with object & Object.entries)
Teddy Riner has won 33 medals
Driulis Gonzalez Morales has won 16 medals
Ryoko Tani has won 16 medals
Ilias Iliadis has won 15 medals
OUTPUT
23

'Teddy Riner': 33,
'Ryoko Tani': 16,
'Ilias Iliadis': 15
}
}
1
2
3
4
5
6
7
8
9
10
@loige
for...of (with object literals)
24

'Teddy Riner': 33,
'Ryoko Tani': 16,
'Ilias Iliadis': 15
}
}
1
2
3
4
5
6
7
8
9
10
@loige
for...of (with object literals)
^
TypeError: medallists is not iterable
at Object. (.../05-for-of-object.js:8:32)
ERROR
24

const countdown = [3, 2, 1, 0]
// spread into array
const from5to0 = [5, 4, ...countdown]
console.log(from5to0) // [ 5, 4, 3, 2, 1, 0 ]
// spread function arguments
console.log('countdown data:', ...countdown)
// countdown data: 3 2 1 0
1
2
3
4
5
6
7
8
9
@loige
Spread operator
25

1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
@loige
Spread operator
25

1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
@loige
Spread operator
25

1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
@loige
Spread operator
25

1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
@loige
Spread operator
25

import {
DynamoDBClient,
paginateListTables
} from '@aws-sdk/client-dynamodb'
const client = new DynamoDBClient({});
for await (const page of paginateListTables({ client }, {})) {
// page.TableNames is an array of table names
for (const tableName of page.TableNames) {
console.log(tableName)
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
@loige
for await...of (async iterable)
26

import {
DynamoDBClient,
paginateListTables
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
import {
DynamoDBClient,
paginateListTables
1
2
3
4
5
6
7
8
9
10
11
}
12
}
13
@loige
26

import {
DynamoDBClient,
paginateListTables
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
import {
DynamoDBClient,
paginateListTables
1
2
3
4
5
6
7
8
9
10
11
}
12
}
13
import {
1
DynamoDBClient,
2
paginateListTables
3
4
5
6
7
8
9
10
11
}
12
}
13
@loige
26

import {
DynamoDBClient,
paginateListTables
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
import {
DynamoDBClient,
paginateListTables
1
2
3
4
5
6
7
8
9
10
11
}
12
}
13
import {
1
DynamoDBClient,
2
paginateListTables
3
4
5
6
7
8
9
10
11
}
12
}
13
}
import {
1
DynamoDBClient,
2
paginateListTables
3
4
5
6
7
8
9
10
11
}
12
13
@loige
26

import {
DynamoDBClient,
paginateListTables
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
import {
DynamoDBClient,
paginateListTables
1
2
3
4
5
6
7
8
9
10
11
}
12
}
13
import {
1
DynamoDBClient,
2
paginateListTables
3
4
5
6
7
8
9
10
11
}
12
}
13
}
import {
1
DynamoDBClient,
2
paginateListTables
3
4
5
6
7
8
9
10
11
}
12
13
}
import {
1
DynamoDBClient,
2
paginateListTables
3
4
5
6
7
8
9
10
11
12
}
13
@loige
26

import {
DynamoDBClient,
paginateListTables
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
import {
DynamoDBClient,
paginateListTables
1
2
3
4
5
6
7
8
9
10
11
}
12
}
13
import {
1
DynamoDBClient,
2
paginateListTables
3
4
5
6
7
8
9
10
11
}
12
}
13
}
import {
1
DynamoDBClient,
2
paginateListTables
3
4
5
6
7
8
9
10
11
}
12
13
}
import {
1
DynamoDBClient,
2
paginateListTables
3
4
5
6
7
8
9
10
11
12
}
13
import {
DynamoDBClient,
paginateListTables
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
@loige
26

Iteration Protocols 😵💫
@loige
27

Iterator protocol
In JavaScript, an object is an iterator if it has a next()
method. Every time you call it, it returns an object with the
keys done (boolean) and value.
@loige
28

function createCountdown (start) {
let nextVal = start
return {
next () {
if (nextVal < 0) {
return { done: true }
}
return {
done: false,
value: nextVal--
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
@loige
Countdown iterator
29

let nextVal = start
return {
next () {
if (nextVal < 0) {
}
return {
done: false,
value: nextVal--
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
}
1
let nextVal = start
2
return {
3
next () {
4
if (nextVal < 0) {
5
6
}
7
return {
8
done: false,
9
value: nextVal--
10
}
11
}
12
}
13
14
@loige
Countdown iterator
const countdown = createCountdown(3)
console.log(countdown.next()) // { done: false, value: 3 }
console.log(countdown.next()) // { done: true }
29

let nextVal = start
return {
next () {
if (nextVal < 0) {
}
return {
done: false,
value: nextVal--
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
}
1
let nextVal = start
2
return {
3
next () {
4
if (nextVal < 0) {
5
6
}
7
return {
8
done: false,
9
value: nextVal--
10
}
11
}
12
}
13
14
let nextVal = start
1
2
return {
3
next () {
4
if (nextVal < 0) {
5
6
}
7
return {
8
done: false,
9
value: nextVal--
10
}
11
}
12
}
13
}
14
@loige
Countdown iterator
29

let nextVal = start
return {
next () {
if (nextVal < 0) {
}
return {
done: false,
value: nextVal--
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
}
1
let nextVal = start
2
return {
3
next () {
4
if (nextVal < 0) {
5
6
}
7
return {
8
done: false,
9
value: nextVal--
10
}
11
}
12
}
13
14
let nextVal = start
1
2
return {
3
next () {
4
if (nextVal < 0) {
5
6
}
7
return {
8
done: false,
9
value: nextVal--
10
}
11
}
12
}
13
}
14
return {
}
1
let nextVal = start
2
3
next () {
4
if (nextVal < 0) {
5
6
}
7
return {
8
done: false,
9
value: nextVal--
10
}
11
}
12
13
}
14
@loige
Countdown iterator
29

let nextVal = start
return {
next () {
if (nextVal < 0) {
}
return {
done: false,
value: nextVal--
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
}
1
let nextVal = start
2
return {
3
next () {
4
if (nextVal < 0) {
5
6
}
7
return {
8
done: false,
9
value: nextVal--
10
}
11
}
12
}
13
14
let nextVal = start
1
2
return {
3
next () {
4
if (nextVal < 0) {
5
6
}
7
return {
8
done: false,
9
value: nextVal--
10
}
11
}
12
}
13
}
14
return {
}
1
let nextVal = start
2
3
next () {
4
if (nextVal < 0) {
5
6
}
7
return {
8
done: false,
9
value: nextVal--
10
}
11
}
12
13
}
14
next () {
}
1
let nextVal = start
2
return {
3
4
if (nextVal < 0) {
5
6
}
7
return {
8
done: false,
9
value: nextVal--
10
}
11
12
}
13
}
14
@loige
Countdown iterator
29

let nextVal = start
return {
next () {
if (nextVal < 0) {
}
return {
done: false,
value: nextVal--
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
}
1
let nextVal = start
2
return {
3
next () {
4
if (nextVal < 0) {
5
6
}
7
return {
8
done: false,
9
value: nextVal--
10
}
11
}
12
}
13
14
let nextVal = start
1
2
return {
3
next () {
4
if (nextVal < 0) {
5
6
}
7
return {
8
done: false,
9
value: nextVal--
10
}
11
}
12
}
13
}
14
return {
}
1
let nextVal = start
2
3
next () {
4
if (nextVal < 0) {
5
6
}
7
return {
8
done: false,
9
value: nextVal--
10
}
11
}
12
13
}
14
next () {
}
1
let nextVal = start
2
return {
3
4
if (nextVal < 0) {
5
6
}
7
return {
8
done: false,
9
value: nextVal--
10
}
11
12
}
13
}
14
if (nextVal < 0) {
}
1
let nextVal = start
2
return {
3
next () {
4
5
6
7
return {
8
done: false,
9
value: nextVal--
10
}
11
}
12
}
13
}
14
@loige
Countdown iterator
29

let nextVal = start
return {
next () {
if (nextVal < 0) {
}
return {
done: false,
value: nextVal--
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
}
1
let nextVal = start
2
return {
3
next () {
4
if (nextVal < 0) {
5
6
}
7
return {
8
done: false,
9
value: nextVal--
10
}
11
}
12
}
13
14
let nextVal = start
1
2
return {
3
next () {
4
if (nextVal < 0) {
5
6
}
7
return {
8
done: false,
9
value: nextVal--
10
}
11
}
12
}
13
}
14
return {
}
1
let nextVal = start
2
3
next () {
4
if (nextVal < 0) {
5
6
}
7
return {
8
done: false,
9
value: nextVal--
10
}
11
}
12
13
}
14
next () {
}
1
let nextVal = start
2
return {
3
4
if (nextVal < 0) {
5
6
}
7
return {
8
done: false,
9
value: nextVal--
10
}
11
12
}
13
}
14
if (nextVal < 0) {
}
1
let nextVal = start
2
return {
3
next () {
4
5
6
7
return {
8
done: false,
9
value: nextVal--
10
}
11
}
12
}
13
}
14
return {
done: false,
value: nextVal--
}
1
let nextVal = start
2
return {
3
next () {
4
if (nextVal < 0) {
5
6
}
7
8
9
10
11
}
12
}
13
}
14
@loige
Countdown iterator
29

let nextVal = start
return {
next () {
if (nextVal < 0) {
}
return {
done: false,
value: nextVal--
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
}
1
let nextVal = start
2
return {
3
next () {
4
if (nextVal < 0) {
5
6
}
7
return {
8
done: false,
9
value: nextVal--
10
}
11
}
12
}
13
14
let nextVal = start
1
2
return {
3
next () {
4
if (nextVal < 0) {
5
6
}
7
return {
8
done: false,
9
value: nextVal--
10
}
11
}
12
}
13
}
14
return {
}
1
let nextVal = start
2
3
next () {
4
if (nextVal < 0) {
5
6
}
7
return {
8
done: false,
9
value: nextVal--
10
}
11
}
12
13
}
14
next () {
}
1
let nextVal = start
2
return {
3
4
if (nextVal < 0) {
5
6
}
7
return {
8
done: false,
9
value: nextVal--
10
}
11
12
}
13
}
14
if (nextVal < 0) {
}
1
let nextVal = start
2
return {
3
next () {
4
5
6
7
return {
8
done: false,
9
value: nextVal--
10
}
11
}
12
}
13
}
14
return {
done: false,
value: nextVal--
}
1
let nextVal = start
2
return {
3
next () {
4
if (nextVal < 0) {
5
6
}
7
8
9
10
11
}
12
}
13
}
14
let nextVal = start
return {
next () {
if (nextVal < 0) {
}
return {
done: false,
value: nextVal--
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
@loige
Countdown iterator
29

Iterable protocol
An object is iterable if it implements the @@iterator*
method, a zero-argument function that returns an iterator.

* Symbol.iterator
@loige
30

let nextVal = start
return {
[Symbol.iterator]: () => ({
next () {
if (nextVal < 0) {
}
return {
done: false,
value: nextVal--
}
}
})
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@loige
Countdown iterable
31

let nextVal = start
return {
next () {
if (nextVal < 0) {
}
return {
done: false,
value: nextVal--
}
}
})
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
}
1
let nextVal = start
2
return {
3
4
next () {
5
if (nextVal < 0) {
6
7
}
8
return {
9
done: false,
10
value: nextVal--
11
}
12
}
13
})
14
}
15
16
@loige
Countdown iterable
for (const value of countdown) {
console.log(value)
}
// 3
// 2
// 1
// 0
31

let nextVal = start
return {
next () {
if (nextVal < 0) {
}
return {
done: false,
value: nextVal--
}
}
})
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
}
1
let nextVal = start
2
return {
3
4
next () {
5
if (nextVal < 0) {
6
7
}
8
return {
9
done: false,
10
value: nextVal--
11
}
12
}
13
})
14
}
15
16
let nextVal = start
1
2
return {
3
4
next () {
5
if (nextVal < 0) {
6
7
}
8
return {
9
done: false,
10
value: nextVal--
11
}
12
}
13
})
14
}
15
}
16
@loige
Countdown iterable
console.log(value)
}
// 3
// 2
// 1
// 0
31

let nextVal = start
return {
next () {
if (nextVal < 0) {
}
return {
done: false,
value: nextVal--
}
}
})
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
}
1
let nextVal = start
2
return {
3
4
next () {
5
if (nextVal < 0) {
6
7
}
8
return {
9
done: false,
10
value: nextVal--
11
}
12
}
13
})
14
}
15
16
let nextVal = start
1
2
return {
3
4
next () {
5
if (nextVal < 0) {
6
7
}
8
return {
9
done: false,
10
value: nextVal--
11
}
12
}
13
})
14
}
15
}
16
return {
}
1
let nextVal = start
2
3
4
next () {
5
if (nextVal < 0) {
6
7
}
8
return {
9
done: false,
10
value: nextVal--
11
}
12
}
13
})
14
15
}
16
@loige
Countdown iterable
console.log(value)
}
// 3
// 2
// 1
// 0
31

let nextVal = start
return {
next () {
if (nextVal < 0) {
}
return {
done: false,
value: nextVal--
}
}
})
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
}
1
let nextVal = start
2
return {
3
4
next () {
5
if (nextVal < 0) {
6
7
}
8
return {
9
done: false,
10
value: nextVal--
11
}
12
}
13
})
14
}
15
16
let nextVal = start
1
2
return {
3
4
next () {
5
if (nextVal < 0) {
6
7
}
8
return {
9
done: false,
10
value: nextVal--
11
}
12
}
13
})
14
}
15
}
16
return {
}
1
let nextVal = start
2
3
4
next () {
5
if (nextVal < 0) {
6
7
}
8
return {
9
done: false,
10
value: nextVal--
11
}
12
}
13
})
14
15
}
16
})
1
let nextVal = start
2
return {
3
4
next () {
5
if (nextVal < 0) {
6
7
}
8
return {
9
done: false,
10
value: nextVal--
11
}
12
}
13
14
}
15
}
16
@loige
Countdown iterable
console.log(value)
}
// 3
// 2
// 1
// 0
31

let nextVal = start
return {
next () {
if (nextVal < 0) {
}
return {
done: false,
value: nextVal--
}
}
})
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
}
1
let nextVal = start
2
return {
3
4
next () {
5
if (nextVal < 0) {
6
7
}
8
return {
9
done: false,
10
value: nextVal--
11
}
12
}
13
})
14
}
15
16
let nextVal = start
1
2
return {
3
4
next () {
5
if (nextVal < 0) {
6
7
}
8
return {
9
done: false,
10
value: nextVal--
11
}
12
}
13
})
14
}
15
}
16
return {
}
1
let nextVal = start
2
3
4
next () {
5
if (nextVal < 0) {
6
7
}
8
return {
9
done: false,
10
value: nextVal--
11
}
12
}
13
})
14
15
}
16
})
1
let nextVal = start
2
return {
3
4
next () {
5
if (nextVal < 0) {
6
7
}
8
return {
9
done: false,
10
value: nextVal--
11
}
12
}
13
14
}
15
}
16
next () {
if (nextVal < 0) {
}
return {
done: false,
value: nextVal--
}
}
1
let nextVal = start
2
return {
3
4
5
6
7
8
9
10
11
12
13
})
14
}
15
}
16
@loige
Countdown iterable
console.log(value)
}
// 3
// 2
// 1
// 0
31

let nextVal = start
return {
next () {
if (nextVal < 0) {
}
return {
done: false,
value: nextVal--
}
}
})
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
}
1
let nextVal = start
2
return {
3
4
next () {
5
if (nextVal < 0) {
6
7
}
8
return {
9
done: false,
10
value: nextVal--
11
}
12
}
13
})
14
}
15
16
let nextVal = start
1
2
return {
3
4
next () {
5
if (nextVal < 0) {
6
7
}
8
return {
9
done: false,
10
value: nextVal--
11
}
12
}
13
})
14
}
15
}
16
return {
}
1
let nextVal = start
2
3
4
next () {
5
if (nextVal < 0) {
6
7
}
8
return {
9
done: false,
10
value: nextVal--
11
}
12
}
13
})
14
15
}
16
})
1
let nextVal = start
2
return {
3
4
next () {
5
if (nextVal < 0) {
6
7
}
8
return {
9
done: false,
10
value: nextVal--
11
}
12
}
13
14
}
15
}
16
next () {
if (nextVal < 0) {
}
return {
done: false,
value: nextVal--
}
}
1
let nextVal = start
2
return {
3
4
5
6
7
8
9
10
11
12
13
})
14
}
15
}
16
let nextVal = start
return {
next () {
if (nextVal < 0) {
}
return {
done: false,
value: nextVal--
}
}
})
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@loige
Countdown iterable
console.log(value)
}
// 3
// 2
// 1
// 0
31

Can an object be both an
iterator and an iterable?! 🤨
@loige
32

const iterableIterator = {
next() {
return { done: false, value: "hello" }
},
[Symbol.iterator]() {
return this
}
}
1
2
3
4
5
6
7
8
@loige
Iterator + Iterable
33

next() {
},
return this
}
}
1
2
3
4
5
6
7
8
}
1
next() {
2
3
},
4
5
return this
6
}
7
8
@loige
Iterator + Iterable
iterableIterator.next()
// { done: false, value: "hello" }
for (const value of iterableIterator) {
console.log(value)
}
// hello
// hello
// hello
// ...
33

next() {
},
return this
}
}
1
2
3
4
5
6
7
8
}
1
next() {
2
3
},
4
5
return this
6
}
7
8
next() {
},
1
2
3
4
5
return this
6
}
7
}
8
@loige
Iterator + Iterable
console.log(value)
}
// hello
// hello
// hello
// ...
33

next() {
},
return this
}
}
1
2
3
4
5
6
7
8
}
1
next() {
2
3
},
4
5
return this
6
}
7
8
next() {
},
1
2
3
4
5
return this
6
}
7
}
8
return this
}
1
next() {
2
3
},
4
5
6
7
}
8
@loige
Iterator + Iterable
console.log(value)
}
// hello
// hello
// hello
// ...
33

next() {
},
return this
}
}
1
2
3
4
5
6
7
8
}
1
next() {
2
3
},
4
5
return this
6
}
7
8
next() {
},
1
2
3
4
5
return this
6
}
7
}
8
return this
}
1
next() {
2
3
},
4
5
6
7
}
8
next() {
},
return this
}
}
1
2
3
4
5
6
7
8
@loige
Iterator + Iterable
console.log(value)
}
// hello
// hello
// hello
// ...
33

Generators
A generator function "produces" an
object that is both an iterator and an
iterable! 🤯
@loige
34

function * createCountdown (start) {
for (let i = start; i >= 0; i--) {
yield i
}
}
1
2
3
4
5
@loige
35

yield i
}
}
1
2
3
4
5
}
1
2
yield i
3
}
4
5
@loige
// As iterator
35

yield i
}
}
1
2
3
4
5
}
1
2
yield i
3
}
4
5
}
1
2
yield i
3
4
}
5
@loige
// As iterable
console.log(value)
}
// 3
// 2
// 1
// 0
// As iterator
35

yield i
}
}
1
2
3
4
5
}
1
2
yield i
3
}
4
5
}
1
2
yield i
3
4
}
5
yield i
1
2
3
}
4
}
5
@loige
// As iterable
console.log(value)
}
// 3
// 2
// 1
// 0
// As iterator
35

yield i
}
}
1
2
3
4
5
}
1
2
yield i
3
}
4
5
}
1
2
yield i
3
4
}
5
yield i
1
2
3
}
4
}
5
yield i
}
}
1
2
3
4
5
@loige
// As iterable
console.log(value)
}
// 3
// 2
// 1
// 0
// As iterator
35

Well, what about async
iteration?
@loige
36

Async Iterator protocol
An object is an async iterator if it has a next() method. Every
time you call it, it returns a promise that resolves to an
object with the keys done (boolean) and value.
@loige
37

import { setTimeout } from 'timers/promises'
function createAsyncCountdown (start, delay = 1000) {
let nextVal = start
return {
async next () {
await setTimeout(delay)
if (nextVal < 0) {
}
return { done: false, value: nextVal-- }
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
@loige
38

let nextVal = start
return {
async next () {
if (nextVal < 0) {
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
let nextVal = start
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
}
14
@loige
38

let nextVal = start
return {
async next () {
if (nextVal < 0) {
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
let nextVal = start
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
}
14
}
1
2
3
let nextVal = start
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
14
@loige
const countdown = createAsyncCountdown(3)
console.log(await countdown.next()) // { done: false, value: 3 }
console.log(await countdown.next()) // { done: true }
38

let nextVal = start
return {
async next () {
if (nextVal < 0) {
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
let nextVal = start
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
}
14
}
1
2
3
let nextVal = start
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
14
let nextVal = start
1
2
3
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
}
14
@loige
38

let nextVal = start
return {
async next () {
if (nextVal < 0) {
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
let nextVal = start
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
}
14
}
1
2
3
let nextVal = start
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
14
let nextVal = start
1
2
3
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
}
14
return {
}
1
2
3
let nextVal = start
4
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
13
}
14
@loige
38

let nextVal = start
return {
async next () {
if (nextVal < 0) {
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
let nextVal = start
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
}
14
}
1
2
3
let nextVal = start
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
14
let nextVal = start
1
2
3
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
}
14
return {
}
1
2
3
let nextVal = start
4
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
13
}
14
async next () {
}
1
2
3
let nextVal = start
4
return {
5
6
7
if (nextVal < 0) {
8
9
}
10
11
12
}
13
}
14
@loige
38

let nextVal = start
return {
async next () {
if (nextVal < 0) {
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
let nextVal = start
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
}
14
}
1
2
3
let nextVal = start
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
14
let nextVal = start
1
2
3
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
}
14
return {
}
1
2
3
let nextVal = start
4
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
13
}
14
async next () {
}
1
2
3
let nextVal = start
4
return {
5
6
7
if (nextVal < 0) {
8
9
}
10
11
12
}
13
}
14
1
2
3
let nextVal = start
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
}
14
@loige
38

let nextVal = start
return {
async next () {
if (nextVal < 0) {
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
let nextVal = start
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
}
14
}
1
2
3
let nextVal = start
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
14
let nextVal = start
1
2
3
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
}
14
return {
}
1
2
3
let nextVal = start
4
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
13
}
14
async next () {
}
1
2
3
let nextVal = start
4
return {
5
6
7
if (nextVal < 0) {
8
9
}
10
11
12
}
13
}
14
1
2
3
let nextVal = start
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
}
14
if (nextVal < 0) {
}
1
2
3
let nextVal = start
4
return {
5
async next () {
6
7
8
9
10
11
}
12
}
13
}
14
@loige
38

let nextVal = start
return {
async next () {
if (nextVal < 0) {
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
let nextVal = start
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
}
14
}
1
2
3
let nextVal = start
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
14
let nextVal = start
1
2
3
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
}
14
return {
}
1
2
3
let nextVal = start
4
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
13
}
14
async next () {
}
1
2
3
let nextVal = start
4
return {
5
6
7
if (nextVal < 0) {
8
9
}
10
11
12
}
13
}
14
1
2
3
let nextVal = start
4
return {
5
async next () {
6
7
if (nextVal < 0) {
8
9
}
10
11
}
12
}
13
}
14
if (nextVal < 0) {
}
1
2
3
let nextVal = start
4
return {
5
async next () {
6
7
8
9
10
11
}
12
}
13
}
14
let nextVal = start
return {
async next () {
if (nextVal < 0) {
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
@loige
38

Async Iterable protocol
An object is an async iterable if it implements the
@@asyncIterator* method, a zero-argument function that
returns an async iterator.

* Symbol.asyncIterator
@loige
40

return {
[Symbol.asyncIterator]: function () {
let nextVal = start
return {
async next () {
if (nextVal < 0) {
}
}
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@loige
41

return {
let nextVal = start
return {
async next () {
if (nextVal < 0) {
}
}
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
}
1
2
3
return {
4
5
let nextVal = start
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
17
}
18
@loige
41

return {
let nextVal = start
return {
async next () {
if (nextVal < 0) {
}
}
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
}
1
2
3
return {
4
5
let nextVal = start
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
17
}
18
return {
1
2
3
4
5
let nextVal = start
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
}
17
}
18
@loige
for await (const value of countdown) {
console.log(value) // 3 ... 2 ... 1 ... 0
}
41

return {
let nextVal = start
return {
async next () {
if (nextVal < 0) {
}
}
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
}
1
2
3
return {
4
5
let nextVal = start
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
17
}
18
return {
1
2
3
4
5
let nextVal = start
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
}
17
}
18
1
2
3
return {
4
5
let nextVal = start
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
}
17
}
18
@loige
}
41

return {
let nextVal = start
return {
async next () {
if (nextVal < 0) {
}
}
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
}
1
2
3
return {
4
5
let nextVal = start
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
17
}
18
return {
1
2
3
4
5
let nextVal = start
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
}
17
}
18
1
2
3
return {
4
5
let nextVal = start
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
}
17
}
18
let nextVal = start
1
2
3
return {
4
5
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
}
17
}
18
@loige
}
41

return {
let nextVal = start
return {
async next () {
if (nextVal < 0) {
}
}
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
}
1
2
3
return {
4
5
let nextVal = start
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
17
}
18
return {
1
2
3
4
5
let nextVal = start
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
}
17
}
18
1
2
3
return {
4
5
let nextVal = start
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
}
17
}
18
let nextVal = start
1
2
3
return {
4
5
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
}
17
}
18
return {
}
1
2
3
return {
4
5
let nextVal = start
6
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
15
}
16
}
17
}
18
@loige
}
41

return {
let nextVal = start
return {
async next () {
if (nextVal < 0) {
}
}
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
}
1
2
3
return {
4
5
let nextVal = start
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
17
}
18
return {
1
2
3
4
5
let nextVal = start
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
}
17
}
18
1
2
3
return {
4
5
let nextVal = start
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
}
17
}
18
let nextVal = start
1
2
3
return {
4
5
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
}
17
}
18
return {
}
1
2
3
return {
4
5
let nextVal = start
6
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
15
}
16
}
17
}
18
async next () {
}
1
2
3
return {
4
5
let nextVal = start
6
return {
7
8
9
if (nextVal < 0) {
10
11
}
12
13
14
}
15
}
16
}
17
}
18
@loige
}
41

return {
let nextVal = start
return {
async next () {
if (nextVal < 0) {
}
}
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
}
1
2
3
return {
4
5
let nextVal = start
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
17
}
18
return {
1
2
3
4
5
let nextVal = start
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
}
17
}
18
1
2
3
return {
4
5
let nextVal = start
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
}
17
}
18
let nextVal = start
1
2
3
return {
4
5
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
}
17
}
18
return {
}
1
2
3
return {
4
5
let nextVal = start
6
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
15
}
16
}
17
}
18
async next () {
}
1
2
3
return {
4
5
let nextVal = start
6
return {
7
8
9
if (nextVal < 0) {
10
11
}
12
13
14
}
15
}
16
}
17
}
18
if (nextVal < 0) {
}
1
2
3
return {
4
5
let nextVal = start
6
return {
7
async next () {
8
9
10
11
12
13
}
14
}
15
}
16
}
17
}
18
@loige
}
41

return {
let nextVal = start
return {
async next () {
if (nextVal < 0) {
}
}
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
}
1
2
3
return {
4
5
let nextVal = start
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
17
}
18
return {
1
2
3
4
5
let nextVal = start
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
}
17
}
18
1
2
3
return {
4
5
let nextVal = start
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
}
17
}
18
let nextVal = start
1
2
3
return {
4
5
6
return {
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
}
15
}
16
}
17
}
18
return {
}
1
2
3
return {
4
5
let nextVal = start
6
7
async next () {
8
9
if (nextVal < 0) {
10
11
}
12
13
}
14
15
}
16
}
17
}
18
async next () {
}
1
2
3
return {
4
5
let nextVal = start
6
return {
7
8
9
if (nextVal < 0) {
10
11
}
12
13
14
}
15
}
16
}
17
}
18
if (nextVal < 0) {
}
1
2
3
return {
4
5
let nextVal = start
6
return {
7
async next () {
8
9
10
11
12
13
}
14
}
15
}
16
}
17
}
18
return {
let nextVal = start
return {
async next () {
if (nextVal < 0) {
}
}
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@loige
}
41

async function * createAsyncCountdown (start, delay = 1000) {
yield i
}
}
1
2
3
4
5
6
7
8
@loige
42

yield i
}
}
1
2
3
4
5
6
7
8
}
1
2
3
4
5
yield i
6
}
7
8
@loige
}
42

yield i
}
}
1
2
3
4
5
6
7
8
}
1
2
3
4
5
yield i
6
}
7
8
yield i
1
2
3
4
5
6
}
7
}
8
@loige
}
42

yield i
}
}
1
2
3
4
5
6
7
8
}
1
2
3
4
5
yield i
6
}
7
8
yield i
1
2
3
4
5
6
}
7
}
8
yield i
}
}
1
2
3
4
5
6
7
8
@loige
}
42

When to use async iterators
@loige
Sequential iteration pattern
Data arriving in order over time
You need to complete processing the current “chunk”
before you can request the next one
Examples
paginated iteration
consuming tasks from a remote queue
44

import { createReadStream } from 'fs'
const sourceStream = createReadStream('bigdata.csv')
let bytes = 0
for await (const chunk of sourceStream) {
bytes += chunk.length
}
console.log(`bigdata.csv: ${bytes} bytes`)
1
2
3
4
5
6
7
8
9
10
@loige
Node.js readable streams are async iterators
46

let bytes = 0
}
1
2
3
4
5
6
7
8
9
10
1
2
3
4
let bytes = 0
5
6
7
}
8
9
10
@loige
46

let bytes = 0
}
1
2
3
4
5
6
7
8
9
10
1
2
3
4
let bytes = 0
5
6
7
}
8
9
10
1
2
3
4
let bytes = 0
5
6
7
}
8
9
10
@loige
46

let bytes = 0
}
1
2
3
4
5
6
7
8
9
10
1
2
3
4
let bytes = 0
5
6
7
}
8
9
10
1
2
3
4
let bytes = 0
5
6
7
}
8
9
10
let bytes = 0
1
2
3
4
5
6
7
}
8
9
10
@loige
46

let bytes = 0
}
1
2
3
4
5
6
7
8
9
10
1
2
3
4
let bytes = 0
5
6
7
}
8
9
10
1
2
3
4
let bytes = 0
5
6
7
}
8
9
10
let bytes = 0
1
2
3
4
5
6
7
}
8
9
10
}
1
2
3
4
let bytes = 0
5
6
7
8
9
10
@loige
46

let bytes = 0
}
1
2
3
4
5
6
7
8
9
10
1
2
3
4
let bytes = 0
5
6
7
}
8
9
10
1
2
3
4
let bytes = 0
5
6
7
}
8
9
10
let bytes = 0
1
2
3
4
5
6
7
}
8
9
10
}
1
2
3
4
let bytes = 0
5
6
7
8
9
10
1
2
3
4
let bytes = 0
5
6
7
}
8
9
10
@loige
46

let bytes = 0
}
1
2
3
4
5
6
7
8
9
10
1
2
3
4
let bytes = 0
5
6
7
}
8
9
10
1
2
3
4
let bytes = 0
5
6
7
}
8
9
10
let bytes = 0
1
2
3
4
5
6
7
}
8
9
10
}
1
2
3
4
let bytes = 0
5
6
7
8
9
10
1
2
3
4
let bytes = 0
5
6
7
}
8
9
10 console.log(`bigdata.csv: ${bytes} bytes`)
1
2
3
4
let bytes = 0
5
6
7
}
8
9
10
@loige
46

let bytes = 0
}
1
2
3
4
5
6
7
8
9
10
1
2
3
4
let bytes = 0
5
6
7
}
8
9
10
1
2
3
4
let bytes = 0
5
6
7
}
8
9
10
let bytes = 0
1
2
3
4
5
6
7
}
8
9
10
}
1
2
3
4
let bytes = 0
5
6
7
8
9
10
1
2
3
4
let bytes = 0
5
6
7
}
8
9
10 console.log(`bigdata.csv: ${bytes} bytes`)
1
2
3
4
let bytes = 0
5
6
7
}
8
9
10
let bytes = 0
}
1
2
3
4
5
6
7
8
9
10
@loige
46

What about
backpressure? 😩
@loige
47

import { once } from 'events'
const destStream = new SlowTransform()
const canContinue = destStream.write(chunk)
if (!canContinue) {
// backpressure, now we stop and we need to wait for drain
await once(destStream, 'drain')
// ok now it's safe to resume writing
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
@loige
48

if (!canContinue) {
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
if (!canContinue) {
9
10
11
12
}
13
}
14
@loige
48

if (!canContinue) {
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
if (!canContinue) {
9
10
11
12
}
13
}
14
1
2
3
4
5
6
7
8
if (!canContinue) {
9
10
11
12
}
13
}
14
@loige
48

if (!canContinue) {
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
if (!canContinue) {
9
10
11
12
}
13
}
14
1
2
3
4
5
6
7
8
if (!canContinue) {
9
10
11
12
}
13
}
14
1
2
3
4
5
6
7
8
if (!canContinue) {
9
10
11
12
}
13
}
14
@loige
48

if (!canContinue) {
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
if (!canContinue) {
9
10
11
12
}
13
}
14
1
2
3
4
5
6
7
8
if (!canContinue) {
9
10
11
12
}
13
}
14
1
2
3
4
5
6
7
8
if (!canContinue) {
9
10
11
12
}
13
}
14
}
1
2
3
4
5
6
7
8
if (!canContinue) {
9
10
11
12
}
13
14
@loige
48

if (!canContinue) {
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
if (!canContinue) {
9
10
11
12
}
13
}
14
1
2
3
4
5
6
7
8
if (!canContinue) {
9
10
11
12
}
13
}
14
1
2
3
4
5
6
7
8
if (!canContinue) {
9
10
11
12
}
13
}
14
}
1
2
3
4
5
6
7
8
if (!canContinue) {
9
10
11
12
}
13
14
1
2
3
4
5
6
7
8
if (!canContinue) {
9
10
11
12
}
13
}
14
@loige
48

JavaScript & Node.js Iterators Explained

JavaScript & Node.js Iterators Explained

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to JavaScript & Node.js Iterators Explained

Similar to JavaScript & Node.js Iterators Explained (20)

More from Luciano Mammino

More from Luciano Mammino (20)

Recently uploaded

Recently uploaded (20)

JavaScript & Node.js Iterators Explained