Benchmark: Some vs Filter Vs FindIndex

Script Preparation code:

var mixedArray = [];
for (var i = 0; i < 10000; i++) {
  mixedArray.push({
    first: Math.random() > 0.5 ? `first${i}` : undefined,
    second: Math.random() > 0.5 ? Date.now() : undefined
  });
}

Tests:

Default
function defaultSort(a) { const b = a .map((c, d) => ({ c, originalIndex: d })) .filter(({ c }) => c.first !== undefined); if (!b.length) return []; const c = b.filter(({ c }) => c.second !== undefined); if (!c.length) return []; if (c.length === b.length) return []; return b.map(({ originalIndex }) => originalIndex); }
reducer
function reducer(a) { return a.reduce((acc, c, i) => { if (c.first !== undefined && c.second === undefined) { acc.push(i); } return acc; }, []); }
forLoop
function forLoop(a) { let result = []; for (let i = 0; i < a.length; i++) { if (a[i].first !== undefined && a[i].second === undefined) { result.push(i); } } return result; }
Foreach
function forEachMethod(arr) { let result = []; arr.forEach((item, index) => { if (item.first !== undefined && item.second === undefined) { result.push(index); } }); return result; }
Filter
function filterMethod(arr) { return arr .map((item, index) => (item.first !== undefined && item.second === undefined) ? index : -1) .filter(index => index !== -1); }
Reduce with object
function reduceObject(arr) { return arr.reduce((acc, curr, i) => { if (curr.first !== undefined && curr.second === undefined) { acc.push(i); } return acc; }, []); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Default
reducer
forLoop
Foreach
Filter
Reduce with object

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36

Browser/OS: Chrome 115 on Windows

View result in a separate tab

Test name	Executions per second
Default	1783982080.0 Ops/sec
reducer	1048914304.0 Ops/sec
forLoop	1807914752.0 Ops/sec
Foreach	1804217984.0 Ops/sec
Filter	1780095104.0 Ops/sec
Reduce with object	1785162880.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

I'll break down the benchmark and explain what's being tested, the different approaches, their pros and cons, and other considerations.

**Benchmark Overview**

The benchmark is designed to compare the performance of six different methods for filtering an array of objects:

1. `Default` (using the built-in `filter()` method)
2. `reducer` (using a custom reducer function)
3. `forLoop` (using a traditional `for` loop)
4. `Foreach` (using the `forEach()` method)
5. `Filter` (using a custom filtering approach with `map()`)
6. `Reduce with object` (using the `reduce()` method with an object accumulator)

**Approaches Compared**

Here's a brief description of each approach:

1. **Default**: Using the built-in `filter()` method, which is a convenient and efficient way to filter arrays.
2. **reducer**: Using a custom reducer function that iterates over the array and pushes indices of objects with certain properties into an accumulator array.
3. **forLoop**: Using a traditional `for` loop to iterate over the array and push indices of objects with certain properties into an accumulator array.
4. **Foreach**: Using the `forEach()` method, which is similar to `filter()`, but doesn't modify the original array.
5. **Filter**: Using a custom filtering approach with `map()` that maps each object to its index if it has a specific property, and then filters out objects without that property.
6. **Reduce with object**: Using the `reduce()` method with an object accumulator, which accumulates indices of objects with certain properties in an object.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

1. **Default**: Pros: concise, efficient, easy to use; Cons: may not be suitable for all data structures or edge cases.
2. **reducer**: Pros: flexible, can handle complex filtering logic; Cons: requires manual accumulator management, less intuitive than `filter()`.
3. **forLoop**: Pros: simple, familiar, works well with arrays; Cons: verbose, less efficient than `filter()` or other approaches.
4. **Foreach**: Pros: concise, easy to read, doesn't modify original array; Cons: may not be as efficient as `filter()`, relies on `forEach()` which can be slower.
5. **Filter**: Pros: concise, easy to understand, works well with arrays; Cons: assumes specific property structure, less flexible than `reducer`.
6. **Reduce with object**: Pros: flexible, handles complex filtering logic; Cons: requires manual accumulator management, may be slower due to object creation.

**Other Considerations**

* The benchmark uses Chrome as the browser, which might not represent all use cases.
* The data structure used is an array of objects, which might not be representative of all data structures (e.g., arrays with different types of elements).
* The filtering logic assumes specific property names and values, which may not hold true for all datasets.

Overall, this benchmark provides a useful comparison of different approaches for filtering arrays of objects, highlighting the strengths and weaknesses of each method.

Related benchmarks:

Some vs Filter Vs FindIndex (version: 0)

Comparing performance of: Default vs reducer vs forLoop vs Foreach vs Filter vs Reduce with object

Created: one year ago by: Guest

Jump to the latest result

Default

reducer

forLoop

Foreach

Filter

Reduce with object

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):