Асинхронное программирование в однопоточных средах JavaScript

1. Введение в асинхронное программирование

let x = 3;
x = x + 4;

let x = 3
setTimeout(() => x = x + 4, 1000)

2. Цикл событий

3. Отложенное выполнение кода с помощью setTimeout setImmediate и process.nextTick

3.1 setTimeout

let x

setTimeout(() => x = 10, 0)

console.info(x) // undefined

3.2 setImmediate

let x

setImmediate(() => x = 10)

console.info(x) // undefined

• setImmediate предназначен для выполнения скрипта после завершения текущей фазы опроса.
• setTimeout планирует запуск скрипта по истечении минимального порога в мс.

// timeout_vs_immediate.js
setTimeout(() => {
  console.log('timeout')
}, 0)

setImmediate(() => {
  console.log('immediate')
})

$ node timeout_vs_immediate.js
timeout
immediate

$ node timeout_vs_immediate.js
immediate
timeout

// timeout_vs_immediate.js
const fs = require('fs')

fs.readFile(__filename, () => {
  setTimeout(() => {
    console.log('timeout')
  }, 0)
  setImmediate(() => {
    console.log('immediate')
  })
})

$ node timeout_vs_immediate.js
immediate
timeout

$ node timeout_vs_immediate.js
immediate
timeout

3.3 process.nextTick

function apiCall(arg, callback) {
  if (typeof arg !== 'string')
    return process.nextTick(
      callback,
      new TypeError('argument should be string'),
    )
}

let bar

// someAsyncApiCall имеет асинхронную сигнатуру, но синхронно вызывает обратный вызов
function someAsyncApiCall(callback) {
  callback()
}

// обратный вызов вызывается до завершения `someAsyncApiCall`
someAsyncApiCall(() => {
  // так как someAsyncApiCall не завершился, bar не было присвоено никакого значения
  console.log('bar', bar) // bar undefined
})

bar = 1

let bar

function someAsyncApiCall(callback) {
  process.nextTick(callback)
}

someAsyncApiCall(() => {
  console.log('bar', bar) // bar 1
})

bar = 1

const server = net.createServer(() => {}).listen(8080)

server.on('listening', () => {})

• Иметь возможножность обрабатывать ошибки, очищать все ненужные ресурсы или, возможно, повторить запрос, прежде чем цикл обработки событий продолжится.
• Иногда необходимо выполнить обратный вызов после запуска стека вызовов, но до продолжения цикла обработки событий.

const server = net.createServer()
server.on('connection', (conn) => {})

server.listen(8080)
server.on('listening', () => {})

const EventEmitter = require('events')
const util = require('util')

function MyEmitter() {
  EventEmitter.call(this)
  this.emit('event')
}
util.inherits(MyEmitter, EventEmitter)

const myEmitter = new MyEmitter()
myEmitter.on('event', () => {
  console.log('an event occurred!')
})

const EventEmitter = require('events')
const util = require('util')

function MyEmitter() {
  EventEmitter.call(this)

  // использование nextTick для генерации события после назначения обработчика
  process.nextTick(() => {
    this.emit('event')
  })
}
util.inherits(MyEmitter, EventEmitter)

const myEmitter = new MyEmitter()
myEmitter.on('event', () => {
  console.log('an event occurred!')
})

4. Устаревшие паттерны асинхронного программирования

function double(value) {
  setTimeout(() => setTimeout(() => console.log(value * 2), 0), 1000)
}

double(3)
// 6 (выводится примерно спустя 1000 мс)

function double(value, callback) {
  setTimeout(() => callback(value * 2), 1000)
}

double(3, (x) => console.log(`I was given: ${x}`))
// I was given: 6 (выводится примерно спустя 1000 мс)

function double(value, success, failure) {
  setTimeout(() => {
    try {
      if (typeof value !== 'number')
        throw new Error(`Unexpected argument. expected number but received: ${typeof value}`)

      success(2 * value)
    } catch (e) {
      failure(e)
    }
  }, 1000)
}
const successCallback = (x) => console.log(`Success: ${x}`)
const failureCallback = (e) => console.log(`Failure: ${e}`)

double(3, successCallback, failureCallback) // Success: 6 (выводится примерно спустя 1000 мс)
double('b', successCallback, failureCallback) // Failure: Error: Unexpected argument. expected number but received: string

function double(value, success, failure) {
  setTimeout(() => {
    try {
      if (typeof value !== 'number')
        throw new Error(`Unexpected argument. expected number but received: ${typeof value}`)

      success(2 * value)
    } catch (e) {
      failure(e)
    }
  }, 1000)
}

