Benchmark: Object key access vs array find

Script Preparation code:

var items = Array.from(Array(1000), (_,x) => ({key: x, value: x*10}));

var objContainer = {};
var arrContainer = [];

for (let i = 100; i >= 0; i--) {
  const index = Math.floor(Math.random() * 1000);
  const item = items[index];
  objContainer[item.key] = item;
  arrContainer.push(item)
}

Tests:

Object access
items.forEach(item => objContainer[item.value])
Array find
items.forEach(item => arrContainer.find(containerItem => containerItem.value === item.value))

Historical Performance Data aggregated from 227 community runs

Desktop Results:

Chrome 159 runs

Object access

30K/s

Array find

4K/s

Fastest: Object access (8.3x faster)

View exact numbers

✓ Object access: 29,967 ops/sec
• Array find: 3,628 ops/sec

Firefox 33 runs

Object access

127K/s

Array find

5K/s

Fastest: Object access (25.3x faster)

View exact numbers

✓ Object access: 127,020 ops/sec
• Array find: 5,014 ops/sec

Other 6 runs

Object access

14K/s

Array find

2K/s

Fastest: Object access (8.4x faster)

View exact numbers

✓ Object access: 14,135 ops/sec
• Array find: 1,689 ops/sec

Mobile Results:

Chrome 16 runs

Object access

18K/s

Array find

4K/s

Fastest: Object access (4.8x faster)

View exact numbers

✓ Object access: 18,210 ops/sec
• Array find: 3,764 ops/sec

Safari 13 runs

Object access

24K/s

Array find

5K/s

Fastest: Object access (5.0x faster)

View exact numbers

✓ Object access: 23,821 ops/sec
• Array find: 4,806 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object access
Array find

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 months ago)

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

Browser/OS: Chrome 147 on Windows

View result in a separate tab

Object access

1.9M/s

Array find

2K/s

View exact numbers

Test name	Executions per second
✓ Object access	1,907,334 Ops/sec
Array find	1,676 Ops/sec

Autogenerated LLM Summary (model gemma2:9b, generated one year ago):

LLMs can make mistakes. Check important info.

This benchmark compares two ways to find an object within a collection: accessing it directly through an object key and using the `find` method on an array.

**Object Access:**

* **Benchmark Definition:**  `items.forEach(item => objContainer[item.value])`
* This approach iterates through each item in the 'items' array. For every item, it uses the `item.value` as a key to access and potentially modify an object (`objContainer`).

**Array Find:**

* **Benchmark Definition:** `items.forEach(item => arrContainer.find(containerItem => containerItem.value === item.value))`
* This approach also iterates through each item in the 'items' array. However, for every item, it uses the `find` method on the `arrContainer` array to locate an object whose `value` property matches the current item's `value`.

**Pros and Cons:**

| Approach      | Pros                                       | Cons                                            |
|--------------|--------------------------------------------|--------------------------------------------------|
| **Object Access** | Potentially faster for retrieving a specific value if you know the key in advance.     | Requires knowing the object's key structure beforehand. Less flexible than array-based searching.|
| **Array Find** |  More flexible, can search based on any property. Can handle dynamic data structures more easily. | Potentially slower than direct object access for frequent lookups using known keys.      |

**Other Considerations:**

* **Data Structure:** The choice between these approaches depends heavily on the nature of your data. If you have a well-defined structure with predictable keys, object access might be faster. If your data is more dynamic or you need to search based on various criteria, `find` offers more flexibility.
* **Frequency of Access:** For very frequent lookups using known keys, object access can be significantly faster. However, if the search criteria are complex or change frequently, `find` might be a better choice.

**Alternatives:**

Besides these two methods, consider:

* **Hash Tables (Map):**  If you need to perform extremely fast key-value lookups, hash tables provide near constant time complexity for both insertion and retrieval.
* **Libraries like Lodash:** Libraries like Lodash offer optimized `find` implementations that might be faster than the built-in array method.

Let me know if you have any other questions!

Object key access vs array find (version: 0)

Test speed of object access by key vs array find to find object

Comparing performance of: `Object access vs Array find`

Created: 6 years ago by: Registered User

Go to the latest result

Object access

Array find

Historical Performance Data aggregated from 227 community runs

Desktop Results:

Chrome 159 runs

Firefox 33 runs

Other 6 runs

Mobile Results:

Chrome 16 runs

Safari 13 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gemma2:9b, generated one year ago):

Object key access vs array find (version: 0)

Test speed of object access by key vs array find to find object

Comparing performance of: Object access vs Array find

Created: 6 years ago by: Registered User

Go to the latest result

Object access

Array find

Historical Performance Data aggregated from 227 community runs

Desktop Results:

Chrome 159 runs

Firefox 33 runs

Other 6 runs

Mobile Results:

Chrome 16 runs

Safari 13 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gemma2:9b, generated one year ago):

Related benchmarks

Comparing performance of: `Object access vs Array find`