Benchmark: Include vs Binary search in sorted array vs Map.has() vs Object[]

Script Preparation code:

var array = [];
var map = new Map();
var obj = {};

for (var i = 0; i < 2000; i++){
  array.push(Math.random());
  map.set(i,true);
  obj[i]=true;
}
var sorted = array.sort()

function binaryIndexOf(searchElement) {

 
    var minIndex = 0;
    var maxIndex = this.length - 1;
    var currentIndex;
    var currentElement;
 
    while (minIndex <= maxIndex) {
        currentIndex = (minIndex + maxIndex) / 2 | 0;
        currentElement = this[currentIndex];
 
        if (currentElement < searchElement) {
            minIndex = currentIndex + 1;
        }
        else if (currentElement > searchElement) {
            maxIndex = currentIndex - 1;
        }
        else {
            return currentIndex;
        }
    }
 
    return -1;
}

Tests:

Includes
sorted.includes(5)
binary
binaryIndexOf.call(sorted, 5)
Map.has()
map.has(5);
Obj[]
obj[5]

Historical Performance Data aggregated from 13 community runs

Desktop Results:

Chrome 13 runs

Obj[]

37.9M/s

Map.has()

32.1M/s

binary

15.4M/s

Includes

1.3M/s

Fastest: Obj[] (29.4x faster)

View exact numbers

✓ Obj[]: 37,857,708 ops/sec
• Map.has(): 32,104,814 ops/sec
• binary: 15,371,528 ops/sec
• Includes: 1,288,652 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
Includes
binary
Map.has()
Obj[]

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36

Browser/OS: Chrome 132 on Chrome OS 14541.0.0

View result in a separate tab

Obj[]

71.3M/s

Map.has()

70.7M/s

binary

19.2M/s

Includes

491K/s

View exact numbers

Test name	Executions per second
✓ Obj[]	71,325,104 Ops/sec
Map.has()	70,701,072 Ops/sec
binary	19,182,264 Ops/sec
Includes	491,244 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON data and explain what's being tested.

**Overall Benchmark**

The benchmark measures the performance of different ways to check for existence in an array or object:

1. `sorted.includes(5)` (using the `includes()` method)
2. `binaryIndexOf.call(sorted, 5)` (using a custom binary search algorithm)
3. `map.has(5);` (using the `Map.prototype.has()` method)
4. `obj[5]` (direct indexing into an object)

**Script Preparation Code**

The script preparation code creates:

* An empty array (`array`)
* A new Map object (`map`) and populates it with 2000 random key-value pairs
* An empty object (`obj`)
* Sorts the array in ascending order

**Library Used: None ( native JavaScript methods)**

All four test cases use only built-in JavaScript methods, without importing any external libraries.

**Test Cases**

Each test case measures the performance of a specific method:

1. `Includes`: Uses the `includes()` method to search for an element in a sorted array.
2. `binary`: Uses a custom binary search algorithm to find an element in a sorted array.
3. `Map.has()`: Uses the `Map.prototype.has()` method to check if a key exists in a Map object.
4. `Obj[]`: Directly indexes into an object using square brackets (`[]`) to access a value.

**Pros and Cons**

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

1. **Includes()**: Fast and straightforward, but may not be optimized for large arrays. (High)
2. **Binary Search**: More complex and potentially slower due to the overhead of recursive function calls or iteration. However, it can be more efficient for very large arrays. (Medium-Low)
3. **Map.has()**: May involve additional memory allocations and garbage collection, but is generally fast and efficient. (High)
4. **Obj[]**: Direct indexing into an object is simple but may not be optimized for performance. (Low-Medium)

**Other Considerations**

* The use of `includes()` can lead to a faster result if the array contains duplicate elements.
* Binary search is more suitable for large arrays where random access is needed.

**Benchmark Result Interpretation**

The provided benchmark results show that:

* The execution speed increases as the test case becomes simpler (e.g., `Obj[]` > `binary` > `Map.has()`).
* Chrome 127 (a specific browser and version) produces the fastest results for each test case.

Keep in mind that these results may not generalize to other browsers or environments.

Include vs Binary search in sorted array vs Map.has() vs Object[] (version: 0)

Comparing performance of: `Includes vs binary vs Map.has() vs Obj[]`

Created: 4 years ago by: Guest

Go to the latest result

Includes

binary

Map.has()

Obj[]

Historical Performance Data aggregated from 13 community runs

Desktop Results:

Chrome 13 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Include vs Binary search in sorted array vs Map.has() vs Object[] (version: 0)

Comparing performance of: Includes vs binary vs Map.has() vs Obj[]

Created: 4 years ago by: Guest

Go to the latest result

Includes

binary

Map.has()

Obj[]

Historical Performance Data aggregated from 13 community runs

Desktop Results:

Chrome 13 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `Includes vs binary vs Map.has() vs Obj[]`