const successCallback = (x) => double(x, (y) => console.log(`Success: ${y}`))
const failureCallback = (e) => console.log(`Failure: ${e}`)

double(3, successCallback, failureCallback)
// Success: 12 (выводится примерно спустя 1000 мс)

5. Promise

5.1 Основы Promise

let p = new Promise(() => {})

console.log(p) // Promise <pending>

• в ожидании (Pending) — начальное состояние;
• выполнен или решенным (Fulfilled) — операция завершена успешно;
• отклонен (Rejected) — операция завершена с ошибкой.

let p1 = new Promise((resolve, reject) => resolve())
setTimeout(() => console.log(p1), 0) // Promise {<fulfilled>: undefined}
// [[PromiseState]]: "fulfilled"
// [[PromiseResult]]: undefined


let p2 = new Promise((resolve, reject) => reject())
setTimeout(() => console.log(p2), 0) // Promise {<rejected>: undefined}
// [[PromiseState]]: "rejected"
// [[PromiseResult]]: undefined
// Uncaught error (in promise)

let p = new Promise((resolve, reject) => {
 resolve()
 reject() // Безрезультатно
})

setTimeout(() => console.log(p), 0) // Promise {<fulfilled>: undefined}

let p = new Promise((resolve, reject) => {
  setTimeout(reject, 100) // Вызов reject() спустя 1 секунду
  // Код исполнителя
 })
 
 setTimeout(() => console.log(p), 0) // Promise <pending>
 setTimeout(() => console.log(p), 200) // Проверка состояния спустя 2 секунды

 // (Спустя 1 секунду) Uncaught error
 // (Спустя 2 секунды) Promise <rejected>

let p1 = new Promise((resolve, reject) => resolve())
let p2 = Promise.resolve()

const p1 = Promise.resolve()
console.info(p1) // Promise <resolved>: undefined

const p2 = Promise.resolve(3)
console.info(p2) // Promise <resolved>: 3

// Дополнительные аргументы игнорируются
const p3 = Promise.resolve(4, 5, 6)
console.info(p3) // Promise <resolved>: 4

const p = Promise.resolve(7)
console.log(p === Promise.resolve(p)) // true
console.log(p === Promise.resolve(Promise.resolve(p))) // true

let p = new Promise(() => {})

console.log(p) // Promise <pending>
console.log(Promise.resolve(p)) // Promise <pending>
console.log(p === Promise.resolve(p)) // true

let p = Promise.resolve(new Error('foo'))

console.log(p)
// Promise <resolved>: Error: foo

let p1 = new Promise((resolve, reject) => reject())
let p2 = Promise.reject()

let p = Promise.reject(3)

console.log(p) // Promise <rejected>: 3
p.then(null, e => console.log(e)) // 3

console.log(Promise.reject(Promise.resolve()))
// Promise <rejected>: Promise <resolved>

try {
  throw new Error('foo')
} 
catch(e) {
  console.log(e) // Error: foo
}
try {
  Promise.reject(new Error('bar'))
} 
catch(e) {
  console.log(e) // Uncaught (in promise) Error: bar
}

5.2 Методы экземпляра Promise

class MyThenable {
  then () {}
}

5.2.1 Promise.prototype.then

function onResolved (id) {
  console.log('resolved')
}

function onRejected (id) {
  console.log('rejected')
}

let p1 = new Promise((resolve, reject) => setTimeout(resolve, 3000))
let p2 = new Promise((resolve, reject) => setTimeout(reject, 3000))

p1.then(() => onResolved('p1'), () => onRejected('p1')) // p1 resolved
p2.then(() => onResolved('p2'), () => onRejected('p2')) // p2 rejected

function onResolved (id) {
  console.log('resolved')
}

function onRejected (id) {
  console.log('rejected')
}

let p1 = new Promise((resolve, reject) => setTimeout(resolve, 3000))
let p2 = new Promise((resolve, reject) => setTimeout(reject, 3000))

// Нефункциональные обработчики игнорируются, и их использование не рекомендуется
p1.then('gobbeltygook')

// Каноническая форма явного пропуска обработчика onResolved
p2.then(null, () => onRejected('p2'))
// p2 rejected (спустя 3 с)

let p1 = new Promise(() => {})
let p2 = p1.then()

console.log(p1) // Promise <pending>
console.log(p2) // Promise <pending>
console.log(p1 === p2) // false

let p1 = Promise.resolve('foo')

