Benchmark: Lodash forEach VS native for loop VS native forEach VS native map

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/lodash/4.17.15/lodash.min.js"></script>

Script Preparation code:

var values = [{a: 30310}, {b: 100303}, {c: 3040494}]

Tests:

lodash.forEach
let count = 0; _.forEach(values, (value) => { if (value.a != null) { count++; } })
native for
let count = 0; const length = values.length; for (var i = 0; i < length; i++) { if (values[i].a != null) { count++; } }
native forEach
let count = 0; values.forEach((value) => { if (value.a != null) { count++; } })
native map
let count = 0; values.map((value) => { if (value.a != null) { count++; } })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash.forEach
native for
native forEach
native map

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36

Browser/OS: Chrome 109 on Linux

View result in a separate tab

Test name	Executions per second
lodash.forEach	3128848.0 Ops/sec
native for	3340816.8 Ops/sec
native forEach	8956624.0 Ops/sec
native map	6891256.5 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided JSON represents a JavaScript benchmark test case created using MeasureThat.net. The test compares four different approaches to iterate over an array of objects: Lodash's `forEach`, native `for` loop, native `forEach` method, and native `map` method.

**Approaches Compared**

1. **Lodash's `forEach`**: This approach uses the `_` alias from Lodash to call its `forEach` function on the input array.
2. **Native `for` loop**: This approach uses a traditional `for` loop to iterate over the array elements, accessing each element using its index (`i`) and the array length (`length`).
3. **Native `forEach` method**: This approach directly calls the native `forEach` method on the input array.
4. **Native `map` method**: This approach uses the native `map` method to create a new array with transformed elements, but then iterates over this new array using another `for` loop.

**Pros and Cons of Each Approach**

1. **Lodash's `forEach`**:
	* Pros: Easy to use, concise code, avoids manual indexing.
	* Cons: External dependency on Lodash, might introduce overhead due to function call.
2. **Native `for` loop**:
	* Pros: Direct access to array elements, no external dependencies.
	* Cons: More verbose code, requires manual indexing and length checks.
3. **Native `forEach` method**:
	* Pros: Native implementation, potentially faster than Lodash's `forEach`.
	* Cons: Might require additional setup or configuration in some browsers.
4. **Native `map` method with iteration**:
	* Pros: Convenient to use, creates a new array with transformed elements.
	* Cons: Iterates over the result of `map`, which may not be what the user expects.

**Special Features and Libraries**

1. **Lodash**: A popular JavaScript utility library that provides various functions for tasks like string manipulation, object manipulation, and array iteration.
2. **Native implementations**: The native `forEach` method is implemented in WebAssembly (WASM) or V8 (for Chrome browsers), while the native `map` method uses a different implementation.

**Other Considerations**

* **Browser differences**: The performance results may vary across different browsers due to their respective JavaScript engines and optimizations.
* **Array size and complexity**: The choice of approach might affect performance when dealing with large or complex arrays.

**Alternatives**

If you're looking for alternatives to MeasureThat.net, consider the following options:

1. **Benchmarking libraries**: Libraries like BenchmarkJS, js-benchmark, or Benchmark can help you create and run benchmark tests in your own projects.
2. **Online JavaScript testing platforms**: Platforms like JSFiddle, CodePen, or Repl.it provide environments for running JavaScript code and benchmarking different approaches.

Keep in mind that the performance differences between these approaches may be small, and other factors like optimization techniques, caching, or parallel execution might have a greater impact on overall performance.

Related benchmarks:

Lodash forEach VS native for loop VS native forEach VS native map (version: 1)

Comparing performance of: lodash.forEach vs native for vs native forEach vs native map

Created: one year ago by: Registered User

Jump to the latest result

lodash.forEach

native for

native forEach

native map

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