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 similar = {
 	all: [],
	ids: [],
	allLength: 1000,
	idsLength: 800
};

for(var i = 0; i < similar.allLength; i++) {
  similar.all[i] = {id: i, value: 'value' + i };
}

for(var i = 0; i < similar.allLength; i++) {
  similar.ids[i] = i;
}
similar.ids = similar.ids.splice(similar.allLength - similar.idsLength)
shuffle(similar.all);
shuffle(similar.ids);

var distant = {
 	all: [],
	ids: [],
	allLength: 1000,
	idsLength: 200
};

for(var i = 0; i < distant.allLength; i++) {
  distant.all[i] = {id: i, value: 'value' + i };
}

for(var i = 0; i < distant.allLength; i++) {
  distant.ids[i] = i;
}
distant.ids = distant.ids.splice(distant.allLength - distant.idsLength)
shuffle(distant.all);
shuffle(distant.ids);

Tests:

800/1000 - map + find iterate on ids
var output = _.map(similar.ids, function(id) { var i = _.findIndex(similar.all, { id: id }); return similar.all[i]; });
800/1000 - reduce + includes iterate on all
var output = _.reduce(similar.all, function(acc, element) { if(similar.ids.indexOf(element.id) !== -1) { acc.push(element); } return acc; }, []);
800/1000 - filter + includes iterate on all
var output = _.filter(similar.all, function(element) { return similar.ids.indexOf(element.id) !== -1; });
200/1000 - map + find iterate on ids
var output = _.map(distant.ids, function(id) { var i = _.findIndex(distant.all, { id: id }); return distant.all[i]; });
200/1000 - reduce + includes iterate on all
var output = _.reduce(distant.all, function(acc, element) { if(distant.ids.indexOf(element.id) !== -1) { acc.push(element); } return acc; }, []);
200/1000 - filter + includes iterate on all
var output = _.filter(distant.all, function(element) { return distant.ids.indexOf(element.id) !== -1; });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
800/1000 - map + find iterate on ids
800/1000 - reduce + includes iterate on all
800/1000 - filter + includes iterate on all
200/1000 - map + find iterate on ids
200/1000 - reduce + includes iterate on all
200/1000 - filter + includes iterate on all

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark compares the performance of three different functions from the Lodash library: `map`, `reduce`, and `filter`. Each function is used to filter or transform an array based on a specific condition. The test cases are identical, with some minor variations in the input data.

**Test Cases**

1. **`200/1000 - filter + includes iterate on all`**: This test case uses `filter` to create a new array that only includes elements where their ID is present in the `similar.ids` array.
2. **`200/1000 - reduce + includes iterate on all`**: This test case uses `reduce` to accumulate an array of elements where their ID is present in the `similar.ids` array.
3. **`800/1000 - filter + includes iterate on all`**: Similar to the first test case, but with a larger input size.
4. **`800/1000 - reduce + includes iterate on all`**: Similar to the second test case, but with a larger input size.

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides a collection of functional programming helpers, including `map`, `reduce`, and `filter`. These functions are used to transform or filter arrays, objects, and other data structures.

**Performance Comparison**

The benchmark measures the execution time for each test case across different browsers and devices. The results show that:

* `map` is generally faster than `filter` and `reduce`.
* `filter` is faster than `reduce`, but both are slower than `map`.
* The performance difference between `map` and `filter` is relatively small, while the difference between `filter` and `reduce` is more significant.

**Implications**

The results suggest that when working with large datasets, using `map` can be a good choice for filtering or transforming data. However, if you need to accumulate values in an array (e.g., summing or counting elements), `reduce` might be a better option.

Related benchmarks:

lodash test (version: 0)

Comparing performance of: 800/1000 - map + find iterate on ids vs 800/1000 - reduce + includes iterate on all vs 800/1000 - filter + includes iterate on all vs 200/1000 - map + find iterate on ids vs 200/1000 - reduce + includes iterate on all vs 200/1000 - filter + includes iterate on all

Created: 8 years ago by: Guest

Jump to the latest result

800/1000 - map + find iterate on ids

800/1000 - reduce + includes iterate on all

800/1000 - filter + includes iterate on all

200/1000 - map + find iterate on ids

200/1000 - reduce + includes iterate on all

200/1000 - filter + includes iterate on all

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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