Benchmark: using data set. array vs object

Script Preparation code:

data_array = [];
data_object = {};

for(let i = 0; i < 100; i++){
  const data = {
    idx: i,
    key: i % 3,
    text: i +'text'
  }
  
  data_array.push(data);
  data_object[i] = data;
}

find_index = 5;

Tests:

array find
const data = data_array.find((row) => { return row.idx === find_index });
object find
const data = data_object[find_index];
array filter
const data = data_array.filter((row) => { return row.key === 2 });
object filter
const data = Object.keys(data_object).filter((key) => { return data_object[key].key === 2 });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array find
object find
array filter
object filter

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:75.0) Gecko/20100101 Firefox/75.0

Browser/OS: Firefox 75 on Ubuntu

View result in a separate tab

Test name	Executions per second
array find	16611388.0 Ops/sec
object find	66350824.0 Ops/sec
array filter	1446634.6 Ops/sec
object filter	241525.2 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark measures the performance of three different approaches for finding data in an array and an object: `Array.prototype.find()`, `Object.prototype.hasOwnProperty.call()`-based approach, and `Array.prototype.filter()`. The test creates a large dataset of 100 objects with various keys and values to simulate real-world scenarios.

**Options Compared**

1. **`Array.prototype.find()`**: This method searches for the first element in an array that satisfies the provided callback function.
2. **Object-based approach**: This method uses `Object.prototype.hasOwnProperty.call()` to check if a key exists in the object and then returns the corresponding value.
3. **`Array.prototype.filter()`**: This method creates a new array with all elements that pass the test implemented by the provided callback function.

**Pros and Cons of Each Approach**

1. **`Array.prototype.find()`**:
	* Pros: Efficient for finding a single element in an array, readable code.
	* Cons: May not be suitable for large datasets or arrays with no matching elements, can throw if the callback function returns `undefined`.
2. **Object-based approach**:
	* Pros: Suitable for objects where keys are unique and can be looked up efficiently.
	* Cons: Less readable code, may have performance issues with very large datasets.
3. **`Array.prototype.filter()`**:
	* Pros: Efficient for creating a new array with multiple conditions, less memory-intensive than using `Object.keys()`.
	* Cons: May return an empty array if no elements match the callback function, can be slower than `find()` for single-element searches.

**Library and Special JS Features**

The benchmark uses the following libraries:

1. **`Array.prototype.find()`**: A built-in JavaScript method introduced in ECMAScript 2015.
2. **`Object.keys()`**: A built-in JavaScript method introduced in ECMAScript 2015.
3. **`Object.prototype.hasOwnProperty.call()`**: A built-in JavaScript method that checks if an object has a specific property.

No special JS features or syntax are used beyond the built-in methods mentioned above.

**Other Alternatives**

Alternative approaches for finding data in an array and an object include:

1. Using `Array.prototype.indexOf()` instead of `Array.prototype.find()`.
2. Implementing your own loop-based search using `Array.prototype.forEach()` and checking each element.
3. Using a library like Lodash or Underscore.js, which provide additional utility functions for working with arrays and objects.

Keep in mind that the performance differences between these approaches can be significant, especially for large datasets. The benchmark's results should be used as a starting point to evaluate your specific use case and choose the most efficient approach.

Related benchmarks:

using data set. array vs object (version: 0)

Comparing performance of: array find vs object find vs array filter vs object filter

Created: 4 years ago by: Registered User

Jump to the latest result

array find

object find

array filter

object filter

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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