Benchmark: Array.find vs. Set.has

Script Preparation code:

const SOURCE_DATA = ['one', 'two', 'three', 'four', 'five', 'six'];
const arr = Array.from(SOURCE_DATA);
const set = new Set(SOURCE_DATA);
const existingItem = 'three';
const nonExistingItem = 'nine';
window.testData = {
  SOURCE_DATA,
  arr,
  set,
  existingItem,
  nonExistingItem
};

Tests:

Array.find existing
window.testData.arr.find(e => e === window.testData.existingItem);
Array.find non-existing
window.testData.arr.find(e => e === window.testData.nonExistingItem);
Set.has existing
window.testData.set.has(window.testData.existingItem)
Set.has non-Existing
window.testData.set.has(window.testData.nonExistingItem)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.find existing
Array.find non-existing
Set.has existing
Set.has non-Existing

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 144 on Android

View result in a separate tab

Test name	Executions per second
Array.find existing	30043012.0 Ops/sec
Array.find non-existing	24686876.0 Ops/sec
Set.has existing	45339616.0 Ops/sec
Set.has non-Existing	47869588.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The provided JSON represents a JavaScript microbenchmark test case on MeasureThat.net, which compares the performance of two approaches: using `Array.find` and `Set.has`.

**Options being compared:**

1. **Array.find**: A method that searches for an element in an array and returns it if found.
2. **Set.has**: A method that checks if a value exists in a Set data structure.

**Pros and Cons of each approach:**

*   **Array.find**:
    *   Pros:
        *   More expressive and concise code
        *   Can be used with other array methods like `some`, `every`
    *   Cons:
        *   May have higher overhead due to the iteration process
        *   Requires more memory allocation for potential array copies
*   **Set.has**:
    *   Pros:
        *   Generally faster and more efficient, as it uses a hash table data structure
        *   Can be used for membership testing without iterating over the set
    *   Cons:
        *   Less expressive code compared to `Array.find`
        *   Limited use cases beyond membership testing

**Library usage:**

In this test case, two libraries are used:

1.  **`Array.from()`**: Used to convert an array-like object (in this case, a string array) into an actual JavaScript array.
2.  No other library is explicitly mentioned.

**Special JS feature or syntax:**

The test uses the following features:

1.  **Arrow functions**: Used in the `find` method definitions for concise and expressive code.
2.  **Template literals**: Used to define string values, such as `"one", "two", ...`.
3.  **Set data structure**: Implemented using the native JavaScript `Set` object.

**Other alternatives:**

If you need to implement these operations differently, consider the following:

1.  For membership testing (like `Set.has`):
    *   You could create a custom hash table or use an existing library like Lodash's `hasIn`.
2.  For array search and manipulation:
    *   Use other array methods, such as `indexOf`, `forEach`, or implement your own search algorithm.

Keep in mind that the best approach depends on your specific requirements, such as performance, readability, and maintainability of code.

To write this test case from scratch, you would need to create a similar JavaScript file with the same data structures and operations. Here's an example of how it might look:

```javascript
const SOURCE_DATA = ['one', 'two', 'three', 'four', 'five', 'six'];
const arr = Array.from(SOURCE_DATA);
const set = new Set(SOURCE_DATA);

const existingItem = 'three';
const nonExistingItem = 'nine';

function findArrayElement(element) {
  return arr.find(e => e === element);
}

console.log(findArrayElement(existingItem));
console.log(findArrayElement(nonExistingItem));

function checkSetMembership(item) {
  return set.has(item);
}

console.log(checkSetMembership(existingItem));
console.log(checkSetMembership(nonExistingItem));
```

This implementation uses similar approaches but implements them from scratch, without relying on the `Array.from` and `Set` methods.

Related benchmarks:

Array.find vs. Set.has (version: 0)

Compares a performance of Array.find on a small number of items

Comparing performance of: Array.find existing vs Array.find non-existing vs Set.has existing vs Set.has non-Existing

Created: 5 years ago by: Guest

Jump to the latest result

Array.find existing

Array.find non-existing

Set.has existing

Set.has non-Existing

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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