Benchmark: lodash sumBy vs normal sum of 4 values

HTML Preparation code:

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

Tests:

lodash sumBy test
const [value1, value2, value3, value4] = [1, 2, 3, 4]; const arr = ['value1', 'value2', 'value3', 'value4']; const totalSum = _.sumBy(arr, (field) => { return arr[field] || 0; });
Normal sum test case
const [value1, value2, value3, value4] = [1, 2, 3, 4]; const totalSum = (value1 || 0) + (value2 || 0) + (value3 || 0) + (value4 || 0);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash sumBy test
Normal sum test case

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 months ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36

Browser/OS: Chrome 143 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lodash sumBy test	18669200.0 Ops/sec
Normal sum test case	119856232.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript microbenchmarks can be a fascinating topic.

**Overview**

The provided JSON represents two benchmark definitions for comparing the performance of two approaches: using the `_.sumBy` function from the Lodash library, and calculating the sum manually without any library assistance. The test cases are designed to measure the execution time of both methods on an array of four values.

**Benchmark Definitions**

There are two benchmark definitions:

1. **Lodash sumBy**: This approach uses the `_.sumBy` function, which takes an array and a callback function as arguments. The callback function is applied to each element in the array, and the results are summed up.
2. **Normal sum**: This approach calculates the sum manually by iterating over the array elements and adding them together.

**Options Compared**

The two options being compared are:

* Using the `_.sumBy` function from Lodash library
* Calculating the sum manually without any library assistance

**Pros and Cons of Each Approach**

* **Lodash sumBy**:
	+ Pros: Convenient, efficient, and easy to use. It reduces boilerplate code and makes the calculation more readable.
	+ Cons: Requires an additional library (Lodash) which may have a performance overhead or depend on external dependencies.
* **Normal sum**:
	+ Pros: No external dependencies, easier to understand, and potentially faster since it doesn't involve the overhead of calling a function.
	+ Cons: More verbose, and may not be as readable.

**Library - Lodash**

Lodash is a popular JavaScript library that provides a comprehensive set of functional programming helpers. The `_.sumBy` function is one of its many utility functions that simplifies common tasks. It takes an array and a callback function as arguments, applies the callback to each element in the array, and returns the sum of the results.

**Special JS Feature or Syntax**

There are no special JavaScript features or syntax used in these benchmark definitions.

**Other Alternatives**

Other alternatives for calculating sums in JavaScript include:

* Using `Array.prototype.reduce()`: This method reduces an array to a single value by applying a callback function to each element.
* Using a simple loop: A traditional loop can be used to iterate over the array elements and calculate the sum manually.

```javascript
arr.reduce((sum, current) => sum + (current || 0), 0)
```

```javascript
let sum = 0;
for (const value of arr) {
  sum += (value || 0);
}
```

These alternatives can be used as an alternative to the `_.sumBy` function or the normal sum approach.

In summary, the Lodash library provides a convenient and efficient way to calculate sums using the `_.sumBy` function. However, this comes at the cost of introducing an additional dependency. The normal sum approach is more verbose but potentially faster and doesn't rely on external dependencies.

Related benchmarks:

lodash sumBy vs normal sum of 4 values (version: 0)

Comparing performance of: lodash sumBy test vs Normal sum test case

Created: 4 years ago by: Guest

Jump to the latest result

lodash sumBy test

Normal sum test case

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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