Benchmark: lodash.foreach vs for-of vs array.forEach

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js"></script>

Script Preparation code:

var arr = Array.from({ length: 10000 }).map((value, i) => i);

Tests:

lodash.foreach
_.forEach(arr, function(e, i) {})
native for-of
for (const e of arr) {}
native for-of + entries
for (const [i, e] of arr.entries()) {}
native forEach
arr.forEach(function(e, i) {})

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash.foreach
native for-of
native for-of + entries
native forEach

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what is being tested.

**Benchmark Overview**

The benchmark measures the performance of three different approaches to iterate over an array:

1. `lodash.foreach` (using Lodash library)
2. Native `for-of` loop
3. Native `forEach` method with callback function

Each test case uses a specific iteration approach, and the results are compared to determine which one is the fastest.

**Test Case 1: `lodash.foreach`**

* Library used: Lodash (version 4.17.5)
* Purpose: The `foreach` function from the Lodash library iterates over an array using a callback function.
* Pros:
	+ Easy to use and understand for developers familiar with Lodash.
	+ Can be useful when working with complex data structures or when iteration is not the primary concern.
* Cons:
	+ Requires including the Lodash library in the test environment, which can add overhead.
	+ May have slower performance compared to native iterations due to additional function call overhead.

**Test Case 2: Native `for-of` loop**

* Purpose: The native `for-of` loop is a built-in iteration mechanism that allows iterating over arrays using a more concise syntax.
* Pros:
	+ Fast and lightweight, as it only involves array indexing and loop control logic.
	+ Allows for direct access to array elements and their indices.
* Cons:
	+ Requires understanding of the native `for-of` loop syntax and its limitations (e.g., no iteration over objects or arrays with non-numeric keys).
	+ May require additional setup to ensure proper iteration behavior.

**Test Case 3: Native `forEach` method with callback function**

* Purpose: The native `forEach` method is another built-in iteration mechanism that allows iterating over arrays using a callback function.
* Pros:
	+ Similar performance characteristics to the native `for-of` loop, as it only involves array indexing and callback function execution.
	+ Easy to understand and use for developers familiar with JavaScript's built-in methods.
* Cons:
	+ May have slightly slower performance compared to native `for-of`, as the method call overhead is still present.
	+ Can be less readable than the native `for-of` loop due to the need to include callback functions.

**Test Case 4: Native `for-of + entries`**

* Purpose: This test case uses a combination of the native `for-of` loop and array's `entries()` method to iterate over an array.
* Pros:
	+ Allows for direct access to both array elements and their indices using the `entries()` method.
	+ Provides flexibility in iteration behavior compared to native `for-of`.
* Cons:
	+ May have slightly slower performance due to the additional method call overhead of `entries()`.
	+ Requires understanding of how to use `entries()` correctly with the native `for-of` loop.

**Other Considerations**

When evaluating these alternatives, consider factors like:

* Performance: Measured in terms of executions per second.
* Code readability and maintainability.
* Library or framework dependencies (e.g., Lodash).
* Native JavaScript features or syntax used.

In this benchmark, the results indicate that the native `for-of` loop is the fastest approach for iterating over an array. However, the choice of iteration method ultimately depends on personal preference, project requirements, and familiarity with the relevant library or framework.

**Alternatives**

Other alternatives to consider when iterating over arrays in JavaScript include:

* Using a `for` loop with explicit indexing (e.g., `arr[i] = value; i++`)
* Utilizing array's `map()` method for transformations
* Leveraging third-party libraries like RxJS or Bluebird

Keep in mind that the performance characteristics and trade-offs of each approach can vary depending on specific use cases and requirements.

Latest run results:

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

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

Browser/OS: Chrome 113 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lodash.foreach	24194.7 Ops/sec
native for-of	170903.1 Ops/sec
native for-of + entries	41844.2 Ops/sec
native forEach	225724.6 Ops/sec

Related benchmarks:

lodash.foreach vs for-of vs array.forEach (version: 1)

Comparing performance of: lodash.foreach vs native for-of vs native for-of + entries vs native forEach

Created: one year ago by: Registered User

Jump to the latest result

lodash.foreach

native for-of

native for-of + entries

native forEach

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