map, filter, and reduce: Performance and When Not to Use Them

map, filter, and reduce: Performance and When Not to Use Them

map, filter, and reduce are great for readability, but they are not always the best choice for performance. Here is when to use a loop instead.

When to Use map/filter/reduce

• Readability: declarative code is easier to read and maintain.
• Small to medium arrays: the performance difference is negligible.
• Pure transformations: when you want a new array without mutations.
• Chaining: when you want to build a pipeline.

When to Use a Loop Instead

1. Large Arrays with Multiple Passes

// multiple passes (3 new arrays)
const result = arr
  .filter((n) => n > 0)
  .map((n) => n * 2)
  .reduce((acc, n) => acc + n, 0);

// single pass (faster for large arrays)
let result = 0;
for (const n of arr) {
  if (n > 0) result += n * 2;
}
``
Each `map`/`filter`/`reduce` creates a new array. For large arrays and many steps, a single loop is faster.

#### 2. Early Exit

```js
// find: stops at the first match
const found = arr.find((n) => n > 5);

// some: stops at the first truthy
const has = arr.some((n) => n > 5);

// every: stops at the first falsy
const all = arr.every((n) => n > 0);
``
`map`/`filter`/`reduce` always iterate the entire array. `find`/`some`/`every` can exit early. Use them when you do not need to process every element.

#### 3. Breaking Out of a Loop

`map`/`filter`/`reduce` do not support `break` or `return` (from the outer context). If you need to break, use a `for` loop.

```js
for (const n of arr) {
  if (n > 5) break;
  process(n);
}
``
#### 4. Complex Logic

If the callback logic is complex, a `for` loop with clear variables may be more readable than a long `reduce` callback.

### Performance Comparison

```js
// 1,000,000 elements
// map: ~20ms
arr.map((n) => n * 2);
// for loop: ~5ms
const result = new Array(arr.length);
for (let i = 0; i < arr.length; i++) result[i] = arr[i] * 2;
``
For 1M elements, a `for` loop is about 4x faster than `map`. But for 100 elements, the difference is negligible.

### The Takeaway

Use `map`/`filter`/`reduce` for readability with small to medium arrays. Use a `for` loop for large arrays (single pass is faster than multiple), early exit (`find`/`some`/`every` or `break`), and complex logic. Optimize only when profiling shows a problem; do not premature-optimize.