Benchmark: exclusion lookup

Tests:

array indexOf
var a = ["h0", "h1"]; var b = ["h0", "h2", "h1", "h3"]; var c = b.filter(x => a.indexOf(x) === -1);
object key
var a = { "h0": 1, "h1": 1 }; var b = ["h0", "h2", "h1", "h3"]; var c = b.filter(x => !a[x]);
set lookup
var a = new Set(["h0", "h1"]); var b = ["h0", "h2", "h1", "h3"]; var c = b.filter(x => !a.has(x));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array indexOf
object key
set lookup

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 years ago)

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

Browser/OS: Chrome 89 on Windows

View result in a separate tab

Test name	Executions per second
array indexOf	21196276.0 Ops/sec
object key	14280606.0 Ops/sec
set lookup	3529134.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Overview**

The provided benchmark measures the performance of three different approaches for exclusion lookups in JavaScript:

1. **Array `indexOf` method**: This approach uses the built-in `indexOf` method to search for a value in an array.
2. **Object key lookup with negation**: This approach uses an object's properties as keys and negates the result when searching for a non-existent key.
3. **Set lookup**: This approach uses the `has` method of a Set data structure to check if a value is present.

**Options Compared**

The benchmark compares these three approaches on an array and an object, both with different values. The test cases are designed to highlight the performance differences between each approach.

**Pros and Cons of Each Approach**

1. **Array `indexOf` method**:
	* Pros: Wide support across browsers, simple to implement.
	* Cons: Can be slow for large arrays due to its linear search algorithm.
2. **Object key lookup with negation**:
	* Pros: Generally faster than the array approach, as it uses a hash table under the hood.
	* Cons: Requires an object to be created, which can add overhead.
3. **Set lookup**:
	* Pros: Fast and efficient for checking membership in a set, especially for large sets.
	* Cons: May require additional memory allocation for the Set data structure.

**Library Usage**

The benchmark uses no external libraries, as it only focuses on the JavaScript core functionality.

**Special JS Features/Syntax**

There are no special JS features or syntax used in this benchmark that would require specific knowledge of those features to understand. The focus is solely on the performance comparison of these three exclusion lookup approaches.

**Alternatives**

If you're interested in exploring alternative approaches, here are a few options:

* **Regular expressions**: Using regular expressions can provide a more efficient solution for certain types of lookups.
* **Sparse arrays**: Using sparse arrays (arrays with null or undefined values) can be faster than using dense arrays for large datasets.
* **Native WebAssembly support**: Modern browsers have excellent support for native WebAssembly, which can provide significant performance benefits for certain types of computations.

Keep in mind that these alternatives might require additional setup and configuration on the MeasureThat.net platform.

Related benchmarks:

exclusion lookup (version: 0)

Comparing performance of: array indexOf vs object key vs set lookup

Created: 3 years ago by: Guest

Jump to the latest result

array indexOf

object key

set lookup

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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