Benchmark: Lodash reduce vs Lodash Each

HTML Preparation code:

<html>
  <head>
  	<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.10.1/lodash.min.js"></script>
  </head>
  <body>
  </body>
</html>

Script Preparation code:

var xpath = "/a/b1/c1/d1/../../../b2/c2/d2"
var xpathParts = xpath.split("/");

Tests:

Reduce (cloning)
_.reduce(_.clone(xpathParts), function(acc, node) { if (node === "..") { acc.pop(); } else { acc.push(node); } return acc; }, []);
Reduce (without cloning)
_.reduce(xpathParts, function(acc, node) { if (node === "..") { acc.pop(); } else { acc.push(node); } return acc; }, []);
Each (cloning)
var resultXPath = []; _.each(_.clone(xpathParts), function(xpathPart) { if (xpathPart === "..") { resultXPath.pop(); } else { resultXPath.push(xpathPart); } });
Each (without cloning)
var resultXPath = []; _.each(xpathParts, function(xpathPart) { if (xpathPart === "..") { resultXPath.pop(); } else { resultXPath.push(xpathPart); } });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Reduce (cloning)
Reduce (without cloning)
Each (cloning)
Each (without cloning)

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36

Browser/OS: Chrome 68 on Linux

View result in a separate tab

Test name	Executions per second
Reduce (cloning)	905346.3 Ops/sec
Reduce (without cloning)	1436396.2 Ops/sec
Each (cloning)	1006845.7 Ops/sec
Each (without cloning)	1704190.9 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the explanation into smaller sections to make it easier to understand.

**Benchmark Overview**

The provided JSON represents a JavaScript benchmark test case on the MeasureThat.net website. The test compares two approaches: using `_.reduce` with cloning and without cloning, versus using `_.each` with cloning and without cloning.

**What is being tested?**

* The benchmark tests the performance of two functions:
	1. `_.reduce`: A function that reduces an array by repeatedly applying a callback function.
	2. `_.each`: A function that executes a provided callback function once for each element in an array, similar to a traditional `for` loop.
* Both `_.reduce` and `_.each` are implemented using the Lodash library.

**Options being compared**

The benchmark compares two options for each function:

1. **Cloning**: For both `_reduce` and `_each`, there is an option where the input array is cloned before passing it to the callback function. This allows the callback function to modify the original array.
2. **No cloning**: The other option for each function is run without cloning the input array, which means the callback function must work with a copy of the original array.

**Pros and Cons**

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

1. **Cloning**:
	* Pros: Can simplify the implementation of the callback function, as it doesn't need to worry about modifying the original array.
	* Cons: Creates an extra copy of the input array, which can lead to performance overhead due to memory allocation and deallocation.
2. **No cloning**:
	* Pros: Avoids the overhead of creating multiple copies of the input array, making it more efficient for large datasets.
	* Cons: The callback function must be designed to modify a copy of the original array, which can make it more complex to implement.

**Lodash Library**

The `_.reduce` and `_.each` functions are part of the Lodash library. Lodash is a popular utility library for JavaScript that provides a collection of functional programming helpers, such as array manipulation and string utilities.

**Other Considerations**

When writing performance-critical code in JavaScript, it's essential to consider factors like:

* Memory allocation and deallocation
* Cache locality
* Branch prediction

In this benchmark, the main consideration is how cloning affects performance. Cloning creates an extra copy of the input array, which can lead to overhead due to memory allocation and deallocation.

**Alternatives**

If you need to perform similar operations in your own code, consider using:

1. **Native JavaScript arrays**: Instead of using a utility library like Lodash, you can use native JavaScript arrays for manipulation.
2. **Other utility libraries**: Depending on the specific operation, other libraries like Underscore.js or Ramda might provide alternative implementations with varying trade-offs in terms of performance and complexity.

Keep in mind that these alternatives may not offer significant performance improvements over Lodash's implementation, but they can simplify your code and reduce dependencies on external libraries.

Related benchmarks:

Lodash reduce vs Lodash Each (version: 0)

Comparing performance of: Reduce (cloning) vs Reduce (without cloning) vs Each (cloning) vs Each (without cloning)

Created: 6 years ago by: Registered User

Jump to the latest result

Reduce (cloning)

Reduce (without cloning)

Each (cloning)

Each (without cloning)

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