Benchmark: With defined array, Array.includes vs String.includes vs Object Hashmap vs Set vs Array.indexOf Large

Script Preparation code:

var testArray = ['foo', 'a','b', 'c','d','e','f','g','h','i','j', 'k', 'l','m','n' ,'bar','o', 'p', 'q', 'r', 's','t','u', 'v','w','x','y', 'z'];

Tests:

Array.includes
const testStrFirst = 'foo'; testArray.includes(testStrFirst); const testStrSecond = 'bar'; testArray.includes(testStrSecond); const testStrNotMatch = 'baz'; testArray.includes(testStrNotMatch);
String.includes
var testString = testArray.join(','); const testStrFirst = 'foo'; testString.includes(testStrFirst); const testStrSecond = 'bar'; testString.includes(testStrSecond); const testStrNotMatch = 'baz'; testString.includes(testStrNotMatch);
Object Hash-map
var objectHash = testArray.reduce((acc, key) => {acc[key] = true; return acc;},{}); const testStrFirst = 'foo'; objectHash[testStrFirst]; const testStrSecond = 'bar'; objectHash[testStrSecond]; const testStrNotMatch = 'baz'; objectHash[testStrNotMatch];
ES6 Set
var testSet = new Set(testArray); const testStrFirst = 'foo'; testSet.has(testStrFirst); const testStrSecond = 'bar'; testSet.has(testStrSecond); const testStrNotMatch = 'baz'; testSet.has(testStrNotMatch);
Array.indexOf
const testStrFirst = 'foo'; testArray.indexOf(testStrFirst); const testStrSecond = 'bar'; testArray.indexOf(testStrSecond); const testStrNotMatch = 'baz'; testArray.indexOf(testStrNotMatch);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.includes
String.includes
Object Hash-map
ES6 Set
Array.indexOf

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the Benchmark Definition and test cases to understand what is being tested.

**What is being tested?**

The benchmark is testing four different approaches for matching a string against an array or a collection of strings:

1. **Array.includes**: This method checks if a given string exists in an array.
2. **String.includes**: This method checks if a given string exists as a substring within another string.
3. **Object Hash-map**: This approach creates a hash map (an object with key-value pairs) and uses the strings as keys to store values, then checks for existence using the key-value pair access.
4. **ES6 Set**: Similar to Object Hash-map, but uses a set data structure instead of an object.

**Options compared**

The benchmark compares these four approaches against each other in terms of performance (executions per second) on different browser versions and platforms (Safari 17 on Mac OS X).

**Pros and Cons of each approach:**

1. **Array.includes**: Fastest approach, as it uses a linear search through the array. However, it may not be suitable for large arrays or strings.
2. **String.includes**: Similar to Array.includes, but faster for larger strings since it only needs to check the length of the string and then perform a substring search. It's also more readable than using an array or object.
3. **Object Hash-map**: Creates a new data structure, which can be slower due to the overhead of creating and maintaining objects. However, it provides fast lookups if you need to access values associated with the strings.
4. **ES6 Set**: Similar to Object Hash-map, but uses a set data structure instead. It's generally faster for large datasets since sets provide fast membership testing.

**Other considerations:**

* All approaches have their own trade-offs in terms of memory usage, complexity, and readability.
* Array.includes and String.includes are suitable for most use cases where speed is important.
* Object Hash-map and ES6 Set might be overkill for simple string matching but can be useful when dealing with large datasets or need to access associated values.

**Special JavaScript features or syntax:**

No specific special features or syntax are used in these benchmark tests. However, it's worth noting that the use of `const` and `let` keywords (not shown in the code snippet) is consistent with modern JavaScript best practices.

Now, regarding alternatives:

Other approaches for matching strings against arrays or collections include using regular expressions (regex), which can be slower but offer more flexibility and power. However, this benchmark focuses on simple string matching without regex patterns.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15

Browser/OS: Safari 17 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Array.includes	6004806.0 Ops/sec
String.includes	2490271.5 Ops/sec
Object Hash-map	2296988.8 Ops/sec
ES6 Set	2038913.0 Ops/sec
Array.indexOf	12116984.0 Ops/sec

Related benchmarks:

With defined array, Array.includes vs String.includes vs Object Hashmap vs Set vs Array.indexOf Large (version: 0)

Matching a string against more than one possibility.

Comparing performance of: Array.includes vs String.includes vs Object Hash-map vs ES6 Set vs Array.indexOf

Created: 9 months ago by: Guest

Jump to the latest result

Array.includes

String.includes

Object Hash-map

ES6 Set

Array.indexOf

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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