Benchmark: lodash.forEach vs forEach vs for loop vs for in vs for of

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++; } })
for loop
var count = 0; for (var i = 0; i < values.length; i++) { if (values[i].a != null) { count++; } }
for of
var count = 0; for (const v of values) { if (v.a != null) { count++; } }
for in
var count = 0; for (const v in values) { if (v.a != null) { count++; } }
forEach native
var count = 0; values.forEach(function(v, i) { if (v.a != null) { count++; } })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash.forEach
for loop
for of
for in
forEach native

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 dive into the world of JavaScript benchmarks.

**Benchmark Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided JSON represents a benchmark test case with four different approaches: `lodash.forEach`, `forEach native` (the built-in JavaScript `forEach` function), `for loop`, and `for in`. The test case also uses an array of objects (`values`) as input data.

**What is being tested?**

In this benchmark, the following options are compared:

1. **`lodash.forEach`**: A custom implementation of the `forEach` function using Lodash.
2. **`forEach native`**: The built-in JavaScript `forEach` function, which iterates over an array and executes a callback function for each element.
3. **`for loop`**: A traditional `for` loop that iterates over an array using a manual index variable.
4. **`for in`**: A `for...in` loop that iterates over the properties of an object, which is used to iterate over the elements of the input array.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

1. **`lodash.forEach`**:
	* Pros: Efficient implementation, optimized for performance.
	* Cons: Requires Lodash library, adds overhead due to external dependency.
2. **`forEach native`**:
	* Pros: Built-in function, efficient execution, no external dependencies.
	* Cons: May have slower performance due to JavaScript engine optimizations.
3. **`for loop`**:
	* Pros: Control over iteration, minimal dependencies.
	* Cons: Manual indexing can lead to errors, may be slower than built-in functions.
4. **`for in`**:
	* Pros: Simple and intuitive syntax, suitable for object iteration.
	* Cons: Not optimized for array iteration, may have slower performance.

**Library**

The `lodash.forEach` function uses the Lodash library, which provides a utility function to iterate over arrays and objects. The library is included in the HTML preparation code using a script tag.

**Special JS feature or syntax**

None of the approaches use any special JavaScript features or syntax that would affect their performance significantly.

**Other alternatives**

Other alternatives to consider for array iteration include:

1. `Array.prototype.forEach` (the built-in function, but not explicitly included in this benchmark).
2. `map()` and `filter()` functions (which can be used to iterate over arrays, but may have different performance characteristics).

In summary, the benchmark compares four different approaches to iterating over an array of objects: a custom implementation using Lodash (`lodash.forEach`), the built-in JavaScript `forEach` function (`forEach native`), a traditional `for` loop (`for loop`), and a `for in` loop (`for in`). Each approach has its pros and cons, and the choice of which one to use depends on the specific requirements of the project.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36

Browser/OS: Chrome 78 on Windows

View result in a separate tab

Test name	Executions per second
lodash.forEach	2296730.0 Ops/sec
for loop	1332737.6 Ops/sec
for of	8232024.0 Ops/sec
for in	2752426.2 Ops/sec
forEach native	7650227.5 Ops/sec

Related benchmarks:

lodash.forEach vs forEach vs for loop vs for in vs for of (version: 0)

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

Created: 4 years ago by: Guest

Jump to the latest result

lodash.forEach

for loop

for of

for in

forEach native

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