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)
}

​x
 
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])
items.forEach(item => objContainer[item.value])
Array find
items.forEach(item => arrContainer.find(containerItem => containerItem.value === item.value))
items.forEach(item => arrContainer.find(containerItem => containerItem.value === item.value))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Object access
Array find

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 days ago)

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

Browser/OS: Chrome 135 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object access	1308662.6 Ops/sec
Array find	1886.0 Ops/sec

Autogenerated LLM Summary (model gemma2:9b, generated 6 months ago):

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!

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!

Related benchmarks:

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: 4 years ago by: Registered User

Jump to the latest result

Object access

Array find

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gemma2:9b, generated 6 months ago):