// Вызов then() без функций-обработчиков сработает как проход
let p2 = p1.then()
console.log(p2) // Promise <resolved>: foo

// Эти варианты эквивалентны
let p3 = p1.then(() => undefined)
let p4 = p1.then(() => {})
let p5 = p1.then(() => Promise.resolve())
console.log(p3) // Promise <resolved>: undefined
console.log(p4) // Promise <resolved>: undefined
console.log(p5) // Promise <resolved>: undefined

// Явные возвращаемые значения обернуты в Promise.resolve():
// Эти варианты эквивалентны:
let p6 = p1.then(() => 'bar')
let p7 = p1.then(() => Promise.resolve('bar'))
console.log(p6) // Promise <resolved>: bar
console.log(p7) // Promise <resolved>: bar

// Promise.resolve() сохраняет возвращенный промис
let p8 = p1.then(() => new Promise(() => {}))
let p9 = p1.then(() => Promise.reject())
// Uncaught (in promise): undefined

console.log(p8) // Promise <pending>
console.log(p9) // Promise <rejected>: undefined

// Генерация ошибки вернет отклоненный промис:
let p10 = p1.then(() => { throw new Error('baz') })
// Uncaught (in promise) baz

console.log(p10) // Promise <rejected> baz

// Возвращение ошибки не приведет к тому же поведению отклонения,
// а вместо этого обернет объект ошибки в разрешенный промис:
let p11 = p1.then(() => Error('qux'))
console.log(p11) // Promise <resolved>: Error: qux

5.2.2 Promise.prototype.catch

let p = Promise.reject()

let onRejected = function () {
  console.log('rejected')
}

// Эти обработчики отклонений эквивалентны:
p.then(null, onRejected) // rejected
p.catch(onRejected) // rejected

let p1 = new Promise(() => {})
let p2 = p1.catch()

setTimeout(console.log, 0, p1) // Promise <pending>
setTimeout(console.log, 0, p2) // Promise <pending>
setTimeout(console.log, 0, p1 === p2) // false

5.2.3 Promise.prototype.finally

let p1 = Promise.resolve()
let p2 = Promise.reject()

let onFinally = function () {
  console.log('Finally!')
}

p1.finally(onFinally) // Finally
p2.finally(onFinally) // Finally

let p1 = new Promise(() => {})
let p2 = p1.finally()

console.log(p1) // Promise <pending>
console.log(p2) // Promise <pending>
console.log(p1 === p2) // false

let p1 = Promise.resolve('foo')

// Все это сработает как проход
let p2 = p1.finally()
let p3 = p1.finally(() => undefined)
let p4 = p1.finally(() => {})
let p5 = p1.finally(() => Promise.resolve())
let p6 = p1.finally(() => 'bar')
let p7 = p1.finally(() => Promise.resolve('bar'))
let p8 = p1.finally(() => Error('qux'))

setImmediate(() => console.log(p2)) // Promise <resolved>: foo
setImmediate(() => console.log(p3)) // Promise <resolved>: foo
setImmediate(() => console.log(p4)) // Promise <resolved>: foo
setImmediate(() => console.log(p5)) // Promise <resolved>: foo
setImmediate(() => console.log(p6)) // Promise <resolved>: foo
setImmediate(() => console.log(p7)) // Promise <resolved>: foo
setImmediate(() => console.log(p8)) // Promise <resolved>: foo

// Promise.resolve() сохраняет возвращенный промис
let p9 = p1.finally(() => new Promise(() => {}))
let p10 = p1.finally(() => Promise.reject()) // Uncaught (in promise): undefined

setImmediate(() => console.log(p9)) // Promise <pending>
setImmediate(() => console.log(p10)) // Promise <rejected>: undefined

let p11 = p1.finally(() => { throw new Error('baz') })
// Uncaught (in promise) baz

setImmediate(() => console.log(p11)) // Promise <rejected>: baz

let p1 = Promise.resolve('foo')

// Возвращаемое значение игнорируется
let p2 = p1.finally(() => new Promise((resolve, reject) => setImmediate(() => resolve('bar'))))

setImmediate(() => console.log(p2)) // Promise <pending>
setImmediate(() => setImmediate(() => (console.log(p2)))) // Promise <resolved>: foo

// Создание разрешенного промиса
let p = Promise.resolve()

// Добавление обработчика разрешенного состояния.
// Интуитивно понятно, что это будет выполнено как можно скорее,
// поскольку p уже разрешен.
p.then(() => console.log('onResolved handler'))

// Синхронная запись, указывающая, что then() вернулся
console.log('then() returns')
// Действительный вывод:
// then() returns
// onResolved handler

