Benchmark: Underscore.js _forEach() vs Native for loop for large arrays (rewrite)

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.6.0/underscore-min.js'></script>

Script Preparation code:

var values = [{a: 30310}, {b: 100303}, {c: 3040494}]

Tests:

Underscore.js _forEach()
var count = 0; _.forEach(values, function(value) { if (value.a != null) { count++; } });
native for loop
var count = 0; for (var i = 0; i < values.length; i++) { if (values[i].a != null) { count++; } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Underscore.js _forEach()
native for loop

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in this benchmark.

**What is being tested?**

The test case compares the performance of two approaches: using Underscore.js `_forEach()` and a native `for` loop on large arrays. Specifically, it tests how many times the code executes the condition inside the loop (in this case, `value.a != null`) for each value in the array.

**Options compared**

The two options being compared are:

1. **Underscore.js `_forEach()`**: A function from the popular utility library Underscore.js that iterates over arrays and objects.
2. **Native `for` loop**: A basic looping construct in JavaScript that uses an index variable to iterate over array elements.

**Pros and cons of each approach**

**Underscore.js `_forEach()`**

Pros:

* Easier to read and write, as it abstracts away low-level details
* More concise code
* Can be more efficient for large datasets, since Underscore.js can handle indexing and bounds checking internally

Cons:

* Adds an external dependency (the Underscore.js library)
* May introduce overhead due to the need to call the `_forEach()` function on each element
* Limited control over iteration details (e.g., skipping elements)

**Native `for` loop**

Pros:

* Lightweight, no external dependencies required
* Provides fine-grained control over iteration details (e.g., skipping elements)
* Faster execution for small arrays or simple iterations

Cons:

* More verbose code
* Requires manual indexing and bounds checking

**Library: Underscore.js**

Underscore.js is a popular utility library that provides various functions for functional programming, data manipulation, and more. The `_forEach()` function is one of its most commonly used methods, allowing you to iterate over arrays and objects in a concise way.

**Special JS feature/syntax**

There are no special JavaScript features or syntax mentioned in this benchmark.

Now, let's take a look at the individual test cases:

1. **Underscore.js `_forEach()`**: This code uses Underscore.js `_forEach()` to iterate over the `values` array and increment a counter for each element where `value.a != null`.
2. **Native `for` loop**: This code uses a traditional `for` loop to iterate over the `values` array, incrementing a counter for each element where `value.a != null`.

**Other alternatives**

For large-scale iterations, other approaches you might consider include:

* Using modern JavaScript features like `Array.prototype.forEach()` or `for...of`
* Leveraging libraries like Lodash (which provides a more extensive set of iteration utilities)
* Utilizing parallel processing or multi-threading techniques for extreme performance-critical scenarios

However, for most use cases, the choice between `_forEach()` and a native `for` loop ultimately depends on personal preference, project requirements, and performance considerations.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/111.0

Browser/OS: Firefox 111 on Windows

View result in a separate tab

Test name	Executions per second
Underscore.js _forEach()	24646238.0 Ops/sec
native for loop	46553880.0 Ops/sec

Related benchmarks:

Underscore.js _forEach() vs Native for loop for large arrays (rewrite) (version: 0)

This will compare the native for loop speed vs the underscore _forEach() on a relatively large array.

Comparing performance of: Underscore.js _forEach() vs native for loop

Created: one year ago by: Guest

Jump to the latest result

Underscore.js _forEach()

native for loop

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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