Benchmark: Fastest Partion of Arrays (heavy predicate)

Fastest Partion of Arrays (heavy predicate) (version: 0)

Define a method that takes an iterable/array and a predicate, and returns two arrays, one with passing elements and one with failed elements. This is useful where you usually use filter(), but want also want an array with the elements that failed the filter.

Comparing performance of: Two filters vs forEach vs for of vs Reduce + Spread vs reduce push

Created: 2 years ago by: Registered User

Jump to the latest result

Script Preparation code:

function getRandomIntInclusive(min, max) {
    min = Math.ceil(min);
    max = Math.floor(max);
    return Math.floor(Math.random() * (max - min + 1)) + min; //The maximum is inclusive and the minimum is inclusive 
}

var arrayOfRandomInts = Array.from({
    length: 2500
}, () => getRandomIntInclusive(1, 10));

function isValid(e) {
    for (let i = 0; i < 1000; i++) {
        // Fake workload to simulate a "heavy" predicate
    }

    return e > 5;
}

function partitionTwoFilters(array, predicate) {
    return [
        array.filter((i) => predicate(i)),
        array.filter((i) => !predicate(i)),
    ];
}

function partitionForEach(array, predicate) {
    const pass = [];
    const fail = [];
    array.forEach(elem => {
        predicate(elem) ? pass.push(elem) : fail.push(elem);
    });
    return [pass, fail];
}

function partitionForOf(array, predicate) {
    const result = [];
    const rest = [];
    for (const value of array) {
        if (predicate(value, result.length, result)) {
            result.push(value);
        } else {
            rest.push(value);
        }
    }
    return [result, rest];
}

function partitionReduceSpread(array, predicate) {
    return array.reduce(([pass, fail], elem) => {
        return predicate(elem) ? [
            [...pass, elem], fail
        ] : [pass, [...fail, elem]];
    }, [
        [],
        []
    ]);
}

// https://codereview.stackexchange.com/a/162879
function partitionReducePush(array, predicate) {
    return array.reduce(
        (result, element) => {
            result[predicate(element) ? 0 : 1].push(element);
            return result;
        },
        [[], []],
    );
}

Tests:

Two filters
const [pass, fail] = partitionTwoFilters(arrayOfRandomInts, isValid);
forEach
const [pass, fail] = partitionForEach(arrayOfRandomInts, isValid);
for of
const [pass, fail] = partitionForOf(arrayOfRandomInts, isValid);
Reduce + Spread
const [pass, fail] = partitionReduceSpread(arrayOfRandomInts, isValid);
reduce push
const [pass, fail] = partitionReducePush(arrayOfRandomInts, isValid);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Two filters
forEach
for of
Reduce + Spread
reduce push

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

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

Browser/OS: Chrome 96 on Windows

View result in a separate tab

Test name	Executions per second
Two filters	791.9 Ops/sec
forEach	1706.3 Ops/sec
for of	1725.1 Ops/sec
Reduce + Spread	576.5 Ops/sec
reduce push	1651.8 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, compared options, pros and cons of each approach, and other considerations.

**Benchmark Definition**

The benchmark measures the performance of different approaches for partitioning an array into two parts based on a predicate (a condition). The predicate function `isValid` checks if a number is greater than 5. The goal is to create a method that can be used in scenarios where you need both passed and failed elements.

**Comparison Options**

The benchmark compares four different approaches:

1. **Two Filters**: Using the built-in `filter()` method twice, once for each part of the partition.
2. **ForEach**: Iterating over the array using the `forEach` method and pushing elements to two separate arrays based on the predicate.
3. **For Of**: Using a `for...of` loop with an iterator to partition the array.
4. **Reduce + Spread**: Using the `reduce()` method with spread syntax (`[...pass, elem]`) to build the passed array and `(...fail, elem)` to build the failed array.
5. **Reduce Push**: Using the `reduce()` method with push() to update an accumulator array.

**Pros and Cons of Each Approach**

1. **Two Filters**:
	* Pros: Simple, built-in method, no extra memory allocation needed.
	* Cons: Can be slower due to multiple filter calls, and has a higher overhead due to creating two new arrays.
2. **ForEach**:
	* Pros: Easy to implement, flexible, and allows for more control over the partitioning process.
	* Cons: Requires iterating over the array twice (once for each part), which can be slower than a single pass through the data.
3. **For Of**:
	* Pros: Efficient use of iterator, no extra memory allocation needed, and potentially faster due to less overhead from filter calls.
	* Cons: May not be as straightforward to implement, especially for those familiar with traditional loops.
4. **Reduce + Spread**:
	* Pros: Memory-efficient, can be faster due to reduced overhead from creating multiple arrays.
	* Cons: Requires understanding of spread syntax and potentially more complex implementation.
5. **Reduce Push**:
	* Pros: Similar performance characteristics to Two Filters, but with a different implementation approach.
	* Cons: May not be as straightforward to understand or implement for those unfamiliar with reduce().

**Other Considerations**

* **Memory Allocation**: Some approaches (like `Two Filters`) allocate more memory due to creating multiple arrays. Others (like `For Of` and `Reduce + Spread`) are more memory-efficient.
* **Overhead from Filter Calls**: Approaches like `Two Filters` have higher overhead due to repeated filter calls, which can impact performance.

**Benchmark Results**

The benchmark results show the execution speed of each approach, with Chrome 96 as the testing device. The fastest approach is `For Of`, followed closely by `Reduce + Spread`. The other approaches are slower, with `Two Filters` being one of the slower options due to its repeated filter calls.

In conclusion, the choice of partitioning approach depends on factors like performance requirements, memory constraints, and personal preference for implementation complexity.

Related benchmarks:

Fastest Partion of Arrays (heavy predicate) (version: 0)

Define a method that takes an iterable/array and a predicate, and returns two arrays, one with passing elements and one with failed elements. This is useful where you usually use filter(), but want also want an array with the elements that failed the filter.

Comparing performance of: Two filters vs forEach vs for of vs Reduce + Spread vs reduce push

Created: 2 years ago by: Registered User

Jump to the latest result

Two filters

forEach

for of

Reduce + Spread

reduce push

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):