Benchmark: concat map - MeasureThat.net

Script Preparation code:

function concatMap1(xs, fn) {
    return xs.map(v => fn(v)).reduce((acc, arr) => Array.isArray(arr) ? acc.concat(arr) : acc.concat([arr]), []);
}

function concatMap2(xs, fn) {
    var res = [];
    for (var i = 0; i < xs.length; i++) {
        var x = fn(xs[i], i);
        if (Array.isArray(x)) res.push.apply(res, x);
        else res.push(x);
    }
    return res;
}

Tests:

concat 1
concatMap1(Array(1000).fill(0), v => [v-1, v, v+1])
concat 2
concatMap2(Array(1000).fill(0), v => [v-1, v, v+1])
concat 1 small to large
concatMap1([1, 2, 3, 4], v => Array(1000).fill(v))
concat 2 small to large
concatMap2([1, 2, 3, 4], v => Array(1000).fill(v))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
concat 1
concat 2
concat 1 small to large
concat 2 small to large

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript benchmarks!

**Benchmark Definition**

The benchmark compares two different implementations of the `concatMap` function, which is used to concatenate arrays in a map-like fashion. The two implementations are:

1. `concatMap1(xs, fn)`: This implementation uses the `map` method to create an array of transformed values, and then uses the `reduce` method to concatenate these arrays.
2. `concatMap2(xs, fn)`: This implementation uses a simple loop to iterate over the input array, transforming each value using the provided function. If the transformed value is an array, it is concatenated with the existing result.

**Options Compared**

The two implementations are compared in terms of their performance. The benchmark measures the number of executions per second for each implementation.

**Pros and Cons of Each Approach**

1. `concatMap1(xs, fn)`: This approach uses functional programming techniques to create an array of transformed values, which can be more concise and expressive. However, it may incur overhead due to the use of `map` and `reduce`.
	* Pros: Concise implementation, easy to read and maintain.
	* Cons: May incur performance overhead due to functional programming overhead.
2. `concatMap2(xs, fn)`: This approach uses a simple loop to iterate over the input array, which can be more straightforward and efficient. However, it may require more lines of code and be less readable than the first implementation.
	* Pros: Efficient, simple loop-based implementation.
	* Cons: May require more lines of code, less readable.

**Library**

There is no specific library mentioned in the benchmark definition. The implementations use built-in JavaScript methods such as `map`, `reduce`, and array concatenation.

**Special JS Feature or Syntax**

There are no special features or syntax used in this benchmark that are not part of standard JavaScript. Both implementations should be compatible with most modern browsers and JavaScript environments.

**Alternatives**

If you're interested in exploring alternative approaches, here are a few options:

1. Using `flatMap` instead of `concat`: Some modern browsers and JavaScript engines support the `flatMap` method, which can simplify the implementation and improve performance.
2. Using a loop with `push` instead of array concatenation: Instead of using `concat` or `reduce` to concatenate arrays, you could use a simple loop with `push` to build up the result array incrementally.
3. Using a specialized library or framework: If you're working on a performance-critical application, you might consider using a specialized library or framework that provides optimized implementations of the `concatMap` function.

Keep in mind that these alternatives may not be suitable for all use cases and may introduce additional complexity or overhead.

Related benchmarks:

concat map (version: 2)

comparing concat map implementations

Comparing performance of: concat 1 vs concat 2 vs concat 1 small to large vs concat 2 small to large

Created: 9 years ago by: Registered User

Jump to the latest result

concat 1

concat 2

concat 1 small to large

concat 2 small to large

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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