let synchronousResolve

// Создание промиса и сохранение функции разрешения в локальной переменной.
let p = new Promise((resolve) => {
  synchronousResolve = function () {
    console.log('1: invoking resolve()')
    resolve()
    console.log('2: resolve() returns')
  }
})

p.then(() => console.log('4: then() handler executes'))
synchronousResolve()
console.log('3: synchronousResolve() returns')

// Действительный вывод:
// 1: invoking resolve()
// 2: resolve() returns
// 3: synchronousResolve() returns
// 4: then() handler executes

let p1 = Promise.resolve()
p1.then(() => console.log('p1.then() onResolved'))
console.log('p1.then() returns')

let p2 = Promise.reject()
p2.then(null, () => console.log('p2.then() onRejected'))
console.log('p2.then() returns')

let p3 = Promise.reject()
p3.catch(() => console.log('p3.catch() onRejected'))
console.log('p3.catch() returns')

let p4 = Promise.resolve()
p4.finally(() => console.log('p4.finally() onFinally'))
console.log('p4.finally() returns')
// p1.then() returns
// p2.then() returns
// p3.catch() returns
// p4.finally() returns
// p1.then() onResolved
// p2.then() onRejected
// p3.catch() onRejected
// p4.finally() onFinally

let p1 = Promise.resolve()
let p2 = Promise.reject()

p1.then(() => setImmediate(() => console.log(1)))
p1.then(() => setImmediate(() => console.log(2)))
// 1
// 2

p2.then(null, () => setImmediate(() => console.log(3)))
p2.then(null, () => setImmediate(() => console.log(4)))
// 3
// 4

p2.catch(() => setImmediate(() => console.log(5)))
p2.catch(() => setImmediate(() => console.log(6)))
// 5
// 6

p1.finally(() => setImmediate(() => console.log(7)))
p1.finally(() => setImmediate(() => console.log(8)))
// 7
// 8

let p1 = new Promise((resolve, reject) => resolve('foo'))
p1.then(value => console.log(value)) // foo

let p2 = new Promise((resolve, reject) => reject('bar'))
p2.catch(reason => console.log(reason)) // bar

let p1 = Promise.resolve('foo')
p1.then(value => console.log(value)) // foo

let p2 = Promise.reject('bar')
p2.catch(reason => console.log(reason)) // bar

let p1 = new Promise((resolve, reject) => reject(Error('foo')))
let p2 = new Promise((resolve, reject) => { throw Error('foo') })
let p3 = Promise.resolve().then(() => { throw Error('foo') })
let p4 = Promise.reject(Error('foo'))

setImmediate(() => console.log(p1)) // Promise <rejected>: Error: foo
setImmediate(() => console.log(p2)) // Promise <rejected>: Error: foo
setImmediate(() => console.log(p3)) // Promise <rejected>: Error: foo
setImmediate(() => console.log(p4)) // Promise <rejected>: Error: foo
// Также были сгенерированы четыре необрабатываемые ошибки

throw Error('foo')
console.log('bar') // Этот код никогда не выполнится
// Uncaught Error: foo

Promise.reject(Error('foo'))
console.log('bar')
// bar
// Uncaught (in promise) Error: foo

// Правильно
Promise.reject(Error('foo')).catch((e) => {})

// Неправильно
try {
  Promise.reject(Error('foo'))
} catch(e) {}

let p = new Promise((resolve, reject) => {
  try {
    throw Error('foo')
  } catch(e) {}

  resolve('bar')
})
setImmediate(() => console.log(p)) // Promise <resolved>: bar

console.log('begin synchronous execution')

try {
  throw Error('foo')
} catch(e) {
  console.log('caught error', e)
}

console.log('continue synchronous execution')
// begin synchronous execution
// caught error Error: foo
// continue synchronous execution

new Promise((resolve, reject) => {
  console.log('begin asynchronous execution')
  reject(Error('bar'))
}).catch((e) => {
  console.log('caught error', e)
}).then(() => {
  console.log('continue asynchronous execution')
})
// begin asynchronous execution
// caught error Error: bar
// continue asynchronous execution

5.3 Композиция и цепочки промисов

let p = new Promise((resolve) => {
  console.log('first')
  resolve()
})

p.then(() => console.log('second'))
  .then(() => console.log('third'))
  .then(() => console.log('fourth'))
// first
// second
// third
// fourth

(() => console.log('first'))();
(() => console.log('second'))();
(() => console.log('third'))();
(() => console.log('fourth'))()

