Run results for: Fastest Partion of Arrays (heavy predicate)

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.

Run details:

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: Chrome 96

Operating system: Windows

Device Platform: Desktop

Date tested: 2 years ago

Test name	Executions per second
Two filters	786.5 Ops/sec
forEach	1703.3 Ops/sec
for of	1746.9 Ops/sec
Reduce + Spread	527.1 Ops/sec
reduce push	1661.1 Ops/sec

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

Run results for: Fastest Partion of Arrays (heavy predicate)

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.

Two filters

forEach

for of

Reduce + Spread

reduce push