Benchmark: Lodash sumBy vs forEach vs for 2

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;
for
let result = 0; for(let i=0;i<arr.length;i++) { result += arr[i].value; }; return result;
reduce
arr.reduce((acc, curr) => acc += curr, 0)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.sumBy
foreach
for
reduce

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 100 on Linux

View result in a separate tab

Test name	Executions per second
_.sumBy	785.3 Ops/sec
foreach	726.1 Ops/sec
for	57.8 Ops/sec
reduce	86.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the provided JSON benchmark.

**Benchmark Definition**

The benchmark is designed to measure the performance of different approaches to sum up an array of objects using JavaScript functions. The three tested methods are:

1. `_.sumBy` from Lodash library
2. `forEach`
3. `for`

Each method has its own pros and cons:

* `_.sumBy`: This approach is concise and efficient, as it leverages the optimized implementation provided by Lodash. It's also easy to read and understand.
	+ Pros: Concise, efficient, and well-tested.
	+ Cons: Requires an external library (Lodash) to be included in the test environment.
* `forEach`: This approach is a built-in JavaScript method that iterates over arrays. While it can work for this specific use case, it's generally less efficient than `_.sumBy`.
	+ Pros: Built-in, no external dependencies required.
	+ Cons: Less efficient, may not be as concise or readable.
* `for`: This approach is a traditional loop method that iterates over arrays using an index. It can work for this specific use case but is generally less efficient and more verbose than `_.sumBy`.
	+ Pros: No external dependencies required.
	+ Cons: Less efficient, more verbose.

**Lodash Library**

The Lodash library provides a number of utility functions for common tasks, including array manipulation. In this case, `_.sumBy` is used to sum up an array of objects based on a specified key (`"value"`). The library is included in the test environment through the provided HTML script tag.

**Special JS Features/Syntax**

There are no special JavaScript features or syntax used in this benchmark that would require additional explanation. All code snippets use standard JavaScript syntax and semantics.

**Alternative Approaches**

Other approaches to sum up an array of objects using JavaScript could include:

* Using a traditional `for` loop with indexing
* Using the `Array.prototype.reduce()` method
* Using a recursive function to iterate over the array

These alternative approaches would likely have similar performance characteristics to the methods tested in this benchmark, but may require additional code and consideration for readability and maintainability.

**Benchmark Preparation Code**

The script preparation code generates an array of 100,000 objects with random integer values between 0 and 100. This allows the benchmark to test a large dataset without requiring manual setup or modification.

**Latest Benchmark Results**

The latest results show the execution speed per second for each method in Chrome 100 on Linux:

* `_.sumBy`: 785.28 executions/second
* `forEach`: 726.09 executions/second
* `for`: 86.46 executions/second
* `reduce`: 57.76 executions/second

Related benchmarks:

Lodash sumBy vs forEach vs for 2 (version: 0)

Comparing performance of: _.sumBy vs foreach vs for vs reduce

Created: 2 years ago by: Guest

Jump to the latest result

_.sumBy

foreach

for

reduce

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