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 = _.indexOf(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 = _.indexOf(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:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.75 Safari/537.36

Browser/OS: Chrome 68 on Mac OS X 10.13.5

View result in a separate tab

Test name	Executions per second
800/1000 - map + find iterate on ids	961.1 Ops/sec
800/1000 - reduce + includes iterate on all	1567.3 Ops/sec
800/1000 - filter + includes iterate on all	1507.4 Ops/sec
200/1000 - map + find iterate on ids	3879.4 Ops/sec
200/1000 - reduce + includes iterate on all	3387.8 Ops/sec
200/1000 - filter + includes iterate on all	3357.8 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll provide an explanation of the benchmark and its test cases.

**What is being tested?**

The provided JSON represents a JavaScript microbenchmark that tests the performance of four different functions: `map`, `reduce`, `filter`, and their combinations with iteration on IDs. The functions are part of the Lodash library, which provides utility functions for functional programming in JavaScript.

**Options compared**

Here's an overview of what each test case is testing:

1. **800/1000 - map + find iterate on ids**: Tests the performance of `_.map` and `_.indexOf` functions together when iterating over IDs.
2. **800/1000 - reduce + includes iterate on all**: Tests the performance of `_.reduce` and `_.includes` functions together when iterating over all elements.
3. **800/1000 - filter + includes iterate on all**: Tests the performance of `_.filter` and `_.includes` functions together when iterating over all elements.
4. **200/1000 - map + find iterate on ids**: Tests the performance of `_.map` and `_.indexOf` functions together when iterating over IDs, with fewer elements than the previous test case.
5. **200/1000 - reduce + includes iterate on all**: Tests the performance of `_.reduce` and `_.includes` functions together when iterating over all elements, with fewer elements than the previous test case.
6. **200/1000 - filter + includes iterate on all**: Tests the performance of `_.filter` and `_.includes` functions together when iterating over all elements, with fewer elements than the previous test case.

**Iteration vs. Direct lookup**

The tests are designed to measure the performance difference between two approaches:

* Iteration: Looping through an array or object using a traditional loop (e.g., `for`, `forEach`) and accessing each element individually.
* Direct lookup: Using methods like `_.indexOf` or `_.includes` that directly look up elements in an array or object.

The tests compare the performance of these two approaches, as iteration can be slower than direct lookup for large datasets.

**Lodash library**

The benchmark uses Lodash functions to perform the iterations and lookups. The specific functions used are:

* `_map`: Applies a given function to each element of an array.
* `_reduce`: Accumulates a value by applying a given function to each element in an array, passing the accumulated value as the first argument to the next iteration.
* `_filter`: Creates a new array with all elements that pass the test implemented by the provided function.
* `_indexOf`: Returns the index of the first occurrence of the specified value in an array.
* `_includes`: Checks if an array includes all values passed in the `values` array.

**Browsers and devices**

The benchmark results are from a Chrome 68 browser running on a Mac OS X 10.13.5 desktop device. The test name and device information suggest that the tests may be optimized for this specific setup, which could affect the results across other browsers, devices, or environments.

Overall, this benchmark provides insight into how different JavaScript functions perform in various scenarios, including iteration vs. direct lookup, and can help developers understand performance trade-offs when choosing between these approaches.

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: 7 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>

Experimental features:

Fastest: N/A

Slowest: N/A

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