Benchmark: Lodash sumBy string vs array vs function

HTML Preparation code:

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

Script Preparation code:

var arr = [];
for(var i = 0; i < 100; i++){
  arr.push({a: {b:1}});
}

Tests:

sumBy with function
_.sumBy(arr, (item) => item.a.b)
sumBy with array
_.sumBy(arr, ["a", "b"])
sumBy with string
_.sumBy(arr, "a.b")

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
sumBy with function
sumBy with array
sumBy with string

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided JSON represents a JavaScript microbenchmark created on MeasureThat.net. The benchmark tests three different approaches to calculate the sum of values in an array using Lodash, a popular utility library for JavaScript.

**Benchmark Definition**

The benchmark consists of a single script preparation code that creates an array of objects with a nested property `a.b`. The HTML preparation code includes the Lodash library version 4.17.5.

**Test Cases**

There are three individual test cases:

1. **sumBy with function**: This test case uses the `_sumBy` function from Lodash, passing a custom function `(item) => item.a.b` as an argument.
2. **sumBy with array**: This test case uses the `_sumBy` function from Lodash, passing an array `[\"a\", \"b\"]` as an argument.
3. **sumBy with string**: This test case uses the `_sumBy` function from Lodash, passing a string `"a.b"` as an argument.

**Options Compared**

The three test cases compare the execution time of the `sumBy` function with different approaches:

*   Using a custom function `(item) => item.a.b`
*   Using an array `[\"a\", \"b\"]` as an argument
*   Using a string `"a.b"` as an argument

**Pros and Cons of Each Approach**

Here's a brief analysis of each approach:

1.  **Custom Function**: This approach provides the most flexibility, allowing developers to choose the most efficient way to extract values from the object.
    *   Pros: Flexibility, potential for better performance
    *   Cons: May require additional setup or optimization
2.  **Array Argument**: Passing an array as an argument allows Lodash to use a more optimized approach, potentially reducing execution time.
    *   Pros: Optimized for performance, easy to implement
    *   Cons: Limited flexibility, may not work with all object structures
3.  **String Argument**: Using a string as an argument is the simplest way to access values from an object, but it may be slower due to the overhead of parsing and splitting the string.
    *   Pros: Easy to implement, simple to read
    *   Cons: Potential performance issues, less flexible

**Lodash Library**

Lodash is a utility library that provides a wide range of functions for tasks such as array manipulation, object transformation, and more. In this benchmark, Lodash is used for its `_sumBy` function, which calculates the sum of values in an array by applying a provided function to each element.

**JavaScript Feature/Syntax**

There's no specific JavaScript feature or syntax mentioned in this benchmark that requires special attention.

**Alternative Approaches**

For calculating the sum of values in an array without using Lodash, developers can use built-in JavaScript methods like `reduce()` or `forEach()`. However, these approaches might not be as optimized for performance as the ones provided by Lodash.

Here's a basic example using `reduce()`:

```javascript
let arr = [];
for (var i = 0; i < 100; i++) {
    arr.push({a: {b:1}});
}
let sum = arr.reduce((acc, item) => acc + item.a.b, 0);
console.log(sum); // Output: the sum of values in the array
```

Keep in mind that this approach is less optimized for performance compared to using Lodash's `_sumBy` function.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.106 Safari/537.36

Browser/OS: Chrome 80 on Windows

View result in a separate tab

Test name	Executions per second
sumBy with function	155274.5 Ops/sec
sumBy with array	104002.8 Ops/sec
sumBy with string	15407.9 Ops/sec

Related benchmarks:

Lodash sumBy string vs array vs function (version: 0)

Comparing performance of: sumBy with function vs sumBy with array vs sumBy with string

Created: 4 years ago by: Guest

Jump to the latest result

sumBy with function

sumBy with array

sumBy with string

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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