Benchmark: lodash forEach vs for i loop vs native for i in

HTML Preparation code:

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

Script Preparation code:

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

Tests:

lodash.forEach
var count = 0; _.forEach(values, function(v,i) { if (v.a != null) { count++; } })
native
var count = 0; for (var i = 0; i < values.length; i++) { if (values[i].a != null) { count++; } }
native for i in
var count = 0; for (var i in values) { if (values[i].a != null) { count++; } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash.forEach
native
native for i in

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 88 on Linux

View result in a separate tab

Test name	Executions per second
lodash.forEach	3652923.2 Ops/sec
native	2304189.8 Ops/sec
native for i in	2126701.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark analysis.

**Benchmark Purpose**

The goal of this benchmark is to compare the performance of three different approaches:

1. Lodash `forEach` method
2. Native `for` loop with indexing (using `values.length` and `i`)
3. Native `for...in` loop

These approaches are compared for their execution speed in iterating over an array (`values`) and executing a condition on each element.

**Options Compared**

The benchmark compares the performance of three options:

1. **Lodash `forEach` method**: This is a utility function from the Lodash library that iterates over an array using a callback function.
2. **Native `for` loop with indexing**: This approach uses a traditional `for` loop to iterate over the array indices, accessing each element using its index (`values[i]`).
3. **Native `for...in` loop**: This approach uses the older `for...in` syntax, which iterates over an object's properties (in this case, the array elements). Note that `for...in` is not as efficient as traditional `for` loops for arrays.

**Pros and Cons of Each Approach**

1. **Lodash `forEach` method**:
	* Pros: Easy to use, concise code, and often faster than native implementations due to its optimized internal logic.
	* Cons: Requires the Lodash library, which may introduce additional overhead.
2. **Native `for` loop with indexing**:
	* Pros: Fastest approach, as it uses a traditional `for` loop with direct access to array elements.
	* Cons: May require more code and is less readable than the Lodash `forEach` method.
3. **Native `for...in` loop**:
	* Pros: Simple to implement and can be faster for small arrays.
	* Cons: Less efficient than traditional `for` loops due to the overhead of iterating over object properties.

**Library Used**

In this benchmark, Lodash is used as a utility library. The `lodash.min.js` script is included in the HTML file using a CDN link (`https://cdn.jsdelivr.net/lodash/4.16.0/lodash.min.js`). This allows users to easily run the benchmark with and without Lodash.

**Special JavaScript Features or Syntax**

In this benchmark, no special JavaScript features or syntax are used beyond what's standard for arrays and `for` loops. There are no experimental features like async/await, promise chaining, or arrow functions.

**Alternatives**

If you want to compare other approaches, consider the following alternatives:

* Other utility libraries (e.g., jQuery, underscore.js) that offer similar `forEach` methods.
* Modern JavaScript array methods (e.g., `map()`, `filter()`) for iterating over arrays.
* Using `Set` or `Map` data structures instead of arrays for faster lookups.
* Implementing custom iteration logic using recursive functions or `for...of` loops.

Keep in mind that each alternative will have its own trade-offs and performance characteristics, so be sure to test and benchmark them as needed.

Related benchmarks:

lodash forEach vs for i loop vs native for i in (version: 0)

Comparing performance of: lodash.forEach vs native vs native for i in

Created: 3 years ago by: Guest

Jump to the latest result

lodash.forEach

native

native for i in

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