let p1 = new Promise((resolve) => {
  console.log('p1 executor')
  setTimeout(resolve, 1000)
})

p1.then(() => new Promise((resolve) => {
  console.log('p2 executor')
  setTimeout(resolve, 1000)
}))
  .then(() => new Promise((resolve) => {
    console.log('p3 executor')
    setTimeout(resolve, 1000)
  }))
  .then(() => new Promise((resolve) => {
    console.log('p4 executor')
    setTimeout(resolve, 1000)
  }))
// p1 executor (спустя 1 с)
// p2 executor (спустя 2 с)
// p3 executor (спустя 3 с)
// p4 executor (спустя 4 с)

function delayedResolve (str) {
  return new Promise((resolve) => {
    console.log(str)
    setTimeout(resolve, 1000)
  })
}

delayedResolve('p1 executor')
  .then(() => delayedResolve('p2 executor'))
  .then(() => delayedResolve('p3 executor'))
  .then(() => delayedResolve('p4 executor'))
// p1 executor (спустя 1 с)
// p2 executor (спустя 2 с)
// p3 executor (спустя 3 с)
// p4 executor (спустя 4 с)

function delayedExecute (str, callback = null) {
  setTimeout(() => {
    console.log(str)
    callback && callback()
  }, 1000)
}
delayedExecute('p1 callback', () => {
  delayedExecute('p2 callback', () => {
    delayedExecute('p3 callback', () => {
      delayedExecute('p4 callback')
    })
  })
})
// p1 callback (спустя 1 с)
// p2 callback (спустя 2 с)
// p3 callback (спустя 3 с)
// p4 callback (спустя 4 с)

let p = new Promise((resolve, reject) => {
  console.log('initial promise rejects')
  reject()
})

p.catch(() => console.log('reject handler'))
  .then(() => console.log('resolve handler'))
  .finally(() => console.log('finally handler'))
// initial promise rejects
// reject handler
// resolve handler
// finally handler

5.3.1 Графы промисов

//     A
//    / \
//   B   C
//  / \ / \
// D  E F  G
let A = new Promise((resolve, reject) => {
  console.log('A')
  resolve()
})

let B = A.then(() => console.log('B'))
let C = A.then(() => console.log('C'))

B.then(() => console.log('D'))
B.then(() => console.log('E'))
C.then(() => console.log('F'))
C.then(() => console.log('G'))
// A
// B
// C
// D
// E
// F
// G

5.3.2 Параллельная композиция промисов с Promise.all и Promise.race

let p1 = Promise.all([
  Promise.resolve(),
  Promise.resolve(),
])

// Элементы в итерируемом параметре приводятся к промису
// с использованием Promise.resolve()
let p2 = Promise.all([3, 4])

// Пустой итерируемый параметр эквивалентен to Promise.resolve()
let p3 = Promise.all([])

// Неверный синтаксис
let p4 = Promise.all()
// TypeError: cannot read Symbol.iterator of undefined

// Составной промис разрешается только после разрешения каждого содержащегося в нем промиса:
let p = Promise.all([
  Promise.resolve(),
  new Promise(resolve => setTimeout(resolve, 1000)),
])

setImmediate(() => console.log(p)) // Promise <pending>

p.then(() => setImmediate(console.log('all() resolved!')))
// all() resolved! (Спустя ~1000 мс)

// Навсегда останется в ожидании
let p1 = Promise.all([new Promise(() => {})])

setImmediate(() => console.log(p1)) // Promise <pending>

// Единственное отклонение вызывает отклонение составного промиса
let p2 = Promise.all([
  Promise.resolve(),
  Promise.reject(),
  Promise.resolve(),
])

setImmediate(() => console.log(p2)) // Promise <rejected>
// Uncaught (in promise) undefined

let p1 = new Promise(resolve => resolve(1))
let p2 = new Promise(resolve => resolve(2))
let p3 = new Promise(resolve => resolve(3))

let all = Promise.all([p1, p2, p3])

all.then(e => console.info(e)) // [ 1, 2, 3 ]

let p1 = new Promise(resolve => resolve(1))
let p2 = new Promise((resolve, reject) => reject(2))
let p3 = new Promise((resolve, reject) => reject(3))

let all = Promise.all([p1, p2, p3])

all.catch(e => console.info(e)) // 2

let p1 = Promise.race([
  Promise.resolve(),
  Promise.resolve(),
])

// Элементы в итерируемом параметре приводятся к промисам
// с использованием Promise.resolve()
let p2 = Promise.race([3, 4])

