Benchmark: Array.includes vs Set.has vas Map.has vs Object accessor : with string

Script Preparation code:

var a =  [
  "ZBLF",
  "ZPSF",
  "ZOCF",
  "ZSDF",
  "ZBLP",
  "ZPSP",
  "ZOCP",
  "ZSDP",
  "MWST",
];
var b = new Set([
  "ZBLF",
  "ZPSF",
  "ZOCF",
  "ZSDF",
  "ZBLP",
  "ZPSP",
  "ZOCP",
  "ZSDP",
  "MWST",
]);
var c = new Map([
  ["ZBLF", true],
  ["ZPSF", true],
  ["ZOCF", true],
  ["ZSDF", true],
  ["ZBLP", true],
  ["ZPSP", true],
  ["ZOCP", true],
  ["ZSDP", true],
  ["MWST", true],
]);
var d = {a: "ZBLF", b: "ZPSF", c: "ZOCF", d: "ZSDF", e: "ZBLP", f:"ZPSP", g:"ZOCP", h:"ZSDP", i:"MWST"};

Tests:

Array includes
return a.includes("MWST");
Set has
return b.has("MWST");
Map has
return c.has("MWST");
Object accessor
return d["MWST"]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array includes
Set has
Map has
Object accessor

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.

Measuring the performance of JavaScript microbenchmarks like this one is crucial for understanding the efficiency of various data structures and methods.

Let's dive into what options are being compared:

1. **Array `includes()`**: This method checks if an element with the specified value exists in the array.
2. **Set `has()`**: A Set in JavaScript is a collection of unique values, and this method checks if a specific value exists within it.
3. **Map `has()`**: Similar to Sets, Maps are collections of key-value pairs, and this method checks if a specific key exists within it.
4. **Object accessor (`d[`key`)`: This is simply accessing a property on an object using the bracket notation.

**Pros and Cons:**

*   **Array `includes()`**: Pros:
    *   Generally fast (O(n) time complexity)
    *   Widely supported
    *   Simple implementation
*   Cons:
    *   May have issues with duplicate values or non-unique arrays
    *   Not as efficient as some other methods for very large datasets
*   **Set `has()`**: Pros:
    *   Fast (O(1) time complexity)
    *   Efficient use of memory, eliminating duplicates automatically
    *   Suitable for unique values
*   Cons:
    *   Can be slower than Array `includes()` for arrays with many duplicate values
    *   Not as well-supported in older browsers
*   **Map `has()`**: Pros:
    *   Fast (O(1) time complexity)
    *   Efficient use of memory, eliminating duplicates automatically
    *   Suitable for unique keys
*   Cons:
    *   Can be slower than Set `has()` for sets with many duplicate values
    *   Not as well-supported in older browsers

In general, the choice between these methods depends on the specific requirements of your application:

*   Use Array `includes()` when you need to check if an element exists in a large array and don't mind duplicates.
*   Use Set `has()` or Map `has()` when working with unique values or keys and performance is crucial.

Now, let's talk about some special JavaScript features or syntax that might be used in these benchmarks:

The test cases use no special JavaScript features beyond standard language support. The code snippets provided are straightforward examples of the respective methods being tested.

**Alternative approaches:**

If you want to explore alternative data structures or comparison methods, consider the following options:

*   **Hash tables**: These are similar to Sets and Maps but might be more suitable for certain use cases.
*   **Binary search trees**: These can be used for searching and inserting elements in a data structure efficiently.
*   **Arrays with custom comparisons**: If you need to compare elements in an array using a custom function, this could be a viable option.

For microbenchmarking purposes like the one on MeasureThat.net, though, it's generally best to stick with standard Set, Map, and Array methods, as they are widely supported and have well-understood performance characteristics.

Related benchmarks:

Array.includes vs Set.has vas Map.has vs Object accessor : with string (version: 0)

Comparing performance of: Array includes vs Set has vs Map has vs Object accessor

Created: 2 years ago by: Guest

Jump to the latest result

Array includes

Set has

Map has

Object accessor

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):