Benchmark: native built-in filter map function vs native logic for filter, map (about huge map #2)

HTML Preparation code:

<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.core.js"></script>

Script Preparation code:

var numbers = [10, 40, 230, 15, 18, 51, 1221, 24, 36, 28, 10, 6, 8, 7, 55, 89, 256, 102, 1, 23, 41, 38, 7, 2, 5, 9, 60]
var input = []
Array(1000).fill().forEach(_ => input.push(...numbers))

Tests:

native built-in filter
input.filter(i => i > 10).map(x => x * x)
native logic for filter, map
let result = [] for (let x in input) { if (x > 10) result.push(x * x) }
using forEach
let result = [] input.forEach(x => { if (x > 10) result.push(x * x) })
lodash chain
_.chain(input).filter(x => x > 10).map(x => x * x).value()
lodash not chain
_.map(_.filter(input, x => x > 10), x => x * x)
native length refer
let result = [] let length = input.length for (let i = 0; i < length; ++i) { let x = input[i] if (x > 10) result.push(x * x) }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
native built-in filter
native logic for filter, map
using forEach
lodash chain
lodash not chain
native length refer

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.122 Safari/537.36

Browser/OS: Chrome 80 on Mac OS X 10.14.4

View result in a separate tab

Test name	Executions per second
native built-in filter	1170.5 Ops/sec
native logic for filter, map	516.1 Ops/sec
using forEach	2036.9 Ops/sec
lodash chain	933.9 Ops/sec
lodash not chain	927.8 Ops/sec
native length refer	490.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested, compared, and the pros and cons of each approach.

**Benchmark Definition**

The benchmark measures the performance of different approaches to filter and map a large array of numbers. The array is created with 1000 elements using `Array(1000).fill().forEach(_ => input.push(...numbers))`, where `numbers` is an array containing various values.

**Test Cases**

There are six test cases:

1. **Native built-in filter**: Using the native JavaScript `filter()` method to remove elements less than or equal to 10 from the array.
2. **Native logic for filter, map**: Implementing a custom loop using `for...in` and `if` statements to achieve the same result as above.
3. **Using forEach**: Utilizing the `forEach()` method to iterate over the array and perform the filtering and mapping operations.
4. **Lodash chain**: Using the Lodash library to chain together the filtering and mapping operations using `_chain()`, `filter()`, and `map()`.
5. **Lodash not chain**: Using the Lodash library, but without chaining the methods together, instead passing each method individually as arguments to the previous one.
6. **Native length refer**: A seemingly unrelated test case that uses a custom loop with a variable `length` to iterate over the array.

**Comparison**

Each test case measures the performance of its respective approach on the large array of numbers.

**Options Compared**

* Native JavaScript `filter()` vs custom implementation using `for...in` and `if`
* Native JavaScript `forEach()` vs custom implementation
* Lodash library with and without chaining methods

**Pros and Cons**

1. **Native built-in filter**: Fast, optimized for performance. However, may not be as readable or maintainable as other approaches.
2. **Native logic for filter, map**: Custom implementation can be more readable, but may not be optimized for performance like the native `filter()` method.
3. **Using forEach**: Relatively simple and easy to understand, but may not be optimized for performance compared to other methods.
4. **Lodash chain**: Convenient way to perform multiple operations on a dataset, but may introduce overhead due to the additional function calls. Chaining without Lodash can eliminate this overhead.
5. **Lodash not chain**: Provides more control over the execution order of methods, but still relies on the Lodash library for performance.

**Library**

The Lodash library is used in two test cases: `lodash chain` and `lodash not chain`. It provides a convenient way to perform multiple operations on a dataset using its functional programming style.

**Special JavaScript Feature or Syntax**

There is no special JavaScript feature or syntax mentioned in the benchmark. However, some of the test cases rely on the existence of certain methods or properties, such as `Array.prototype.forEach()` and `String.prototype.includes()`.

Related benchmarks:

native built-in filter map function vs native logic for filter, map (about huge map #2) (version: 0)

native built-in filter map function vs native logic for filter, map

Comparing performance of: native built-in filter vs native logic for filter, map vs using forEach vs lodash chain vs lodash not chain vs native length refer

Created: 4 years ago by: Guest

Jump to the latest result

native built-in filter

native logic for filter, map

using forEach

lodash chain

lodash not chain

native length refer

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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

native built-in filter map function vs native logic for filter, map (about huge map #2) (version: 0)

native built-in filter map function vs native logic for filter, map

Comparing performance of: native built-in filter vs native logic for filter, map vs using forEach vs lodash chain vs lodash not chain vs native length refer

Created: 4 years ago by: Guest

Jump to the latest result

native built-in filter

native logic for filter, map

using forEach

lodash chain

lodash not chain

native length refer

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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

Comparing performance of: native built-in filter vs native logic for filter, map vs using forEach vs lodash chain vs lodash not chain vs native length refer

native length refer