Benchmark: lodash each vs native

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.21/lodash.min.js'></script>

Script Preparation code:

var obj = Array.from({ length: 10000 }).map((value, i) => i);

Tests:

lodash.each
_.each(obj, function(v) {})
native forEach
obj.forEach(function(v) {})

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash.each
native forEach

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month ago)

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

Browser/OS: Chrome 133 on Windows

View result in a separate tab

Test name	Executions per second
lodash.each	11829.7 Ops/sec
native forEach	208302.1 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

The benchmark defined in the provided JSON compares the performance of two different methods for iterating over arrays in JavaScript: the `_.each` method from the Lodash library and the native `forEach` method available on array objects.

### Options Compared
1. **Lodash `each` Method**: 
   - **Benchmark Definition**: `_.each(obj, function(v) {})`
   - This method utilizes the Lodash library, which is a popular utility library that provides various functions for data manipulation. The `each` method in Lodash is used to iterate over elements in a collection (array or object) and execute a function for each element.

2. **Native `forEach` Method**:
   - **Benchmark Definition**: `obj.forEach(function(v) {})`
   - This method is part of the standard JavaScript Array prototype. The `forEach` method allows iteration over each element in an array and executes a provided function once for each array element.

### Performance Results
- The benchmark results show that the native `forEach` method achieves **208,302** executions per second, while the Lodash `each` method only achieves **11,829** executions per second. This indicates that the native method is significantly faster than the Lodash method in this specific benchmark scenario.

### Pros and Cons

#### Lodash `each`
**Pros:**
- Consistency: Lodash provides a consistent API across different data structures, making it easier to handle collections in different formats (arrays, objects, etc.).
- Additional Features: Lodash methods often come with additional features or options that can simplify complex data manipulation tasks.

**Cons:**
- Performance: As shown in the benchmark, Lodash methods are generally slower than their native counterparts due to the overhead of additional function calls and abstraction.
- Dependency: Using Lodash increases the size of your project due to the additional library dependency, which may impact load times.

#### Native `forEach`
**Pros:**
- Performance: Native methods are usually faster because they are optimized by JavaScript engines.
- No Dependency: Using native methods reduces dependencies, which can lead to smaller bundle sizes and increased performance.

**Cons:**
- Flexibility: Native methods may lack some of the utility features provided by Lodash, such as handling both arrays and objects in a uniform way.
- Verbosity: Native JavaScript can sometimes lead to more verbose code compared to the shorthand available in utility libraries.

### Other Considerations
- The benchmark utilizes a relatively straightforward array of integers generated with `Array.from({ length: 10000 }).map((value, i) => i)`, which is a common approach to create an array with specific values. The size of the array (10,000) ensures a substantial number of iterations for the tests.
- This benchmark focuses narrowly on just iterating over an array; other factors that might be important in real applications, such as memory usage, context, and callback functions, are not considered here.

### Alternatives
Other alternatives to the methods tested could include:
- **`for..of` Loop**: A modern iteration method that provides a syntax for iterating over iterable objects, including arrays. It offers a simpler syntax and avoids some of the pitfalls of traditional `for` loops.
  
  ```javascript
  for (const v of obj) {
      // process v
  }
  ```

- **Traditional `for` Loop**: While more verbose, the traditional `for` loop provides maximum control over iteration and might be more performant in certain scenarios.
  
  ```javascript
  for (let i = 0; i < obj.length; i++) {
      const v = obj[i];
      // process v
  }
  ```

- **`map` Method**: If the intention is to transform each value in the array rather than just iterating through them, the `map` method could be a better fit.

In summary, this benchmark is valuable for understanding the performance differences between using a utility library (Lodash) and native JavaScript methods, emphasizing the trade-offs between speed and features when selecting an approach for iterating over arrays.

Related benchmarks:

lodash each vs native (version: 1)

Comparing performance of: lodash.each vs native forEach

Created: one month ago by: Guest

Jump to the latest result

lodash.each

native forEach

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):