Benchmark: lodash.each vs Array.forEach vs jQuery.each vs for - function call

HTML Preparation code:

<script src="https://code.jquery.com/jquery-3.5.1.slim.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.20/lodash.min.js"></script>

Script Preparation code:

var array = new Array(1000);
for (let i = 0, l = array.length; i < l; ++i) array[i] = i;

function fn (item) {
  return item * 2 * 5;
}

Tests:

lodash.each
_.forEach(array,fn)
native
array.forEach(fn)
for loop
for(let i = 0, l = array.length; i < l; ++i) fn(array[i]);
jQuery each
$.each(array, fn);
for..of loop
for (const item of array) fn(item);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash.each
native
for loop
jQuery each
for..of loop

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark compares four different approaches to iterate over an array in JavaScript:

1. `lodash.each`
2. Native `Array.prototype.forEach`
3. jQuery's `$.each`
4. For loops (with two variations: traditional `for` loop and `for..of` loop)

**Options Compared**

The four options being compared are designed to test the performance of each iteration method in different scenarios.

* `lodash.each`: A third-party library function that iterates over an array, providing a more functional programming approach.
* Native `Array.prototype.forEach`: A built-in JavaScript method for iterating over arrays.
* jQuery's `$.each`: A wrapper around the native `forEach` method, specific to the jQuery library.
* For loops: Two types of traditional for loops are compared:
	+ Traditional `for` loop: The classic, explicit loop syntax using an index variable.
	+ `for..of` loop: A newer, more concise syntax introduced in ECMAScript 2015 (ES6), which uses a simple declaration statement to iterate over arrays.

**Pros and Cons**

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

* **Lodash `.each`**: Pros:
	+ Easy to use and understand.
	+ More functional programming style, which can lead to more expressive code.
Cons:
	+ An external dependency (Lodash).
	+ May have performance overhead due to function call overhead.
* **Native `Array.prototype.forEach`**:
	+ Built-in method, no additional dependencies.
	+ Lightweight and efficient.
Pros:
	+ Fast and lightweight.
Cons:
	+ Less explicit control over iteration than traditional for loops.
* **jQuery's `$each`**:
	+ Wrapper around native `forEach`, providing a familiar jQuery API.
	+ May have performance overhead due to the wrapper function.
Pros:
	+ Easy to use and understand, especially for developers already familiar with jQuery.
Cons:
	+ Additional dependency (jQuery).
	+ May not be as lightweight or efficient as native methods.
* **For loops**:
	+ Pros:
		- Explicit control over iteration.
		- No dependencies or external libraries.
	+ Cons:
		- More verbose and less readable than other options.
		- May lead to more errors due to index calculation issues.

**Libraries and Special Features**

The benchmark uses the following libraries:

* Lodash (for `_.each`)
* jQuery (for `$each`)

No special JavaScript features or syntax are explicitly mentioned in this benchmark, but it's worth noting that other benchmarks may include features like async/await, promises, or modern language features like arrow functions or template literals.

**Alternatives**

Other alternatives to the tested options might include:

* Using `Array.prototype.map()` or `Array.prototype.filter()` instead of for loops.
* Utilizing modern libraries like Ramda or Purescript, which provide functional programming abstractions and can be more expressive than traditional methods.
* Leveraging native web workers or WebAssembly for performance-critical code.

Keep in mind that the choice of iteration method depends on specific requirements, such as performance, readability, maintainability, and compatibility with existing libraries or frameworks.

Latest run results:

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

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

Browser/OS: Chrome 105 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lodash.each	190190.7 Ops/sec
native	158920.1 Ops/sec
for loop	13702.2 Ops/sec
jQuery each	96598.0 Ops/sec
for..of loop	27139.5 Ops/sec

Related benchmarks:

lodash.each vs Array.forEach vs jQuery.each vs for - function call (version: 1)

Compares lodash.each, Array.prototype.forEach, jQuery.each, for and for..of, when the loop body calls function.

Comparing performance of: lodash.each vs native vs for loop vs jQuery each vs for..of loop

Created: 4 years ago by: Registered User

Jump to the latest result

lodash.each

native

for loop

jQuery each

for..of loop

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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