Benchmark: find vs enumObject vs findindex

Script Preparation code:

var arr = new Array(150000);
arr.fill({
    id: 0
});
arr = arr.map((el, idx) => el.id = idx);
var foo1 = Math.floor(Math.random() * 150000);
var foo2 = Math.floor(Math.random() * 150000);
var foo3 = Math.floor(Math.random() * 150000);
var foo4 = Math.floor(Math.random() * 150000);
var foo5 = Math.floor(Math.random() * 150000);

Tests:

1
function firstWay(id) { return arr.find(user => user.id === id); } firstWay(foo1); firstWay(foo2); firstWay(foo3); firstWay(foo4); firstWay(foo5);
enum
var userEnum = {}; function secondWay(id) { if (Object.keys(userEnum).length === 0) { arr.forEach(user => userEnum[user.id] = user); } return userEnum[id]; } secondWay(foo1); secondWay(foo2); secondWay(foo3); secondWay(foo4); secondWay(foo5);
findindex
function thirdWay(id) { const idx = arr.findIndex(user => user.id == id); return (idx !== -1) ? arr[idx] : null; } thirdWay(foo1); thirdWay(foo2); thirdWay(foo3); thirdWay(foo4); thirdWay(foo5);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
1
enum
findindex

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmarking test on the MeasureThat.net website. The benchmark compares three approaches to find an element in an array by its ID: `find()`, `enumObject`, and `findIndex()`.

**Tested Approaches**

1. **`find()`**: This method uses the built-in `Array.prototype.find()` function, which iterates over the array elements until it finds a match or reaches the end of the array.
2. **`enumObject` (using an object to store the array)**: In this approach, an object is created to store the array elements, with each element's ID as a property key. This allows for O(1) lookups using the `Object.prototype.hasOwnProperty()` method or `in` operator.
3. **`findIndex()`**: This method uses the built-in `Array.prototype.findIndex()` function, which returns the index of the first element that satisfies the provided callback function or -1 if no element matches.

**Pros and Cons**

*   **`find()`**:
    *   Pros: Simple to implement, widely supported.
    *   Cons: Iterates over the entire array in the worst case (O(n)), potentially slow for large arrays.
*   **`enumObject`**:
    *   Pros: Fast lookups (O(1)) due to object property access, suitable for caching or when the array is not dynamically updated.
    *   Cons: Requires extra memory to store the object and its properties, may not be suitable for dynamic arrays or large datasets.
*   **`findIndex()`**:
    *   Pros: Returns the index of the found element (which can be useful in some use cases), more efficient than `find()` when the array is sorted.
    *   Cons: May return -1 if no element matches, which can lead to unexpected behavior; requires a callback function or arrow function.

**Library and Special Features**

In this benchmark, the following libraries are not explicitly mentioned:

*   No external libraries are required for these tests.
*   There are no special JavaScript features like `async/await`, ` generators` or `promises`.

**Alternative Approaches**

Other approaches to find an element in an array by its ID include:

*   **Using a Map**: Similar to the `enumObject` approach, but using the built-in `Map` object instead of an object literal.
*   **Binary Search**: Suitable for sorted arrays, this method divides the search space in half with each iteration.
*   **Hash Table**: A data structure that maps keys (in this case, IDs) to values (array elements).

These alternatives may offer better performance or efficiency in certain scenarios, but are often more complex to implement and may not be suitable for all use cases.

Related benchmarks:

find vs enumObject vs findindex (version: 0)

find multiple users by id

Comparing performance of: 1 vs enum vs findindex

Created: 4 years ago by: Guest

Jump to the latest result

1

enum

findindex

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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