Benchmark: Array.includes vs String.match

Tests:

Array.includes
const testStrFirst = 'foo'; ['foo', 'bar'].includes(testStrFirst); const testStrSecond = 'bar'; ['foo', 'bar'].includes(testStrSecond); const testStrNotMatch = 'baz'; ['foo', 'bar'].includes(testStrNotMatch);
String.match
const testStrFirst = 'foo'; testStrFirst.match(/^(foo|bar)$/); const testStrSecond = 'bar'; testStrSecond.match(/^(foo|bar)$/); const testStrNotMatch = 'baz'; testStrNotMatch.match(/^(foo|bar)$/);
Multiple if Conditions
const testStrFirst = 'foo'; if (testStrFirst == 'foo' || testStrFirst == 'bar') {} const testStrSecond = 'bar'; if (testStrFirst == 'foo' || testStrFirst == 'bar') {} const testStrNotMatch = 'baz'; if (testStrFirst == 'foo' || testStrFirst == 'bar') {}

Historical Performance Data aggregated from 19 community runs

Desktop Results:

Chrome 19 runs

Multiple if Conditions

173.8M/s

Array.includes

79.5M/s

String.match

11.8M/s

Fastest: Multiple if Conditions (14.7x faster)

View exact numbers

✓ Multiple if Conditions: 173,823,872 ops/sec
• Array.includes: 79,493,744 ops/sec
• String.match: 11,819,268 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
Array.includes
String.match
Multiple if Conditions

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36

Browser/OS: Chrome 135 on Mac OS X 10.15.7

View result in a separate tab

Multiple if Conditions

187.8M/s

Array.includes

76.3M/s

String.match

15.1M/s

View exact numbers

Test name	Executions per second
✓ Multiple if Conditions	187,776,576 Ops/sec
Array.includes	76,279,400 Ops/sec
String.match	15,121,363 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 benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark compares three approaches to check if a string matches multiple possibilities:

1. `Array.includes`
2. `String.match` with regular expressions
3. Multiple `if` conditions using equality checks (`==`)

**Options Compared**

* **Array.includes**: This method uses the `includes()` function to search for an element in an array. It returns `true` if the element is found and `false` otherwise.
* **String.match** with regular expressions: This method uses a regular expression pattern to match the input string against multiple possibilities. The `/^(foo|bar)/` pattern matches any string that starts with either "foo" or "bar".
* **Multiple if Conditions**: This approach uses equality checks (`==`) to compare the input string with multiple possibilities.

**Pros and Cons**

* **Array.includes**:
	+ Pros: Simple, efficient, and widely supported.
	+ Cons: May not be as flexible as regular expressions or may use more memory for large arrays.
* **String.match** with regular expressions:
	+ Pros: Flexible, powerful, and can handle complex matching patterns. However, it can be slower than `Array.includes` due to the overhead of compiling the regex pattern.
	+ Cons: May be less intuitive for simple string matching tasks, requires knowledge of regex syntax.
* **Multiple if Conditions**:
	+ Pros: Easy to understand and implement, can be faster since it avoids regex compilation.
	+ Cons: Inefficient, may lead to performance issues with large numbers of conditions.

**Library and Special JS Features**

* No external libraries are used in this benchmark.
* The `includes()` method is a built-in JavaScript function.
* Regular expressions (regex) are not explicitly mentioned as a special feature, but they are used in the `String.match` approach. If you're not familiar with regex, it's worth learning about them for more complex matching tasks.

**Other Alternatives**

If you need to perform string matching with regular expressions, consider using other libraries like `regex-escape` or `regex-test`. For simple string matching, you could also use a dedicated library like `string-match`.

**Benchmark Considerations**

When choosing an approach, consider the following factors:

* Performance: If speed is critical, `Array.includes` might be the best choice. However, if flexibility and accuracy are more important, `String.match` with regular expressions could be the better option.
* Readability and maintainability: For simple string matching tasks, multiple `if` conditions might be easier to understand than regular expressions or built-in functions like `includes()`.
* Complexity: If you need to match complex patterns or edge cases, `String.match` with regular expressions is a good choice.

Array.includes vs String.match (version: 0)

Matching a string against more than one possibility.

Comparing performance of: `Array.includes vs String.match vs Multiple if Conditions`

Created: 9 years ago by: Guest

Go to the latest result

Array.includes

String.match

Multiple if Conditions

Historical Performance Data aggregated from 19 community runs

Desktop Results:

Chrome 19 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Array.includes vs String.match (version: 0)

Matching a string against more than one possibility.

Comparing performance of: Array.includes vs String.match vs Multiple if Conditions

Created: 9 years ago by: Guest

Go to the latest result

Array.includes

String.match

Multiple if Conditions

Historical Performance Data aggregated from 19 community runs

Desktop Results:

Chrome 19 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: `Array.includes vs String.match vs Multiple if Conditions`