Benchmark: Lodash sumBy vs reduce 100 elements

HTML Preparation code:

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

Script Preparation code:

function getRandomInt(max) {
  return Math.floor(Math.random() * Math.floor(max));
}

var arr = [];
for(var i = 0; i < 100; i++){
  arr.push({value:getRandomInt(100)});
}

Tests:

_.sumBy
_.sumBy(arr,"value");
map and reduce
arr.reduce((prev, next) => prev + next.value, 0);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.sumBy
map and reduce

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark.

The provided JSON represents a JavaScript microbenchmark that compares two approaches for summing up elements in an array: `_.sumBy` from the Lodash library and the built-in `reduce` method with additional manual mapping (`map and reduce`).

**What is being tested?**

The test measures the execution time of each approach on a large array (100 elements) with random values between 0 and 100. The comparison aims to determine which approach is faster.

**Options compared:**

1. `_.sumBy(arr, "value")`: This method uses Lodash's `sumBy` function, which applies a callback function to each element in the array and sums up the results.
2. `arr.reduce((prev, next) => prev + next.value, 0)` : This approach uses the built-in `reduce` method with an additional manual mapping step (`map`) to extract the values from the objects in the array.

**Pros and Cons:**

* `_.sumBy(arr, "value")`:
	+ Pros:
		- Convenient and concise syntax
		- Handles arrays of objects with ease
	+ Cons:
		- External dependency on Lodash library (adds overhead)
		- May not be as efficient due to lazy evaluation
* `arr.reduce((prev, next) => prev + next.value, 0)`:
	+ Pros:
		- Built-in method, no external dependencies
		- Can be optimized for performance by the browser's engine
	+ Cons:
		- Requires manual mapping step (`map`), which adds complexity
		- Less readable and maintainable code

**Library:**

The Lodash library is a popular JavaScript utility library that provides functional programming helpers, including `sumBy`. It's widely used for its concise syntax and ease of use.

**Special JS feature or syntax:**

There are no special features or syntaxes being tested in this benchmark. The focus is on comparing the performance of two approaches using standard JavaScript methods.

**Other alternatives:**

For summing up elements in an array, other alternatives could be:

1. `Array.prototype.reduce()`: A built-in method that can be used for summing up elements without requiring manual mapping.
2. `Array.prototype.forEach()`: While not optimized for performance, it can still be used with a custom callback function to achieve the desired result.
3. Custom iterative loop: Writing a simple loop to iterate over the array and sum up the values could also be an option.

However, these alternatives might have varying trade-offs in terms of performance, readability, and maintainability compared to the `_.sumBy` method or the `map and reduce` approach.

Related benchmarks:

Lodash sumBy vs reduce 100 elements (version: 0)

Comparing performance of: _.sumBy vs map and reduce

Created: 4 years ago by: Guest

Jump to the latest result

_.sumBy

map and reduce

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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