Benchmark: lodash test - MeasureThat.net

HTML Preparation code:

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

Script Preparation code:

function shuffle(a) {
    var j, x, i;
    for (i = a.length; i; i--) {
        j = Math.floor(Math.random() * i);
        x = a[i - 1];
        a[i - 1] = a[j];
        a[j] = x;
    }
}
var all = [];
var ids = [];
var allLength = 1000;
var idsLength = 100;

for(var i = 0; i < allLength; i++) {
  all[i] = i;
}

for(var i = 0; i < allLength; i++) {
  ids[i] = i;
}
ids = ids.splice(allLength - idsLength)
shuffle(all);
shuffle(ids);

Tests:

map + find
var output = _.map(ids, function(element) { return _.find(all, element); }); console.log(output);
reduce + includes
var output = _.reduce(ids, function(acc, element) { if(_.includes(all, element)) { acc.push(element); } return acc; }, []); console.log(output);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
map + find
reduce + includes

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 58 on Windows

View result in a separate tab

Test name	Executions per second
map + find	109.3 Ops/sec
reduce + includes	1549.3 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

MeasureThat.net is a platform for creating and running JavaScript microbenchmarks. The provided JSON represents two benchmark test cases, each testing different approaches to perform common operations with the Lodash library.

**Test Case 1: "map + find"**

The first test case uses the `_.map()` function to transform an array of IDs into an array of elements that can be found in another larger array using `_.find()`. The benchmark prepares two arrays, `all` and `ids`, with 1000 and 100 random integers, respectively. After shuffling both arrays, it runs the test case.

**Test Case 2: "reduce + includes"**

The second test case uses the `_.reduce()` function to accumulate elements in an array that are present in another larger array using `_.includes()`. The benchmark prepares two arrays, `all` and `ids`, with 1000 and 100 random integers, respectively. After shuffling both arrays, it runs the test case.

**Library: Lodash**

Lodash is a utility library for JavaScript that provides functions to manipulate data, handle events, and perform other common tasks. The two test cases use several Lodash functions:

* `_.map()`: applies a given function to each element of an array.
* `_.find()`: finds the first element in an array that satisfies a condition.
* `_.reduce()`: reduces an array by applying a callback function.
* `_.includes()`: checks if an array includes a specific value.

**Special JavaScript Feature: Closures**

The benchmark test cases use closures to capture variables from the surrounding scope. Specifically, the `_.map()` and `_.find()` functions are called with anonymous functions that have access to the outer scope's variables (`ids` and `all`, respectively). This is an example of a closure in JavaScript.

**Pros and Cons**

Here are some pros and cons of each approach:

* **Map + Find**: This approach can be efficient if the `_.find()` function can stop searching as soon as it finds a match. However, if the arrays are very large, this can lead to unnecessary comparisons.
* **Reduce + Includes**: This approach is more memory-efficient than the first one because it accumulates elements in an array and checks for membership using `_.includes()`, which has a lower overhead.

**Other Alternatives**

Here are some alternative approaches that might be used:

* Using a single function, like `Array.prototype.find()` and `Array.prototype.forEach()`, to achieve similar results.
* Implementing the logic manually without relying on Lodash functions, but this would likely lead to less efficient code.

Overall, the choice of approach depends on the specific requirements of the use case, including performance, memory efficiency, and readability.

Related benchmarks:

lodash test (version: 0)

Comparing performance of: map + find vs reduce + includes

Created: 7 years ago by: Guest

Jump to the latest result

map + find

reduce + includes

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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