// Пустой итерируемый объект эквивалентен new Promise(() => {})
let p3 = Promise.race([])

// Неверный синтаксис
let p4 = Promise.race()
// TypeError: cannot read Symbol.iterator of undefined

// Сначала происходит разрешение, отклонение по тайм-ауту игнорируется
let p1 = Promise.race([
  Promise.resolve(3),
  new Promise((resolve, reject) => reject()),
])
console.log(p1) // Promise <resolved>: 3

// Сначала происходит отклонение, разрешение по тайм-ауту игнорируется
let p2 = Promise.race([
  Promise.reject(4),
  new Promise((resolve, reject) => resolve()),
])
console.log(p2) // Promise <rejected>: 4

// Порядок обхода — значение для расчета
let p3 = Promise.race([
  Promise.resolve(5),
  Promise.resolve(6),
  Promise.resolve(7),
])
console.log(p3) // Promise <resolved>: 5

// Хотя только первая причина отклонения будет указана в
// обработчике отклонений, вторая причина отклонения будет просто
// обработана без ошибок
let p = Promise.race([
  Promise.reject(3),
  new Promise((resolve, reject) => setImmediate(reject)),
])

p.catch(reason => setImmediate(() => console.log(reason))) // 3
// Нет необработанных ошибок

5.3.3 Серийная композиция промисов

function addTwo (x) { return x + 2 }
function addThree (x) { return x + 3 }
function addFive (x) { return x + 5 }
function addTen (x) {
  return addFive(addTwo(addThree(x)))
}

console.log(addTen(7)) // 17

function addTwo (x) { return x + 2 }
function addThree (x) { return x + 3 }
function addFive (x) { return x + 5 }
function addTen (x) {
  return Promise.resolve(x)
    .then(addTwo)
    .then(addThree)
    .then(addFive)
}

addTen(8).then(console.log) // 18

function addTwo (x) { return x + 2 }
function addThree (x) { return x + 3 }
function addFive (x) { return x + 5 }
function addTen (x) {
  return [addTwo, addThree, addFive]
    .reduce((promise, fn) => promise.then(fn), Promise.resolve(x))
}

addTen(8).then(console.log) // 18

function addTwo (x) { return x + 2 }
function addThree (x) { return x + 3 }
function addFive (x) { return x + 5 }
let addTen = compose(addTwo, addThree, addFive)

addTen(8).then(console.log) // 18

function compose (...fns) {
  return x => fns.reduce((promise, fn) => promise.then(fn), Promise.resolve(x))
}

6. Асинхронные функции

new Promise((resolve, reject) => setTimeout(() => resolve(10), 1000))

let p = new Promise((resolve, reject) => setTimeout(() => resolve(10), 1000))

p.then(console.info) // 10

function handler (x) {
  console.log(x)
}

let p = new Promise((resolve, reject) => setTimeout(() => resolve(10), 1000))

p.then(handler) // 10

async function foo () {}

let bar = async function () {}

let baz = async () => {}

class Qux {
  async qux () {}
}

async function foo () {
  console.log(1)
}
foo()

console.log(2)
// 1
// 2

async function foo () {
  console.log(1)

  return 3
}

// Добавление обработчика разрешения к возвращаемому промису
foo().then(console.log)

console.log(2)
// 1
// 2
// 3

async function foo () {
  console.log(1)

  return Promise.resolve(3)
}

// Добавление обработчика разрешения к возвращаемому промису
foo().then(console.log)

console.log(2)
// 1
// 2
// 3

// Возврат примитива
async function foo () {
  return 'foo'
}
foo().then(console.log) // foo

// Возврат объекта, недоступного для последующего просмотра
async function bar () {
  return ['bar']
}
bar().then(console.log) // ['bar']

// Возврат доступного для последующего просмотра объекта (не промиса)
async function baz () {
  const thenable = {
    then (callback) { callback('baz') },
  }
  return thenable
}
baz().then(console.log) // baz

// Возврат промиса
async function qux () {
  return Promise.resolve('qux')
}
qux().then(console.log) // qux

async function foo () {
  console.log(1)
  throw new Error(3)
}

// Прикрепление обработчика отклонения к возвращаемому промису
foo().catch(console.log)
console.log(2)
// 1
// 2
// Error: 3

async function foo () {
  console.log(1)
  Promise.reject(3)
}

// Прикрепление обработчика отклонения к возвращаемому промису
foo().catch(console.log)
console.log(2)
// 1
// 2
// Uncaught (in promise): 3

function handler (x) {
  console.log(x)
}

