异步等待回调行为

Question

I'm trying to understand async-await behaviour with callbacks. Firstly, let's look at this function:

const assert = require('assert')

async function promiseReturner() {
  return Promise.resolve(Promise.resolve(Promise.resolve(Promise.resolve(42))))
}

(async function() {
  assert.equal(await promiseReturner(), 42)
})()

This leads me to safely conclude that the await keyword always resolves a promise, no matter what.

Now here's a function that returns a number after a second:

async function addTenAndReturnNumber(number) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve(number)
    }, 1000)
  })
}

I ran two experiments with this. First the forEach loop.

(async function() {
  let variable;
  const result = [41, 42, 43].forEach(async (number) => {
    variable = await addTenAndReturnNumber(number)
  })
  console.log(variable) // undefined
})()

Okay, so great. It would appear that the forEach callback evaluated in the next tick, and hence variable is undefined (although that's exactly what one would think await shouldn't do). Let's try map next:

(async function() {
  const result = [41, 42, 43].map(async (number) => {
    return await addTenAndReturnNumber(number)
  })
  console.log(result) // [Promise {}, Promise {}, Promise {}]
})()

I would assume that it would either return [51, 52, 53] , or as before an undefined

Please note that my question is around the behaviour and why this is designed like so - is this a conscious decision on the part of the spec? I am aware that I can use a for...of or a Promise.all

Thanks!

Answer 1

async functions always return a promise (if you await the promise, you'll get its actual value).

Passing an async function to map() will return an array of what the async function returns, which is, of course, a promise.

Your forEach() callback runs immediately, but once it hits the await , it will only resume running after the promise resolves (which is guaranteed to be after your code finishes running).