Benchmark: 정규식 vs includes

Script Preparation code:

var string = "Hello world!";
var regex = /hello/i;

Tests:

정규식
regex.test(string);
소문자 치환 + 문자열 체크
string.toLowerCase().includes("hello");

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
정규식
소문자 치환 + 문자열 체크

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.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**What is being tested?**

The provided benchmark tests two approaches to check if a string contains a certain substring: regular expressions (regex) and the `includes()` method.

**Options compared**

There are two main options being compared:

1. **Regular Expressions (Regex)**: This approach uses a regex pattern to search for a match in the input string. The pattern is defined using the `/.../i` syntax, where `...` is replaced with the actual substring to be searched for.
2. **String Lowercase + String Check**: This approach converts the input string to lowercase using the `toLowerCase()` method and then checks if the lowercase version of the substring matches the original string using the `includes()` method.

**Pros and Cons of each approach**

1. **Regular Expressions (Regex)**:
	* Pros: regex patterns can be complex and flexible, allowing for advanced matching and validation.
	* Cons: regex can be slow for simple substring searches, and the syntax can be difficult to read and write.
2. **String Lowercase + String Check**:
	* Pros: this approach is often faster than regex, especially for short substrings, as it uses a simple string comparison.
	* Cons: this approach requires converting the entire string to lowercase, which can be unnecessary and may affect performance if done frequently.

**Library used**

None of the test cases use any external libraries. The `includes()` method is a built-in JavaScript method that checks if a value exists within a string or array.

**Special JS feature**

There are no special JavaScript features being tested in this benchmark.

**Other considerations**

1. **Cacheing**: If the input string is reused multiple times, it's likely that the cache of previously computed results could be used to speed up the tests.
2. **Input size**: The test cases do not specify any minimum or maximum input sizes. However, for larger strings, regex might become slower than the `includes()` method.

**Alternatives**

If you were to rewrite this benchmark, you could consider additional approaches, such as:

1. Using a different library like ` RegExp.prototype.test()` instead of regex literals.
2. Implementing a custom search algorithm using bit manipulation or other optimization techniques.
3. Comparing performance with multiple browsers and/or versions.
4. Testing the effects of input size and complexity on both approaches.

Overall, this benchmark provides a simple yet informative comparison between two common string searching methods in JavaScript: regular expressions and the `includes()` method.

Related benchmarks:

정규식 vs includes (version: 0)

test

Comparing performance of: 정규식 vs 소문자 치환 + 문자열 체크

Created: 3 years ago by: Guest

Jump to the latest result

정규식

소문자 치환 + 문자열 체크

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