let p = new Promise((resolve, reject) => setTimeout(() => resolve(10), 1000))

p.then(handler) // 10

async function foo () {
  let p = new Promise((resolve, reject) => setTimeout(() => resolve(10), 1000))

  console.log(await p)
}
foo() // 3

// Асинхронно выводит "foo"
async function foo () {
  console.log(await Promise.resolve('foo'))
}
foo() // foo

// Асинхронно выводит "bar"
async function bar () {
  return await Promise.resolve('bar')
}
bar().then(console.log) // bar

// Асинхронно выводит "baz" спустя 1000 мс
async function baz () {
  await new Promise((resolve, reject) => setTimeout(resolve, 1000))
  console.log('baz')
}
baz() // baz <спустся 1000 мс

async function foo () {
  console.log(await 'foo')
}
foo() // foo

// Ожидание объекта, недоступного для просмотра
async function bar () {
  console.log(await ['bar'])
}
bar() // ['bar']

// Ожидание доступного для просмотра объекта (не промиса)
async function baz () {
  const thenable = {
    then (callback) { callback('baz') },
  }
  console.log(await thenable)
}
baz() // baz

// Ожидание промиса
async function qux () {
  console.log(await Promise.resolve('qux'))
}
qux() // qux

async function foo () {
  console.log(1)
  await (() => { throw new Error(3) })()
}

// Прикрепление обработчика отклонения к возвращаемому промису
foo().catch(console.log)
console.log(2)
// 1
// 2
// Error: 3

async function foo () {
  console.log(1)
  await Promise.reject(3)
  console.log(4) // этот код никогда не выполнится
}

// Прикрепление обработчика отклонения к возвращаемому промису
foo().catch(console.log)
console.log(2)
// 1
// 2
// 3

async function foo () {
  console.log(await Promise.resolve(1))
}
foo() // 1

// Немедленный вызов асинхронной функции-выражения
void async function () {
  console.log(await Promise.resolve(2))
}() // 2

// Недопустимо: 'await' внутри стрелочной функции
function foo () {
  const syncFn = () => {
    return await Promise.resolve('foo')
  }
  console.log(syncFn())
}

// Недопустимо: 'await' внутри объявления функции
function bar () {
  function syncFn () {
    return await Promise.resolve('bar')
  }
  console.log(syncFn())

  // Недопустимо: 'await' внутри функции-выражения
  function baz () {
    const syncFn = function () {
      return await Promise.resolve('baz')
    }
    console.log(syncFn())
  }
}

  // Недопустимо: использование функции-выражения или стрелочной функции с IIFE
function qux () {
  (function () { console.log(await Promise.resolve('qux')) })();
  (() => console.log(await Promise.resolve('qux')))()
}

6.1 Остановка и возобновление выполнения

async function foo () {
  console.log(await Promise.resolve('foo'))
}

async function bar () {
  console.log(await 'bar')
}

async function baz () {
  console.log('baz')
}

foo()
bar()
baz()
// baz
// foo
// bar

async function foo () {
  console.log(2)
}

console.log(1)
foo()
console.log(3)
// 1
// 2
// 3

async function foo () {
  console.log(2)
  await null
  console.log(4)
}

console.log(1)
foo()
console.log(3)
// 1
// 2
// 3
// 4

1. Вывод 1.
2. Вызов асинхронной функции foo.
3. (внутри foo) Вывод 2.
4. (внутри foo) Ключевое слово await приостанавливает выполнение и добавляет задачу в очередь сообщений для немедленно доступного значения null.
5. foo завершается.
6. Вывод 3.
7. Синхронный поток выполнения заканчивается.
8. Среда выполнения JavaScript удаляет задачу из очереди сообщений, чтобы возобновить выполнение.
9. 9. (внутри foo) Выполнение возобновляется; await предоставляется со значением null (которое здесь не используется).
10. 10. (внутри foo) Вывод 4.
11. 11. Возвращение foo.

async function foo () {
  console.log(2)
  console.log(await Promise.resolve(6))
  console.log(7)
}

async function bar () {
  console.log(4)
  console.log(await 8)
  console.log(9)
}

console.log(1)
foo()
console.log(3)
bar()
console.log(5)
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8
// 9

6.2 Стратегии для асинхронных функций

6.2.1 Реализация Sleep

async function sleep(delay) {
  return new Promise((resolve) => setTimeout(resolve, delay))
}

void async function foo() {
  const t0 = Date.now()
  await sleep(1500) // sleep for ~1500ms
  console.log(Date.now() - t0)
}()
// 1502

