Benchmark: String manipulation performance test v2

String manipulation performance test v2 (version: 2)

Comparing performance of: RegExp.test (SINGLE) vs String.includes (SINGLE) vs String.match with regex (SINGLE) vs String.indexOf (MULTIPLE) vs String.search (SINGLE) vs RegExp.exec (MULTIPLE) vs String.match (SINGLE) vs String.matchAll with regex(MULTIPLE) vs String.matchAll (MULTIPLE) vs String.search with regex (SINGLE)

Created: one year ago by: Registered User

Jump to the latest result

Script Preparation code:

var haystack = `A floresta tropical é um dos ecossistemas mais ricos e complexos do planeta. Ela abriga uma grande diversidade de plantas e animais, que se adaptaram às condições de clima quente e úmido. A floresta tropical também é importante para o equilíbrio ambiental, pois produz oxigênio, absorve gás carbônico e regula o ciclo da água. No entanto, a floresta tropical está ameaçada pela ação humana, que provoca o desmatamento, a queimada, a caça ilegal e a exploração de recursos naturais. Essas atividades reduzem a área da floresta, afetam a biodiversidade e contribuem para o aquecimento global. Por isso, é necessário proteger e conservar a floresta tropical, que é um patrimônio da humanidade e da vida na Terra.
Uma das formas de proteger a floresta tropical é através da educação ambiental, que visa conscientizar as pessoas sobre a importância e os benefícios da floresta, bem como os problemas e os riscos que ela enfrenta. A educação ambiental pode ser realizada em diferentes espaços, como escolas, comunidades, mídias e organizações não governamentais. A educação ambiental também pode envolver diferentes estratégias, como palestras, oficinas, exposições, jogos e atividades práticas. O objetivo é estimular o conhecimento, a sensibilização e a participação das pessoas na preservação da floresta tropical.`;
var regexNeedle = /educação/;
var needle = 'educação';

Tests:

RegExp.test (SINGLE)
regexNeedle.test(haystack);
String.includes (SINGLE)
haystack.includes(needle);
String.match with regex (SINGLE)
haystack.match(regexNeedle);
String.indexOf (MULTIPLE)
haystack.indexOf(needle);
String.search (SINGLE)
haystack.search(needle);
RegExp.exec (MULTIPLE)
regexNeedle.exec(haystack);
String.match (SINGLE)
haystack.match(needle);
String.matchAll with regex(MULTIPLE)
haystack.matchAll(/educação/g);
String.matchAll (MULTIPLE)
haystack.matchAll(needle);
String.search with regex (SINGLE)
haystack.search(regexNeedle);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
RegExp.test (SINGLE)
String.includes (SINGLE)
String.match with regex (SINGLE)
String.indexOf (MULTIPLE)
String.search (SINGLE)
RegExp.exec (MULTIPLE)
String.match (SINGLE)
String.matchAll with regex(MULTIPLE)
String.matchAll (MULTIPLE)
String.search with regex (SINGLE)

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/110.0.0.0 Safari/537.36 Edg/110.0.1587.63

Browser/OS: Chrome 110 on Windows

View result in a separate tab

Test name	Executions per second
RegExp.test (BOOLEAN)	3331553.0 Ops/sec
String.includes (BOOLEAN)	8864874.0 Ops/sec
String.match (MULTIPLE)	3266056.5 Ops/sec
String.indexOf (MULTIPLE)	8377502.0 Ops/sec
String.search (MULTIPLE)	3698174.2 Ops/sec
RegExp.exec (MULTIPLE)	3062319.8 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark and its options for you.

**Benchmark Definition**

The provided JSON represents a JavaScript microbenchmark that tests the performance of various string manipulation methods in JavaScript. The benchmark is defined by two parts:

1. **Script Preparation Code**: This code snippet creates a sample string `haystack` containing a long sentence with a specific word (`"educação"`). A regular expression object `regexNeedle` is also created to match this word.
2. **Benchmark Definition**: An array of test cases that define the actual benchmarks to be executed.

**Options Compared**

The benchmark compares the performance of different string manipulation methods:

1. **RegExp.test()**: Tests if a specific word (`needle`) exists in the haystack using a regular expression object (`regexNeedle`).
2. **String.includes()**: Checks if a specific word (`needle`) exists in the haystack.
3. **String.match()**: Extracts the first occurrence of a specific pattern (in this case, `needle`) from the haystack.
4. **String.indexOf()**: Finds the index of the first occurrence of a specific substring (`needle`) in the haystack.
5. **String.search()**: Finds the index of the first occurrence of a specific regular expression object (`regexNeedle`) in the haystack.
6. **RegExp.exec()**: Executes a regular expression object (`regexNeedle`) on the haystack and returns an array containing matches.

**Pros and Cons**

Here's a brief summary of the pros and cons of each method:

1. **RegExp.test()**: Pros: fast, can be used for both exact matches and partial matches. Cons: can be slow for long strings or complex patterns.
2. **String.includes()**: Pros: simple and easy to use, fast for short strings. Cons: may be slower for longer strings or non-exact matches.
3. **String.match()**: Pros: flexible, can extract multiple matches. Cons: can be slow for long strings or complex patterns.
4. **String.indexOf()**: Pros: fast, can be used for both exact and partial matches. Cons: may not work well with non-ASCII characters or Unicode-aware strings.
5. **String.search()**: Pros: similar to `RegExp.test()`, but returns an index instead of a boolean value. Cons: may be slower than `RegExp.test()` for some browsers.
6. **RegExp.exec()**: Pros: flexible, can extract multiple matches. Cons: can be slow for long strings or complex patterns.

**Browser-Specific Variations**

The benchmark results show variations in performance across different browsers:

* Chrome 110:
	+ RegExp.test() is slower than expected due to its complexity.
	+ String.includes() and String.indexOf() are faster than expected, possibly due to caching or optimization.
	+ String.match(), String.search(), and RegExp.exec() have similar performance profiles.

Keep in mind that these results may not generalize to all browsers or use cases. The benchmark is intended to provide a general idea of the relative performance of each method across various JavaScript engines.

Now, take another deep breath!

Related benchmarks:

String manipulation performance test v2 (version: 2)

Created: one year ago by: Registered User

Jump to the latest result

RegExp.test (SINGLE)

String.includes (SINGLE)

String.match with regex (SINGLE)

String.indexOf (MULTIPLE)

String.search (SINGLE)

RegExp.exec (MULTIPLE)

String.match (SINGLE)

String.matchAll with regex(MULTIPLE)

String.matchAll (MULTIPLE)

String.search with regex (SINGLE)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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