JavaScript Async filter Keeps Every Item: Await the Decisions

Why even an immediately false result keeps the item#

The ECMAScript filter algorithm converts each callback result to a boolean before deciding whether to copy the element. An async callback returns a promise even when its body contains no await. That object is truthy whether it eventually fulfills with false or true.

1
const wrong = await [1, 2, 3].filter(async () => false);
2
console.log(JSON.stringify(wrong)); // [1,2,3]

The outer await receives an array of original values, not a batch of callback promises. It cannot retrieve those discarded promises. If a callback rejects, this pattern also leaves its rejection outside the caller’s awaited result.

Pair values with decisions before selecting#

This helper accepts an ordinary dense array and a predicate whose resolved result uses boolean truthiness. It takes a shallow snapshot before invoking any predicate. The callback receives the value and its snapshot index; it does not receive the original array or a custom this binding.

1
async function filterAsync(values, predicate) {
2
  const snapshot = [...values];
3
  const rows = await Promise.all(snapshot.map(async (value, index) => ({
4
    value,
5
    keep: await predicate(value, index),
6
  })));
7
  return rows.filter(row => row.keep).map(row => row.value);
8
}

The filter checks row.keep, not row.value. Returning keep ? value : null and then applying filter(Boolean) would incorrectly discard retained 0, false, and empty strings. That is the separate falsy-value filtering trap.

Promise.all preserves input order in its successful result, regardless of fulfillment order. Here each row also carries the value captured before its asynchronous check. Filtering those rows avoids rereading a source array that another part of the program may have changed while the checks were pending.

Verify reverse completion and input mutation#

Save the helper above followed by this fixture as async-filter.mjs, then run node async-filter.mjs. Both blocks together were executed during article preparation on macOS with Node.js 24.13.0, on October 16, 2026. No packages, timers, or network service are needed.

The gates deliberately finish checks in reverse order. Replacing every source element while the gates are closed tests whether selection returns the captured inputs or the replacements.

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

3
const source = [0, false, ''];
4
const releases = [];
5
const completed = [];
6
const batch = filterAsync(source, (value, index) => new Promise(resolve => {
7
  releases[index] = () => {
8
    completed.push(index);
9
    resolve(index !== 1);
10
  };
11
}));
12
assert.equal(releases.length, 3);
13
source.splice(0, source.length, 'replacement');
14
releases[2]();
15
releases[1]();
16
releases[0]();
17
const kept = await batch;
18
assert.deepEqual(completed, [2, 1, 0]);
19
assert.deepEqual(kept, [0, '']);
20
console.log(`completion indexes: ${completed.join(',')}`);
21
console.log(`retained snapshot values: ${JSON.stringify(kept)}`);
22
console.log(`current source: ${JSON.stringify(source)}`);
23

24
assert.deepEqual(await filterAsync([false], async () => true), [false]);
25
assert.deepEqual(await filterAsync([1, 2], async () => false), []);
26
let calls = 0;
27
assert.deepEqual(await filterAsync([], async () => { calls++; }), []);
28
assert.equal(calls, 0);
29
await assert.rejects(
30
  filterAsync([1, 2], async value => {
31
    if (value === 2) throw new Error('lookup failed');
32
    return true;
33
  }),
34
  /lookup failed/,
35
);
36
console.log('false values, all-false, empty input, and rejection: passed');

Expected output:

1
completion indexes: 2,1,0
2
retained snapshot values: [0,""]
3
current source: ["replacement"]
4
false values, all-false, empty input, and rejection: passed

This demonstrates association and selection for successful checks, plus propagation of a rejected predicate. It does not measure API throughput or prove anything about remote authorization checks.

Choose a failure and start policy#

The concurrent helper starts a predicate for every snapshot item without a concurrency cap. For a rate-limited endpoint, use a bounded worker policy or the serial form below. Choosing serial versus concurrent work is a separate decision from whether a value passes the filter.

1
async function filterAsyncSerial(values, predicate) {
2
  const snapshot = [...values];
3
  const kept = [];
4
  for (let index = 0; index < snapshot.length; index++) {
5
    const value = snapshot[index];
6
    if (await predicate(value, index)) kept.push(value);
7
  }
8
  return kept;
9
}

A rejected Promise.all does not cancel the other checks. If checks share a resource that needs cleanup, use the wait-before-cleanup pattern rather than closing that resource as soon as the aggregate rejects. A lookup error and a valid negative answer are different outcomes; silently converting every error to false can hide a failed batch.

Keep the snapshot boundary explicit#

The snapshot protects array membership and value references. It does not deep-clone objects or freeze their fields. A concurrent mutation to record.enabled can still affect a predicate that reads that field later. Snapshot the needed fields separately if the application requires an immutable decision input.

These helpers deliberately require dense arrays. Native filter skips empty slots; spreading a sparse array produces undefined entries, which these helpers will check. They are application helpers, not complete replacements for native filter semantics on sparse arrays, subclasses, or custom iterables.

Supplemental assertions checked the serial helper’s value retention and stop-on-error behavior, shallow object references, and the sparse-input difference. Browser runtimes, cancellation, concurrency limits, and real network failures were not exercised. Keep the decision and original value together, then make the final selection only after the decisions have resolved.

References: ECMAScript: Array.prototype.filter, ECMAScript: PerformPromiseAll, MDN: filter, MDN: Promise.all. Sources checked October 16, 2026; execution boundary described above.