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) { return _.find(similar.all, { id: id }); });
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) { return _.find(distant.all, { id: id }); });
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

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

MeasureThat.net is a platform that allows users to create and run JavaScript microbenchmarks. The provided benchmark definition and test cases are designed to measure the performance of three different operations: `map`, `reduce`, and `filter`, with various iteration patterns.

**Benchmark Definition JSON**

The benchmark definition JSON contains two main sections:

1. **Script Preparation Code**: This section defines a JavaScript function that shuffles an array using the Fisher-Yates algorithm. It also creates two sets, `similar` and `distant`, containing arrays of objects with `id` and `value` properties.
2. **Html Preparation Code**: This section includes a reference to the Lodash library, which is used in the benchmark tests.

**Individual Test Cases**

There are four test cases:

1. **200/1000 - reduce + includes iterate on all**: This test case uses the `reduce` method to filter an array of objects based on whether their `id` property exists in a separate array.
2. **200/1000 - filter + includes iterate on all**: Similar to the previous test case, but uses the `filter` method instead of `reduce`.
3. **800/1000 - reduce + includes iterate on all**: Another test case using the `reduce` method with a larger iteration size.
4. **800/1000 - filter + includes iterate on all**: The last test case uses the `filter` method with a larger iteration size.

**Options Compared**

The benchmark tests compare the performance of three different operations:

1. **Map**: Uses the `map` method to create a new array from an existing one, without modifying the original array.
2. **Reduce**: Uses the `reduce` method to iterate over an array and apply a callback function to each element.
3. **Filter**: Uses the `filter` method to create a new array with only the elements that pass a test.

The tests also vary the iteration size:

* Small iteration size (200): Faster iterations for smaller arrays.
* Large iteration size (800 or 1000): Slower iterations for larger arrays.

**Performance Results**

The provided performance results show the number of executions per second for each test case, across multiple browser and device configurations. The results suggest that:

* `reduce` is generally faster than `map` for filtering large arrays.
* `filter` is slower than both `map` and `reduce` for small iteration sizes.
* Bigger iteration sizes lead to slower performance for all three operations.

**Conclusion**

In summary, this benchmark highlights the performance differences between three JavaScript array methods (`map`, `reduce`, and `filter`) with varying iteration sizes. The results suggest that `reduce` is generally faster than `map` for filtering large arrays, while `filter` may be slower for small iterations due to its overhead. By understanding these performance characteristics, developers can optimize their code for better performance in different scenarios.

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
800/1000 - map + find iterate on ids	88.1 Ops/sec
800/1000 - reduce + includes iterate on all	1265.8 Ops/sec
800/1000 - filter + includes iterate on all	1249.1 Ops/sec
200/1000 - map + find iterate on ids	354.4 Ops/sec
200/1000 - reduce + includes iterate on all	2565.7 Ops/sec
200/1000 - filter + includes iterate on all	2526.6 Ops/sec

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 25 days ago):