Benchmark: My Check - RegEx.test vs. String.includes vs. String.match vs String.IndexOf

Script Preparation code:

var string = "lexi.fletcher23@gmail.com|Gymeast1!";
var regex = /@yahoo\.|@gmail\.|@hotmail\.|@live\.|@outlook\./i;

Tests:

RegEx.test
if(regex.test(string)) return true; else return false;
String.includes
string = string.toLowerCase(); if(string.includes("@yahoo.") || string.includes("@gmail.") || string.includes("@hotmail.") ||string.includes("@live.")||string.includes("@outlook.")) return true; else return false;
String.match
if(string.match(regex)) return true; else return false;
String.indexOf
string = string.toLowerCase(); if(string.indexOf("@yahoo.") || string.indexOf("@gmail.") || string.indexOf("@hotmail.") ||string.indexOf("@live.")||string.indexOf("@outlook.")) return true; else return false;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
RegEx.test
String.includes
String.match
String.indexOf

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 116 on Windows

View result in a separate tab

Test name	Executions per second
RegEx.test	13059101.0 Ops/sec
String.includes	5795897.5 Ops/sec
String.match	11588516.0 Ops/sec
String.indexOf	7687720.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in this benchmark.

**Benchmark Overview**

The benchmark compares the performance of four different approaches to test if a given string contains specific email providers:

1. `RegEx.test`
2. `String.includes`
3. `String.match`
4. `String.indexOf`

Each approach is implemented in JavaScript, and the benchmark aims to determine which one is the fastest.

**Options Compared**

Here's what each option does:

* **`RegEx.test()`**: This method returns `true` if the string matches a given regular expression, and `false` otherwise.
* **`String.includes()`**: This method checks if a specified value (in this case, an email provider) is present in the string. It returns `true` if found and `false` otherwise.
* **`String.match()`**: Similar to `RegEx.test()`, but returns an array of matches or `null` if no match is found.
* **`String.indexOf()`**: This method searches for a specified value (in this case, an email provider) in the string and returns its index. If not found, it returns `-1`.

**Pros and Cons**

Here's a brief analysis of each approach:

* **`RegEx.test()`**:
	+ Pros: Can be more precise than the other methods, as it checks for a full match.
	+ Cons: May be slower due to the overhead of regular expression compilation and execution.
* **`String.includes()`**:
	+ Pros: Simple and efficient, as it only needs to search for a value in the string.
	+ Cons: May not be precise if the specified value is part of a larger substring (e.g., "example@gmail.com" would match "example").
* **`String.match()`**:
	+ Pros: Can return multiple matches or `null` if no match is found, making it more flexible than `RegEx.test()`.
	+ Cons: May be slower due to the overhead of compiling and executing a regular expression.
* **`String.indexOf()`**:
	+ Pros: Simple and efficient, as it only needs to search for a value in the string.
	+ Cons: Returns an index, which may not be immediately useful if you're looking for a specific email provider.

**Library Usage**

None of the tested methods rely on any external libraries. They are all built-in JavaScript functions.

**Special JS Features or Syntax**

There are no special JavaScript features or syntax used in this benchmark beyond the standard functions and operators.

**Other Considerations**

When choosing an approach, consider the trade-offs between precision, efficiency, and flexibility. If you need to check for a specific email provider and don't care about performance, `String.includes()` might be a good choice. However, if you need more precision or want to return multiple matches, one of the other options might be better.

As an alternative to this benchmark, you could consider using other methods, such as:

* Using a dedicated library like RegEx.js for regular expression matching
* Implementing a custom string search algorithm
* Using a different programming language or framework that provides built-in support for email address validation

Keep in mind that the choice of approach ultimately depends on your specific use case and performance requirements.

Related benchmarks:

My Check - RegEx.test vs. String.includes vs. String.match vs String.IndexOf (version: 1)

Comparing performance of: RegEx.test vs String.includes vs String.match vs String.indexOf

Created: one year ago by: Registered User

Jump to the latest result

RegEx.test

String.includes

String.match

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