Benchmark: .find() vs direct access in object by id

Script Preparation code:

function shuffleArray(array) {
    for (let i = array.length - 1; i > 0; i--) {
        const j = Math.floor(Math.random() * (i + 1));
        [array[i], array[j]] = [array[j], array[i]];
    }
}

var ids = [];
var uuids = [];
var entities = {};
var itemIdByUuid = {};
for(let i = 0; i < 5000; i++) {
  const obj = {
    id: `id${i}`,
    uuid: crypto.randomUUID(),
    foo: "bar",
    bar: "foo",
  };
  
  entities[obj.id] = obj;
  ids.push(obj.id);
  itemIdByUuid[obj.uuid] = obj.id;
}

​x
 
function shuffleArray(array) {    for (let i = array.length - 1; i > 0; i--) {        const j = Math.floor(Math.random() * (i + 1));        [array[i], array[j]] = [array[j], array[i]];    }}​var ids = [];var uuids = [];var entities = {};var itemIdByUuid = {};for(let i = 0; i < 5000; i++) {  const obj = {    id: `id${i}`,    uuid: crypto.randomUUID(),    foo: "bar",    bar: "foo",  };    entities[obj.id] = obj;  ids.push(obj.id);  itemIdByUuid[obj.uuid] = obj.id;}

Tests:

finding item using find with Object.values
const randomUUID = uuids[Math.floor(Math.random() * uuids.length)]; const itemMatchingSomeUUID = Object.values(entities).find((obj) => obj.uuid === randomUUID);
const randomUUID = uuids[Math.floor(Math.random() * uuids.length)];
const itemMatchingSomeUUID = Object.values(entities).find((obj) => obj.uuid === randomUUID);
finding item using find without Object.values (accessing entities using the ids array)
const randomUUID = uuids[Math.floor(Math.random() * uuids.length)]; const itemMatchingSomeUUID = ids.map((id) => entities[id]).find((obj) => obj.uuid === randomUUID);
const randomUUID = uuids[Math.floor(Math.random() * uuids.length)];
const itemMatchingSomeUUID = ids.map((id) => entities[id]).find((obj) => obj.uuid === randomUUID);
using the itemIdByUuid "projection" we created
const randomUUID = uuids[Math.floor(Math.random() * uuids.length)]; const itemMatchingSomeUUID = entities[itemIdByUuid[randomUUID]];
const randomUUID = uuids[Math.floor(Math.random() * uuids.length)];
const itemMatchingSomeUUID = entities[itemIdByUuid[randomUUID]];

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
finding item using find with Object.values
finding item using find without Object.values (accessing entities using the ids array)
using the itemIdByUuid "projection" we created

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 123 on Windows

View result in a separate tab

Test name	Executions per second
finding item using find with Object.values	768.4 Ops/sec
finding item using find without Object.values (accessing entities using the ids array)	1698.4 Ops/sec
using the itemIdByUuid "projection" we created	2131273.5 Ops/sec

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

Let's dive into the Benchmark Definition and individual test cases to understand what is being tested.

Benchmark Definition:

The benchmark measures the performance of three approaches for accessing and finding items in an object by their ID:

Using find() method with Object.values(): This approach uses the find() method on the array of objects (Object.values(entities)) to find the item with a matching UUID.
Direct access using IDs array: This approach accesses the entities object directly using the IDs array (ids) and then finds the item with a matching UUID using the find() method.
Using "projection" with itemIdByUuid object: This approach uses a precomputed mapping of UUIDs to IDs (itemIdByUuid) to access the corresponding ID for each UUID and then finds the item in the entities object.

Options compared:

The three approaches are compared to determine which one is the fastest. The results show that:

Using find() with Object.values() has an execution speed of approximately 2131 executions per second.
Direct access using IDs array has a slower execution speed of around 1698 executions per second.
Using "projection" with itemIdByUuid object is the slowest, with an execution speed of about 768 executions per second.

Pros and Cons:

Here's a brief summary of the pros and cons of each approach:

Using find() with Object.values():
- Pros:
  - Simple and intuitive code
  - Does not require explicit knowledge of the data structure
- Cons:
  - May be slower due to the need to create a new array of objects
Direct access using IDs array:
- Pros:
  - Can be faster since it directly accesses the entities object
