Benchmark: Lodash sumBy vs forEach

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 < 100000; i++){
  arr.push({value:getRandomInt(100)});
}

Tests:

_.sumBy
_.sumBy(arr,"value");
foreach
let result = 0; arr.forEach(element => { result += element.value }); return result;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.sumBy
foreach

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'd be happy to help explain the JavaScript microbenchmark on MeasureThat.net.

**Overview**

The benchmark measures the performance difference between two approaches: using Lodash's `sumBy` function and using a traditional `forEach` loop to sum up values in an array. The test creates a large array of objects with random integer values and then uses each approach to calculate the total sum.

**Options compared**

There are two options being compared:

1. **Lodash's `sumBy`**: This is a higher-order function that applies a given callback function to each element of an array, while also accumulating the results.
2. **Traditional `forEach` loop**: This involves iterating over each element in the array using a `forEach` loop and adding up the values manually.

**Pros and Cons**

* **Lodash's `sumBy`**:
	+ Pros: concise and expressive code, eliminates the need for manual iteration and sum calculation.
	+ Cons: requires the presence of Lodash library, may incur additional overhead due to function call and object lookups.
* **Traditional `forEach` loop**:
	+ Pros: lightweight, no external dependencies required, straightforward and easy to understand.
	+ Cons: more verbose code, requires manual iteration and sum calculation, which can be error-prone.

**Library usage**

Lodash is a popular JavaScript utility library that provides a wide range of functions for tasks such as array manipulation, string manipulation, and more. In this benchmark, Lodash's `sumBy` function is used to simplify the process of calculating the sum of an array by applying a callback function to each element.

**Special JS feature or syntax**

There are no special JavaScript features or syntax mentioned in the benchmark code. However, it's worth noting that the use of `let const` and arrow functions (`=>`) is a relatively modern feature of ECMAScript 2015 (ES6) and later versions.

**Benchmark preparation code**

The preparation code creates an array of objects with random integer values using a helper function `getRandomInt`. This helps ensure that the test results are consistent across different runs.

**Other alternatives**

If you're interested in exploring alternative approaches to this benchmark, here are some other options:

* Using a library like Ramda or Underscore.js, which provide similar functionality to Lodash.
* Implementing the `sumBy` function manually using recursion or iteration.
* Using a different array manipulation approach, such as using `reduce()` or `map()`.
* Optimizing the code for specific use cases, such as using SIMD instructions for numerical computations.

Keep in mind that each alternative may have its own trade-offs and considerations, and some may be more suitable than others depending on your specific use case and performance requirements.

Latest run results:

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

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

Browser/OS: Chrome 81 on Linux

View result in a separate tab

Test name	Executions per second
_.sumBy	182.5 Ops/sec
foreach	299.2 Ops/sec

Related benchmarks:

Lodash sumBy vs forEach (version: 0)

Comparing performance of: _.sumBy vs foreach

Created: 4 years ago by: Guest

Jump to the latest result

_.sumBy

foreach

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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