JavaScript await forEach Does Not Wait: Choose Serial or Concurrent Work

Why the outer await completes early#

The ECMAScript forEach algorithm calls each callback and returns undefined. It does not collect callback results. An async callback returns a promise, so an enclosing try/catch around await forEach(...) also cannot catch that callback’s rejected promise. Handle it within the callback or, preferably for a batch, return and await the task promises.

MDN documents that forEach expects synchronous callbacks. Adding another await around it does not supply the missing completion promise. Awaiting a non-promise value still defers continuation, but it does not discover asynchronous work launched elsewhere.

Verify completion and overlap without timers#

Save the following as async-loop.mjs and run node async-loop.mjs. This exact fixture was executed during article preparation on macOS with Node.js 24.13.0, on October 11, 2026. It needs no packages.

A gate holds both operations before completion. The fixture checks whether the batch has returned while the gate remains closed, then releases it and checks the event order and returned values. Capturing tasks is test instrumentation to drain the deliberately ignored work; it is not a repair to the forEach expression.

1
import assert from 'node:assert/strict';
2

3
async function inspect(mode) {
4
  let release;
5
  const gate = new Promise(resolve => { release = resolve; });
6
  const events = [];
7
  const tasks = [];
8
  let returned = false;
9
  const items = ['A', 'B'];
10

11
  function work(item) {
12
    const task = (async () => {
13
      events.push(`start:${item}`);
14
      await gate;
15
      events.push(`end:${item}`);
16
      return item.toLowerCase();
17
    })();
18
    tasks.push(task); // Test instrumentation: lets us drain ignored tasks.
19
    return task;
20
  }
21

22
  const batch = (async () => {
23
    let result;
24
    if (mode === 'forEach') {
25
      result = await items.forEach(async item => { await work(item); });
26
    } else if (mode === 'serial') {
27
      result = [];
28
      for (const item of items) result.push(await work(item));
29
    } else {
30
      result = await Promise.all(items.map(work));
31
    }
32
    returned = true;
33
    return result;
34
  })();
35

36
  await Promise.resolve();
37
  const before = { returned, events: [...events] };
38
  release();
39
  const result = await batch;
40
  await Promise.all(tasks);
41

42
  const serial = mode === 'serial';
43
  assert.equal(before.returned, mode === 'forEach');
44
  assert.deepEqual(before.events, serial ? ['start:A'] : ['start:A', 'start:B']);
45
  assert.deepEqual(events, serial
46
    ? ['start:A', 'end:A', 'start:B', 'end:B']
47
    : ['start:A', 'start:B', 'end:A', 'end:B']);
48
  assert.deepEqual(result, mode === 'forEach' ? undefined : ['a', 'b']);
49

50
  console.log(`${mode} before: ${JSON.stringify(before)}`);
51
  console.log(`${mode} after: ${JSON.stringify({ events, result: result ?? null })}`);
52
}
53

54
for (const mode of ['forEach', 'serial', 'concurrent']) await inspect(mode);

Expected output for that environment:

1
forEach before: {"returned":true,"events":["start:A","start:B"]}
2
forEach after: {"events":["start:A","start:B","end:A","end:B"],"result":null}
3
serial before: {"returned":false,"events":["start:A"]}
4
serial after: {"events":["start:A","end:A","start:B","end:B"],"result":["a","b"]}
5
concurrent before: {"returned":false,"events":["start:A","start:B"]}
6
concurrent after: {"events":["start:A","start:B","end:A","end:B"],"result":["a","b"]}

The output renders the forEach result as null for visibility; its assertion checks the actual value is undefined.

While the gate is closed, forEach has already returned and both operations have started. The serial loop has started only A and has not returned. The concurrent batch has started both operations but has not returned. After release, the serial trace puts end:A before start:B; the concurrent trace shows both starts first.

This checks scheduling and completion ownership for two successful tasks. It is not a network benchmark, a throughput comparison, or a test of database ordering. The shared gate makes both concurrent completions happen in input order here; real operations may finish in another order.

Pick the start policy your work requires#

With map, the callback’s returned values form the new array. Return the operation’s promise. A block callback such as items.map(item => { work(item); }) returns undefined for every item, so awaiting Promise.all over that array still loses the work. Use item => work(item) or item => { return work(item); }.

Promise.all preserves input order in its result array, even if operations finish out of order. That does not serialize writes. Mapping starts the calls without a concurrency cap; a large batch against a rate-limited service needs a separate bounded worker policy.

The examples assume an ordinary dense array that is not modified during processing. forEach skips empty slots; array iteration with for...of yields undefined for those slots. Replacing the loop on a sparse array can therefore change which inputs reach your operation.

Make failures belong to the awaited batch#

An awaited serial operation that throws stops the loop before later operations start, unless your code catches the error and continues. With Promise.all, rejection makes the aggregate reject, but the other mapped operations have already been invoked. It does not cancel them or wait for their settlement before rejecting. If those tasks share a resource, follow the wait-before-cleanup pattern.

Supplemental Node.js assertions verified serial failure stopping before C, mapped async failure still invoking C, missing callback returns, sparse-array visitation, and a callback rejection bypassing the enclosing forEach catch. The rejection check attached a handler directly to the task to avoid an unhandled rejection. No browser, HTTP endpoint, database, cancellation API, or rate limiter was exercised.

Keep the batch’s completion promise in the caller’s control. Then choose separately whether the next operation may start before the previous one finishes.

References: ECMAScript: Array.prototype.forEach, ECMAScript: PerformPromiseAll, MDN: forEach, MDN: map, MDN: for…of, MDN: await, MDN: Promise.all. Checked October 11, 2026; fixture executed on Node.js 24.13.0.