- Cons:
  - Requires explicit knowledge of the data structure (IDs array)
Using "projection" with itemIdByUuid object:
- Pros:
  - Can be optimized using a precomputed mapping (in this case, itemIdByUuid)
- Cons:
  - May require more memory to store the mapping
  - Can be slower due to the need to perform lookups

Library:

The benchmark uses the following libraries:

crypto: used for generating random UUIDs
Math.random(): used for shuffling the array of objects

JavaScript features/syntax:

None.

Other considerations:

The benchmark is run on a Chrome browser, which may affect the results due to its specific implementation of the find() method and object lookup.
The test cases are designed to minimize memory allocation and garbage collection, which can impact performance.
The use of an array of objects (Object.values(entities)) creates a new array that needs to be managed, which can add overhead.

Alternatives:

Other approaches for accessing and finding items in an object by their ID might include:

Using a single lookup object (e.g., itemIdByUuid)
Using a data structure like a trie or a binary search tree
Implementing custom binary searching algorithms

However, these alternatives may have trade-offs in terms of memory usage, complexity, and performance.

LLMs can make mistakes. Check important info.

Let's dive into the Benchmark Definition and individual test cases to understand what is being tested.

**Benchmark Definition:**

The benchmark measures the performance of three approaches for accessing and finding items in an object by their ID:

1. **Using `find()` method with `Object.values()`**: This approach uses the `find()` method on the array of objects (`Object.values(entities)`) to find the item with a matching UUID.
2. **Direct access using IDs array**: This approach accesses the `entities` object directly using the IDs array (`ids`) and then finds the item with a matching UUID using the `find()` method.
3. **Using "projection" with `itemIdByUuid` object**: This approach uses a precomputed mapping of UUIDs to IDs (`itemIdByUuid`) to access the corresponding ID for each UUID and then finds the item in the `entities` object.

**Options compared:**

The three approaches are compared to determine which one is the fastest. The results show that:

* Using `find()` with `Object.values()` has an execution speed of approximately 2131 executions per second.
* Direct access using IDs array has a slower execution speed of around 1698 executions per second.
* Using "projection" with `itemIdByUuid` object is the slowest, with an execution speed of about 768 executions per second.

**Pros and Cons:**

Here's a brief summary of the pros and cons of each approach:

1. **Using `find()` with `Object.values()`:**
	* Pros:
		+ Simple and intuitive code
		+ Does not require explicit knowledge of the data structure
	* Cons:
		+ May be slower due to the need to create a new array of objects
2. **Direct access using IDs array:**
	* Pros:
		+ Can be faster since it directly accesses the `entities` object
	* Cons:
		+ Requires explicit knowledge of the data structure (IDs array)
3. **Using "projection" with `itemIdByUuid` object:**
	* Pros:
		+ Can be optimized using a precomputed mapping (in this case, `itemIdByUuid`)
	* Cons:
		+ May require more memory to store the mapping
		+ Can be slower due to the need to perform lookups

**Library:**

The benchmark uses the following libraries:

1. `crypto`: used for generating random UUIDs
2. `Math.random()`: used for shuffling the array of objects

**JavaScript features/syntax:**

None.

**Other considerations:**

* The benchmark is run on a Chrome browser, which may affect the results due to its specific implementation of the `find()` method and object lookup.
* The test cases are designed to minimize memory allocation and garbage collection, which can impact performance.
* The use of an array of objects (`Object.values(entities)`) creates a new array that needs to be managed, which can add overhead.

**Alternatives:**

Other approaches for accessing and finding items in an object by their ID might include:

1. Using a single lookup object (e.g., `itemIdByUuid`)
2. Using a data structure like a trie or a binary search tree
3. Implementing custom binary searching algorithms

However, these alternatives may have trade-offs in terms of memory usage, complexity, and performance.

Related benchmarks:

.find() vs direct access in object by id (version: 0)

Comparing performance of: finding item using find with Object.values vs finding item using find without Object.values (accessing entities using the ids array) vs using the itemIdByUuid "projection" we created

Created: 3 years ago by: Guest

Jump to the latest result

finding item using find with Object.values

finding item using find without Object.values (accessing entities using the ids array)

using the itemIdByUuid "projection" we created

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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