Benchmark: Lodash reduce vs native in for loop

HTML Preparation code:

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

Script Preparation code:

var nbIterations = 100000 //100,000
var numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

Tests:

Native reduce (in for loop)
for (let i = 0; i < nbIterations; i++) { numbers.reduce((sum, n) => sum + n, 0) }
Lodash reduce (in for loop)
for (let i = 0; i < nbIterations; i++) { _.reduce(numbers, (sum, n) => sum + n, 0) }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Native reduce (in for loop)
Lodash reduce (in for loop)

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/99.0.4844.84 Safari/537.36

Browser/OS: Chrome 99 on Windows

View result in a separate tab

Test name	Executions per second
Native reduce (in for loop)	48.5 Ops/sec
Lodash reduce (in for loop)	24.5 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition:**

The test is designed to compare two approaches:

1. Native JavaScript `reduce()` function inside a `for` loop (Test Name: "Native reduce (in for loop)")
2. Lodash `reduce()` function, also inside a `for` loop, but using the Lodash library (Test Name: "Lodash reduce (in for loop)")

**Options Compared:**

The two approaches are being compared in terms of performance, specifically:

* How many executions per second can be achieved by each approach
* Whether the native JavaScript implementation is faster or slower than the Lodash version

**Pros and Cons:**

1. **Native JavaScript `reduce()` function (in for loop)**:
	* Pros:
		+ Typically optimized for performance, as it's a built-in function
		+ May be more predictable and consistent in behavior
	* Cons:
		+ Requires manual iteration over the array using a `for` loop, which can be error-prone
		+ Might not leverage modern JavaScript features or optimizations (e.g., parallel processing)
2. **Lodash `reduce()` function (in for loop)**:
	* Pros:
		+ Easier to write and maintain, as it's a standardized library function
		+ May offer more flexibility in terms of customization and extension
	* Cons:
		+ Introduces an external dependency (the Lodash library)
		+ Might incur overhead due to the additional layer of abstraction

**Library:**

In this case, the Lodash library is being used for its `reduce()` function. Lodash is a popular utility library that provides a set of functional programming helpers and shortcuts for common tasks.

**Special JS Feature/Syntax:**

There doesn't appear to be any specific JavaScript features or syntax being tested in this benchmark. Both tests follow the standard syntax and structure for using the `reduce()` function.

**Other Alternatives:**

If you're considering alternative approaches, here are a few options:

1. **Using modern JavaScript features:** You could explore using modern JavaScript features like `Array.prototype.reduce()` with an arrow function (`numbers.reduce((sum, n) => sum + n, 0)`), which might offer better performance and readability.
2. **Native implementation without for loop:** Another approach would be to implement the reduction operation directly within a single line of code, avoiding the need for a `for` loop altogether (e.g., `numbers.reduce((sum, n) => sum + n, 0)`).
3. **Using parallel processing or concurrency:** Depending on the specific use case and requirements, you might consider using modern JavaScript features like Web Workers or async/await to leverage parallel processing or concurrency.

Keep in mind that these alternatives may require additional setup, dependencies, or changes to your codebase.

I hope this explanation helps!

Related benchmarks:

Lodash reduce vs native in for loop (version: 0)

This test aims to compare lodash reduce function with the Javascript native reduce function, doing exactly the same operation, BUT inside a regular for loop

Comparing performance of: Native reduce (in for loop) vs Lodash reduce (in for loop)

Created: 4 years ago by: Guest

Jump to the latest result

Native reduce (in for loop)

Lodash reduce (in for loop)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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