Benchmark: array iteration vs _.each vs map vs for

HTML Preparation code:

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

Script Preparation code:

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

Tests:

_.each
_.each(array, (value, index) => { console.log(value) })
forEach
array.forEach((value, index) => { console.log(value) })
map
array.map((value, index) => { console.log(value) })
for
for (i = 0; i < array.length; i++) { console.log(array[i]) }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.each
forEach
map
for

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and its test cases.

**Benchmark Definition**

The website uses a JSON representation of the benchmark definition, which includes:

* **Script Preparation Code**: This code is executed before running the benchmark. In this case, it creates an array `array` with three string elements: `'a'`, `'b'`, and `'c'`.
* **Html Preparation Code**: This code is loaded from a CDN (Content Delivery Network) and contains the Lodash library version 4.17.11. Lodash is a popular utility library for JavaScript that provides various functions, including iteration helpers.
* **Benchmark Definition**: This is an array of individual test cases, each with its own script definition.

**Individual Test Cases**

There are four test cases:

1. `_.each(array, (value, index) => {\r\n  console.log(value)\r\n})`
	* This code uses the Lodash `_` function to iterate over the `array` and logs each element to the console using an arrow function.
2. `array.forEach((value, index) => {\r\n  console.log(value)\r\n})`
	* This code uses the built-in `forEach` method of arrays in JavaScript to iterate over the `array` and logs each element to the console.
3. `array.map((value, index) => {\r\n  console.log(value)\r\n})`
	* This code uses the Lodash `_` function (again!) to create a new array with transformed elements from the original `array`. However, in this case, it also logs each element to the console.
4. `for (i = 0; i < array.length; i++) {\r\n  console.log(array[i])\r\n}`
	* This code uses a traditional `for` loop to iterate over the indices of the `array` and logs each element to the console.

**Options Compared**

The benchmark compares four different ways to iterate over an array:

1. Lodash's `_each` function
2. Built-in `forEach` method
3. Lodash's `map` function (which is not strictly necessary, as it would only transform the elements, not log them)
4. Traditional `for` loop

**Pros and Cons**

Here are some pros and cons of each approach:

1. **Lodash `_each` function**:
	* Pros: concise and readable code, leveraging Lodash's utility library
	* Cons: depends on having Lodash loaded, might be slower due to the overhead of a JavaScript runtime
2. **Built-in `forEach` method**:
	* Pros: widely supported, fast execution, no additional dependencies required
	* Cons: less expressive than other options (i.e., it doesn't explicitly log each element)
3. **Lodash's `map` function**:
	* Pros: can be useful for transformations, but not necessary in this case since we're only logging elements
	* Cons: adds unnecessary complexity and may slow down execution due to the transformation step
4. **Traditional `for` loop**:
	* Pros: straightforward, no dependencies required, easy to optimize
	* Cons: less concise and readable than other options

**Library**

Lodash is a utility library for JavaScript that provides various functions for tasks like array iteration, string manipulation, and functional programming.

**Special JS Features/Syntax**

None of the test cases use any special JavaScript features or syntax. They only rely on standard JavaScript language constructs.

**Alternatives**

If you wanted to rewrite this benchmark using alternative approaches, here are some options:

1. Use other libraries like Lo-Dash or Underscore.js (similar to Lodash)
2. Implement your own iteration functions (e.g., `while`, `do-while`)
3. Use a different programming paradigm (e.g., functional programming with recursion)
4. Use native JavaScript features like `for...of` loops for array iteration

Keep in mind that these alternatives would likely require significant changes to the benchmark code and might not provide comparable results.

Latest run results:

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

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

Browser/OS: Chrome 74 on Mac OS X 10.14.4

View result in a separate tab

Test name	Executions per second
_.each	43317.4 Ops/sec
forEach	24136.3 Ops/sec
map	24031.2 Ops/sec
for	42534.3 Ops/sec

Related benchmarks:

array iteration vs _.each vs map vs for (version: 0)

Comparing performance of: _.each vs forEach vs map vs for

Created: 5 years ago by: Guest

Jump to the latest result

_.each

forEach

map

for

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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