Benchmark: map reduce complex

HTML Preparation code:

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

Script Preparation code:

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

function lodashreduce1 () {
  const timerDateReduceLodash = new Date();
  //console.log('lodash reduce', _.reduce(numbers, (sum, n) => sum + n, 0));
  //console.log('lodash time', new Date() - timerDateReduceLodash);
  const x = _.reduce(numbers, (sum, n) => sum + n, 0)
  return x
}

function reduce1 () {
  const timerDateReduceJS = new Date();
  //console.log('native reduce', numbers.reduce((sum, n) => sum + n, 0));
  //console.log('native time', new Date() - timerDateReduceJS);
  const x = numbers.reduce((sum, n) => sum + n, 0)
  return x
}

Tests:

lodash reduce
lodashreduce1()
reduce
reduce1()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash reduce
reduce

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/131.0.0.0 Safari/537.36

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
lodash reduce	13233542.0 Ops/sec
reduce	16237770.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of MeasureThat.net and analyze the provided benchmark.

**Benchmark Definition JSON**

The benchmark is defined in two parts: a script preparation code and an HTML preparation code.

1. **Script Preparation Code**: This code defines two functions, `lodashreduce1` and `reduce1`, which perform the same operation - reducing an array of numbers to a single value using either the Lodash library's `_.reduce` function or the native JavaScript `reduce` method.
2. **HTML Preparation Code**: This code includes a script tag that loads the Lodash library version 4.17.5.

**What is being tested?**

The benchmark tests two approaches:

1. **Lodash Reduce**: The `lodashreduce1` function uses the Lodash library's `_.reduce` function to reduce the array of numbers.
2. **Native Reduce**: The `reduce1` function uses the native JavaScript `reduce` method to achieve the same result.

**Options compared**

The benchmark compares two options:

1. Using the Lodash library for reducing an array of numbers.
2. Using the native JavaScript `reduce` method for reducing an array of numbers.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

**Lodash Reduce**

Pros:

* Provides a concise and expressive way to perform reduction operations.
* Offers additional functionality beyond what the native `reduce` method provides.

Cons:

* Introduces additional overhead due to the library's overhead and memory allocation.
* May not be as efficient as the native implementation for small arrays or simple reductions.

**Native Reduce**

Pros:

* Has negligible overhead, making it suitable for large datasets or performance-critical code.
* Can take advantage of hardware acceleration and optimized implementations.

Cons:

* Requires a deeper understanding of JavaScript's `reduce` method and its behavior.
* May not be as concise or expressive as the Lodash implementation.

**Library: Lodash**

Lodash is a popular utility library for JavaScript that provides various functions for tasks such as array manipulation, string processing, and more. In this case, it's used to provide an alternative way to perform reduction operations on arrays using its `_.reduce` function.

**Special JS Feature/Syntax**

There are no special JS features or syntax mentioned in the benchmark definition or test cases.

**Other Alternatives**

If you're interested in exploring other alternatives for reducing arrays, here are a few options:

1. **Array.prototype.reduce()**: This is the native JavaScript method for performing reduction operations on arrays.
2. **Ramda**: Ramda is another popular functional programming library that provides various functions for working with arrays and objects, including `ramda.reduce`.
3. **Underscore.js**: Underscore.js is a utility library similar to Lodash, but with some differences in its API and functionality.

Keep in mind that these alternatives may have different trade-offs in terms of performance, conciseness, or expressiveness compared to the native `reduce` method or the Lodash implementation.

Related benchmarks:

map reduce complex (version: 1)

Comparing performance of: lodash reduce vs reduce

Created: 7 years ago by: Registered User

Jump to the latest result

lodash reduce

reduce

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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