Benchmark: Lodash meanBy vs JS (with small and large size)

Script Preparation code:

window.data = [];
for (let i = 0; i < 1000; i++) {
    data.push({n: Math.random()});
}

window.dataBig = [];
for (let i = 0; i < 100000; i++) {
    dataBig.push({n: Math.random()});
}

Tests:

Lodash meanBy (10k entries)
const avg = _.meanBy(data, v => v.n)
JS (10k entries)
const sum = data.reduce((acc, item) => { return acc + item.v; }, 0); const avg = sum / data.length;
Lodash meanBy (100k entries)
const avg = _.meanBy(dataBig, v => v.n)
JS (100k entries)
const sum = dataBig.reduce((acc, item) => { return acc + item.v; }, 0); const avg = sum / data.length;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash meanBy (10k entries)
JS (10k entries)
Lodash meanBy (100k entries)
JS (100k entries)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 135 on Windows

View result in a separate tab

Test name	Executions per second
Lodash meanBy (10k entries)	130094.2 Ops/sec
JS (10k entries)	1972422.2 Ops/sec
Lodash meanBy (100k entries)	801.5 Ops/sec
JS (100k entries)	1282.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):

LLMs can make mistakes. Check important info.

The benchmark defined in the JSON tests two different methods of calculating the mean (average) of values in an array of objects: using Lodash's `meanBy` function and a native JavaScript approach using `reduce`. Two scenarios are tested: with a relatively small dataset and a much larger one.

### Options Compared:

1. **Lodash `meanBy` Method**:
   - **Benchmark**: `const avg = _.meanBy(data, v => v.n)`
   - **Test Name**: "Lodash meanBy (10k entries)" and "Lodash meanBy (100k entries)"
   - **Pros**:
     - **Simplicity**: The syntax is concise and expressive, making it easy to understand.
     - **Readability**: It abstracts the implementation details, allowing developers to focus on the logic.
   - **Cons**:
     - **Performance Overhead**: Lodash introduces additional overhead because it’s a utility library; thus, function calls in Lodash can be slower than using raw JavaScript, especially for large datasets.
     - **Library Dependency**: It requires including the Lodash library, which adds extra weight to the project size.

2. **Native JavaScript `reduce` Method**:
   - **Benchmark**: 
     ```javascript
     const sum = data.reduce((acc, item) => {
         return acc + item.v;
     }, 0);
     const avg = sum / data.length;
     ```
   - **Test Name**: "JS (10k entries)" and "JS (100k entries)"
   - **Pros**:
     - **Performance**: Pure JavaScript is often faster due to less abstraction; retrieving values directly and performing calculations can be optimized by JavaScript engines.
     - **No Library Overhead**: This method doesn't require any additional libraries, keeping the code lightweight.
   - **Cons**:
     - **Verbosity**: The syntax is more verbose than using Lodash, which can reduce readability slightly, especially for complex operations.
     - **Error Handling**: More manual setup needed to handle edge cases (e.g., empty arrays).

### Considerations:
- The performance differences between the two methods are highlighted particularly in the benchmarks with larger datasets (100k entries) where the native JavaScript approach outperforms Lodash significantly. This is likely due to Lodash's abstraction layer taking more time to execute, especially under heavier load.
  
- When working with smaller datasets (10k entries), the performance difference is less pronounced, meaning that the choice between using Lodash or native JavaScript might come down to developer preference or code readability rather than outright performance.

### Alternatives:
1. **Typed Arrays**: For numerical datasets, using JavaScript Typed Arrays (like `Float64Array`) can provide better performance for mathematical operations, but they require a different handling of data structures.
  
2. **Functional Libraries**: Other libraries like Ramda or Underscore.js could also be considered for functional programming techniques, though they carry similar pros and cons as Lodash.

3. **Custom Implementations**: Developers might implement their own mean calculation method to suit specific performance needs, aiming for optimization based on their unique constraints or understanding of their data.

In summary, these benchmarks provide valuable insight into the performance trade-offs between using a rich library like Lodash versus relying on native JavaScript functionalities. The choice typically should weigh the importance of readability and maintainability against performance requirements, especially for applications sensitive to computation speed or large data sets.

Related benchmarks:

Lodash meanBy vs JS (with small and large size) (version: 1)

Comparing performance of: Lodash meanBy (10k entries) vs JS (10k entries) vs Lodash meanBy (100k entries) vs JS (100k entries)

Created: one year ago by: Guest

Jump to the latest result

Lodash meanBy (10k entries)

JS (10k entries)

Lodash meanBy (100k entries)

JS (100k entries)

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):