Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
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
Go to the latest result
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>
Run tests (2)
Previous results
Fork
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:
6 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
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=623934" width="100%" height="500px"></iframe>
Normal sum test case
119.9M/s
lodash sumBy test
18.7M/s
View exact numbers
Test name
Executions per second
✓
Normal sum test case
119,856,232 Ops/sec
lodash sumBy test
18,669,200 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
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) ``` or ```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.
Comments
Confirm delete:
Do you really want to delete benchmark?