Benchmark: _.forEach with index vs for-of with entries

HTML Preparation code:

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

Script Preparation code:

var elements = ['a', 'b', 'c']

Tests:

_.forEach
_.forEach(elements, (e, i) => i.toString() + e)
native for-of with entries
for (const [i, e] of elements.entries()) { i.toString() + e; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.forEach
native for-of with entries

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:97.0) Gecko/20100101 Firefox/97.0

Browser/OS: Firefox 97 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
_.forEach	6375213.0 Ops/sec
native for-of with entries	6848951.5 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 provided benchmark and explain what's being tested.

**Benchmark Overview**

MeasureThat.net is testing the performance difference between using `Array.prototype.forEach()` with an index (`i`) parameter and a newer, more modern approach using `for-of` loops with the `entries` method. The goal is to determine which approach is faster in JavaScript.

**Options Compared**

Two options are being compared:

1. **_.forEach(elements, (e, i) => i.toString() + e)**: This uses the `Array.prototype.forEach()` method from the Lodash library. It takes two arguments: an array (`elements`) and a callback function that returns a value based on the index (`i`) and element (`e`). The callback function is also passed the index as its second argument.
2. **for (const [i, e] of elements.entries()) { i.toString() + e; }**: This uses a traditional `for-of` loop with the `entries()` method to iterate over an array's entries. The `entries()` method returns an iterator object that yields key-value pairs from the array.

**Pros and Cons**

**_.forEach(elements, (e, i) => i.toString() + e)**

Pros:

* Familiar syntax for many developers
* Can handle arrays with more complex logic in the callback function

Cons:

* Introduced by Lodash library, might require an additional import
* Might have slower performance compared to native `for-of` loops

**for (const [i, e] of elements.entries()) { i.toString() + e; }**

Pros:

* Native JavaScript syntax, no external library needed
* Can be faster for small arrays or simple iteration logic

Cons:

* Less familiar syntax for some developers
* Limited control over the iteration process in the callback function

**Other Considerations**

* The `for-of` loop is a more modern approach to iterating over arrays and objects. It provides better support for iterators and promises.
* The use of Lodash's `forEach()` method might be considered less "native" or "vanilla" JavaScript, which could affect performance in some cases.

**Library Used**

The library used is Lodash (version 4.17.15), a popular utility library for JavaScript that provides various functions and methods for working with arrays, objects, and other data structures.

**Special JS Feature/Syntax**

There are no special JavaScript features or syntax mentioned in this benchmark. The focus is on comparing the performance of two iteration approaches using native JavaScript syntax.

**Alternatives**

If you want to test different iteration approaches or libraries, here are some alternatives:

* **`for-in` loop**: An older way of iterating over arrays and objects in JavaScript.
* **`Array.prototype.map()`**: A method that creates a new array with the results of applying a provided function on every element in this array.
* **`Set` data structure**: A collection of unique values, which can be used for iteration or set operations.
* **Other libraries**: Depending on your specific use case, you might want to test libraries like Ramda, Underscore.js, or even TypeScript's `for...of` loop.

Related benchmarks:

_.forEach with index vs for-of with entries (version: 0)

Comparing performance of: _.forEach vs native for-of with entries

Created: 3 years ago by: Guest

Jump to the latest result

_.forEach

native for-of with entries

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