Benchmark: Hashmap vs Array.Filter

Script Preparation code:

const counter = 10000
const map = new Map()
const array = new Array(counter)

window.counter = counter
window.map = map
window.array = array
for (let i = 0; i < counter; i++) {
    map.set(i)
    array[counter] = i
}

Tests:

Hashmap
for (let i = 0; i < 20000; i++) { window.map.has(500) }
Array.filter
for (let i = 0; i < 20000; i++) { window.array.filter((value) => value === 500) }

Historical Performance Data aggregated from 42 community runs

Desktop Results:

Chrome 33 runs

Hashmap

869/s

Array.filter

0/s

Fastest: Hashmap (2325.6x faster)

View exact numbers

✓ Hashmap: 869 ops/sec
• Array.filter: 0 ops/sec

Firefox 9 runs

Hashmap

572/s

Array.filter

1/s

Fastest: Hashmap (960.8x faster)

View exact numbers

✓ Hashmap: 572 ops/sec
• Array.filter: 1 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
Hashmap
Array.filter

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/137.0.0.0 Safari/537.36

Browser/OS: Chrome 137 on Windows

View result in a separate tab

Hashmap

19K/s

Array.filter

0/s

View exact numbers

Test name	Executions per second
✓ Hashmap	18,745 Ops/sec
Array.filter	0 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 benchmark and explain what's being tested.

**Benchmark Definition**

The benchmark is designed to compare two approaches:

1. **Hashmap**: Using the `Map` data structure in JavaScript to test its performance for fast lookups.
2. **Array.filter**: Using the `filter()` method on an array to test its performance for filtering elements based on a condition.

**Options Compared**

In this benchmark, we have two options being compared:

*   Hashmap (using `Map`)
*   Array.filter

These two approaches are being tested for their execution speed and efficiency in performing fast lookups or filtering elements.

**Pros and Cons of Each Approach:**

### Hashmap

Pros:

*   Hashmaps provide fast lookups with an average time complexity of O(1), making them suitable for applications that require frequent searches.
*   They can handle a large number of key-value pairs efficiently.

Cons:

*   Hashmaps are not designed specifically for filtering elements, which can lead to slower performance compared to other data structures like arrays.

### Array.filter

Pros:

*   The `filter()` method is optimized for filtering elements in an array and has a time complexity of O(n), making it suitable for applications that require element removal.
*   It's a built-in method, so you don't need to create a custom implementation.

Cons:

*   The `filter()` method scans the entire array, which can lead to slower performance compared to other data structures like hashmaps.
*   It may not be as efficient for large datasets since it requires additional memory allocations and copies of elements.

**Library and Purpose**

In this benchmark, no specific library is being used. However, it's worth noting that some JavaScript environments might use a `Map` implementation that's derived from the V8 engine (used in Chrome). This could affect the performance results.

**Special JS Feature or Syntax**

There are no special JavaScript features or syntax mentioned in this benchmark. The code is straightforward and uses standard JavaScript constructs.

**Other Alternatives**

Some other data structures you might consider for this type of benchmark include:

*   **Set**: Similar to `Map`, but it's more lightweight and optimized for fast lookups.
*   **Sqrtcache**: A custom implementation of a cache that uses a square root table for fast lookups.
*   **Trie** (also known as a prefix tree): An efficient data structure for storing and searching key-value pairs, especially when the keys are strings.

Keep in mind that these alternatives might have different performance characteristics depending on your specific use case and requirements.

Hashmap vs Array.Filter (version: 0)

Comparing performance of: `Hashmap vs Array.filter`

Created: 6 years ago by: Guest

Go to the latest result

Hashmap

Array.filter

Historical Performance Data aggregated from 42 community runs

Desktop Results:

Chrome 33 runs

Firefox 9 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Hashmap vs Array.Filter (version: 0)

Comparing performance of: Hashmap vs Array.filter

Created: 6 years ago by: Guest

Go to the latest result

Hashmap

Array.filter

Historical Performance Data aggregated from 42 community runs

Desktop Results:

Chrome 33 runs

Firefox 9 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: `Hashmap vs Array.filter`