Benchmark: Lodash Loop Comparison to native for() |while()

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 for()
var count = 0; for (var i = 0; i < values.length; i++) { if (values[i].a != null) { count++; } }
native while()
var count = 0; var i = -1; while (++i < values.length) { if (values[i].a != null) { count++; } }
native forEach()
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()
native for()
native while()
native forEach()

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 96 on Windows

View result in a separate tab

Test name	Executions per second
lodash.forEach()	3485232.2 Ops/sec
native for()	1999319.8 Ops/sec
native while()	2001905.1 Ops/sec
native forEach()	11008980.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The provided JSON represents a benchmark test case on MeasureThat.net, comparing the performance of three different iteration methods in JavaScript: `for`, `while`, and `forEach`. The tests are designed to measure how efficiently each method can iterate over an array and perform a simple condition check.

Here's a breakdown of each option:

**1. Lodash `forEach()`**

*   Purpose: The `_` (underscore) is a popular utility library for JavaScript that provides functional programming helpers, including the `forEach` function.
*   Pros:
    *   Easy to use: The `forEach` method is a well-known and widely used function in the JavaScript community, making it easy for developers to understand and implement.
    *   Efficient: In this specific test case, Lodash's optimized implementation of `forEach` provides good performance.
*   Cons:
    *   Additional library dependency: By using an external library like Lodash, the benchmark introduces an additional dependency that might not be present in all environments.

**2. Native `for` loop**

*   Purpose: The traditional `for` loop is a fundamental construct in JavaScript for iterating over arrays and objects.
*   Pros:
    *   Built-in functionality: Since it's part of the standard library, there are no additional dependencies to consider.
    *   Wide support: This approach should work on most platforms without any issues.
*   Cons:
    *   More verbose: Compared to `forEach`, a traditional `for` loop requires more code and might be less readable.

**3. Native `while` loop**

*   Purpose: A simple `while` loop can be used for iteration, especially when the size of the array is not known in advance.
*   Pros:
    *   Simple and easy to understand: The basic syntax of a `while` loop is straightforward, making it accessible to developers who are new to iteration.
*   Cons:
    *   Potential performance issues: A manual `while` loop can lead to slower execution compared to other methods like `forEach` or `for`.

**Other alternatives**

Other iteration methods not included in this benchmark include:

*   `for...of` and `for...in`: These are used for iterating over arrays and objects, respectively. They provide a more modern and concise alternative to traditional `for` loops but have slightly different syntax.
*   Array methods like `every`, `some`, or `find`: These functions can be used for iteration but typically perform specific operations (e.g., checking if all elements meet a condition) rather than counting.

In this specific benchmark, the focus is on comparing the performance of basic iteration methods (`for`, `while`, and `forEach`). The inclusion of Lodash's `forEach` highlights the advantages of using optimized implementations for common functions.

Related benchmarks:

Lodash Loop Comparison to native for() |while() | forEach() (version: 0)

Comparing performance of: lodash.forEach() vs native for() vs native while() vs native forEach()

Created: 4 years ago by: Registered User

Jump to the latest result

lodash.forEach()

native for()

native while()

native forEach()

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