Benchmark: String.includes vs String.match 3

Tests:

String.includes
const testStrFirst = 'foo'; 'foobar'.includes(testStrFirst); const testStrSecond = 'bar'; 'foobar'.includes(testStrSecond); const testStrNotMatch = 'baz'; 'foobar'.includes(testStrNotMatch);
String.match needle
const testStrFirst = 'foobar'; testStrFirst.match('foo'); const testStrSecond = 'foobar'; testStrSecond.match('bar'); const testStrNotMatch = 'foobar'; testStrNotMatch.match('baz');
String.match regexp
const testStrFirst = 'foo'; testStrFirst.match(/^(foo|bar)$/); const testStrSecond = 'bar'; testStrSecond.match(/^(foo|bar)$/); const testStrNotMatch = 'baz'; testStrNotMatch.match(/^(foo|bar)$/);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
String.includes
String.match needle
String.match regexp

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided JSON represents a benchmark test case that compares the performance of three different approaches for matching a string against more than one possibility: `String.includes`, `String.match` with a needle, and `String.match` with a regular expression.

**Test Cases**

The benchmark consists of three individual test cases:

1. **String.includes**: This test case checks how fast `includes()` is compared to itself for different strings.
2. **String.match needle**: This test case compares the performance of `match()` when passed a single string (needle) against another string.
3. **String.match regexp**: This test case measures the performance of `match()` when passed a regular expression against a string.

**Options Compared**

The benchmark compares three different options:

* **`String.includes`**: A simple method to check if a substring is present in a string.
* **`String.match(needle)`**: A method that searches for a specific pattern (needle) in a string and returns an array of matches or null if no match is found.
* **`String.match(regexp)`**: A method that uses regular expressions to search for patterns in a string.

**Pros and Cons**

Here's a brief overview of the pros and cons of each approach:

* **`String.includes`**:
	+ Pros: Simple, fast, and widely supported.
	+ Cons: May not be as efficient as other methods for large strings or complex searches.
* **`String.match(needle)`**:
	+ Pros: Can match multiple substrings with a single call, more flexible than `includes()`.
	+ Cons: May be slower than `includes()` and has limitations on the type of patterns that can be used (e.g., no regex support).
* **`String.match(regexp)`**:
	+ Pros: Powerful for complex searches using regular expressions.
	+ Cons: Can be slower than `includes()` or `match(needle)`, and may have performance issues with very long strings.

**Library and Purpose**

In the provided benchmark, no libraries are explicitly mentioned. However, it's worth noting that both `String.match()` and `String.includes()` methods rely on internal JavaScript engine optimizations, which can vary between browsers and versions.

**Special JS Features or Syntax**

None of the test cases explicitly use special JavaScript features or syntax (e.g., ES6 classes, async/await, etc.). The tests focus on the performance comparison of three basic string matching approaches.

**Alternatives**

If you're looking for alternatives to MeasureThat.net, some popular options include:

* jsperf: A classic benchmarking website for JavaScript that allows users to create and run microbenchmarks.
* Benchmark.js: A lightweight, modern benchmarking library for Node.js and web browsers.
* Speedometer: A benchmarking framework developed by Microsoft for testing browser performance.

These alternatives offer various features, such as support for asynchronous tests, caching, and more advanced analysis tools.

Latest run results:

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

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

Browser/OS: Chrome 103 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
String.includes	829334528.0 Ops/sec
String.match needle	1496076.9 Ops/sec
String.match regexp	7238416.5 Ops/sec

Related benchmarks:

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

Matching a string against more than one possibility.

Comparing performance of: String.includes vs String.match needle vs String.match regexp

Created: 2 years ago by: Guest

Jump to the latest result

String.includes

String.match needle

String.match regexp

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