Benchmark: Test lodash v2 - MeasureThat.net

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/lodash/4.16.0/lodash.min.js"></script>

Script Preparation code:

var array = _.range(100);

Tests:

Strict
_.map(_.filter(array, function(n) { return n > 50; }), function(n) { return {test: n}; });
Lazy
_(array).filter(function(n) { return n > 50; }).map(function(n) { return {test: n}; }).value();
Lazy with one function
_(array).reduce(function(acc, n) { if(n > 50) acc.push({test: n}); return acc; }, []);
Strict with one function
_.reduce(array, function(acc, n) { if(n > 50) acc.push({test: n}); return acc; }, []);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Strict
Lazy
Lazy with one function
Strict with one function

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON benchmark definitions.

**Overview**

The benchmark compares the performance of different approaches to filter and map an array using the Lodash library, a popular JavaScript utility library. The tests are designed to measure the execution time of each approach on a specific use case: filtering an array of 100 numbers greater than 50 and mapping the result to create a new object with a "test" property.

**Benchmark Definitions**

There are four benchmark definitions:

1. **Strict**: `_.map(_.filter(array, function(n) { return n > 50; }), function(n) { return {test: n}; });`
	* This approach uses the `_.map()` method to apply a transformation function to each element in the filtered array. The transformation function creates a new object with a "test" property for each element.
	* Pros: Easy to read and understand, no unnecessary overhead from lazy evaluation.
	* Cons: Creates an intermediate array of transformed objects, which can lead to higher memory usage.
2. **Lazy**: `_(array).filter(function(n) { return n > 50; }).map(function(n) { return {test: n}; }).value();`
	* This approach uses the Lodash `_.map()` method on a lazy pipeline, where the filtering and mapping are done in sequence without creating intermediate arrays.
	* Pros: Reduces memory usage by avoiding unnecessary array creation.
	* Cons: Can be less readable due to the use of lazy evaluation, which may lead to performance overhead if not optimized correctly.
3. **Lazy with one function**: `_(array).reduce(function(acc, n) {\r\n  if(n > 50)\r\n    acc.push({test: n});\r\n  \r\n  return acc;\r\n}, []);`
	* This approach uses the Lodash `_.reduce()` method to accumulate the results of filtering and mapping in a single array.
	* Pros: More efficient than creating intermediate arrays, as it uses a single iteration over the data.
	* Cons: Can be less readable due to the use of `_.reduce()`, which may require more understanding of its behavior.
4. **Strict with one function**: `_.reduce(array, function(acc, n) {\r\n  if(n > 50)\r\n    acc.push({test: n});\r\n  \r\n  return acc;\r\n}, []);`
	* This approach uses the `_.reduce()` method to accumulate the results of filtering and mapping in a single array, similar to the previous example.
	* Pros: More efficient than creating intermediate arrays, as it uses a single iteration over the data.
	* Cons: Less readable due to the use of `_.reduce()`, which may require more understanding of its behavior.

**Library**

The Lodash library is used in all benchmark definitions. Lodash provides a set of utility functions that make it easier to write efficient and concise code, including:

* `_filter()`: Filters an array based on a predicate function.
* `_map()`: Applies a transformation function to each element in an array.
* `_reduce()`: Accumulates the results of applying a reduction function to each element in an array.

**Special JS Feature or Syntax**

None of the benchmark definitions use any special JavaScript features or syntax that would require additional explanation. The code is straightforward and uses only standard JavaScript and Lodash functions.

**Alternatives**

If you're interested in exploring alternative approaches, here are a few options:

* Using native JavaScript methods: You could implement the same filtering and mapping logic using native JavaScript methods like `Array.prototype.filter()` and `Array.prototype.map()`, without relying on Lodash.
* Using ES6+ features: If you're targeting modern browsers or environments that support ES6+, you could use features like arrow functions, template literals, and async/await to simplify the code and improve performance.

Keep in mind that these alternatives might not be as concise or efficient as using Lodash or native JavaScript methods, depending on your specific requirements and constraints.

Latest run results:

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

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

Browser/OS: Chrome 54 on Windows

View result in a separate tab

Test name	Executions per second
Strict	333533.6 Ops/sec
Lazy	278009.1 Ops/sec
Lazy with one function	471430.2 Ops/sec
Strict with one function	503956.1 Ops/sec

Related benchmarks:

Test lodash v2 (version: 0)

Comparing performance of: Strict vs Lazy vs Lazy with one function vs Strict with one function

Created: 7 years ago by: Guest

Jump to the latest result

Strict

Lazy

Lazy with one function

Strict with one function

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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