6.2.2 Максимизация распараллеливания

async function randomDelay(id) {
  // Задержка между 0 и 1000 мс
  const delay = Math.random() * 1000
  return new Promise((resolve) => setTimeout(() => {
    console.log(`${id} finished`)
    resolve()
  }, delay))
}

void async function foo() {
  const t0 = Date.now()
  await randomDelay(0)
  await randomDelay(1)
  await randomDelay(2)
  await randomDelay(3)
  await randomDelay(4)
  console.log(`${Date.now() - t0}ms elapsed`)
}()
// 0 finished
// 1 finished
// 2 finished
// 3 finished
// 4 finished
// 3341ms elapsed

async function randomDelay(id) {
  // Задержка между 0 и 1000 мс
  const delay = Math.random() * 1000
  return new Promise((resolve) => setTimeout(() => {
    console.log(`${id} finished`)
    resolve()
  }, delay))
}

void async function foo() {
  const t0 = Date.now()
  for (let i = 0; i < 5; ++i) {
    await randomDelay(i)
  }
  console.log(`${Date.now() - t0}ms elapsed`)
}()
// 0 finished
// 1 finished
// 2 finished
// 3 finished
// 4 finished
//  2219ms elapsed

async function randomDelay(id) {
  // Задержка между 0 и 1000 мс
  const delay = Math.random() * 1000
  return new Promise((resolve) => setTimeout(() => {
    setImmediate(() => console.log(`${id} finished`))
    resolve()
  }, delay))
}

void async function foo() {
  const t0 = Date.now()
  const p0 = randomDelay(0)
  const p1 = randomDelay(1)
  const p2 = randomDelay(2)
  const p3 = randomDelay(3)
  const p4 = randomDelay(4)
  await p0
  await p1
  await p2
  await p3
  await p4

  setImmediate(() => console.log(`${Date.now() - t0}ms elapsed`))
}()
// 1 finished
// 4 finished
// 3 finished
// 0 finished
// 2 finished
// 672ms elapsed

async function randomDelay(id) {
  // Задержка между 0 и 1000 мс
  const delay = Math.random() * 1000
  return new Promise((resolve) => setTimeout(() => {
    console.log(`${id} finished`)
    resolve()
  }, delay))
}

void async function foo() {
  const t0 = Date.now()
  const promises = Array(5).fill(null).map((_, i) => randomDelay(i))
  for (const p of promises)
    await p

  console.log(`${Date.now() - t0}ms elapsed`)
}()
// 4 finished
// 2 finished
// 1 finished
// 0 finished
// 3 finished
// 906ms elapsed

async function randomDelay(id) {
  // Задержка между 0 и 1000 мс
  const delay = Math.random() * 1000
  return new Promise((resolve) => setTimeout(() => {
    console.log(`${id} finished`)
    resolve(id)
  }, delay))
}

void async function foo() {
  const t0 = Date.now()

  const promises = Array(5).fill(null).map((_, i) => randomDelay(i))
  for (const p of promises)
    console.log(`awaited ${await p}`)

  console.log(`${Date.now() - t0}ms elapsed`)
}()
// 1 finished
// 2 finished
// 4 finished
// 3 finished
// 0 finished
// awaited 0
// awaited 1
// awaited 2
// awaited 3
// awaited 4
// 906ms elapsed

6.2.3 Серийное выполнение промисов

function addTwo(x) {return x + 2}
function addThree(x) {return x + 3}
function addFive(x) {return x + 5}
async function addTen(x) {
  for (const fn of [addTwo, addThree, addFive])
    x = await fn(x)

  return x
}
addTen(9).then(console.log) // 19

async function addTwo(x) {return x + 2}
async function addThree(x) {return x + 3}
async function addFive(x) {return x + 5}
async function addTen(x) {
  for (const fn of [addTwo, addThree, addFive])
    x = await fn(x)

  return x
}
addTen(9).then(console.log) // 19

6.2.4 Трассировка стека и управление памятью

function fooPromiseExecutor(resolve, reject) {
  setTimeout(reject, 1000, 'bar')
}

void function foo() {
  new Promise(fooPromiseExecutor)
}()
// Uncaught (in promise) bar
// setTimeout
// setTimeout (async)
// fooPromiseExecutor
// foo

function fooPromiseExecutor(resolve, reject) {
  setTimeout(reject, 1000, 'bar')
}

void async function foo() {
  await new Promise(fooPromiseExecutor)
}()
// Uncaught (in promise) bar
// foo
// async function (async)
// foo