Benchmark: compare string replace all RegExp and split + join and replace

Script Preparation code:

var str = "Test abc test test abc test test test abc test test abc"

Tests:

Regular Expression Literal:
str = str.replace(/abc/g, "replaced text");
split and join
str = str.split("abc").join("replaced text");
Regular Expression:
str = str.replace(new RegExp("abc", "g"), "replaced text");
while replace includes
while(str.includes("abc")){ str = str.replace("abc", "replaced text"); }
while replace indexOf
while(str.indexOf("abc") !== -1){ str = str.replace("abc", "replaced text"); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Regular Expression Literal:
split and join
Regular Expression:
while replace includes
while replace indexOf

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/114.0.0.0 Safari/537.36

Browser/OS: Chrome 114 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Regular Expression Literal:	8927917.0 Ops/sec
split and join	6070086.0 Ops/sec
Regular Expression:	4984785.5 Ops/sec
while replace includes	17430994.0 Ops/sec
while replace indexOf	17279666.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmark that compares the performance of different approaches to replace all occurrences of a substring in a string: using regular expressions with literals, using split and join, and using while loops with includes or indexOf methods.

**Comparison Approaches**

There are four test cases:

1. **Regular Expression Literal**: Uses `str.replace(/abc/g, "replaced text");`
	* This approach uses a literal regular expression to match the substring "abc" globally.
	* Pros: Simple and concise syntax, suitable for simple patterns.
	* Cons: May not be efficient for large strings or complex patterns.
2. **split and join**: Uses `str.split("abc").join("replaced text");`
	* This approach splits the string into an array of substrings using "abc" as a delimiter, then joins them back together with "replaced text".
	* Pros: Can be efficient for large strings or complex patterns, but may have overhead due to creating and manipulating arrays.
	* Cons: May not be suitable for simple cases where only one replacement is needed.
3. **while replace includes**: Uses `while (str.includes("abc")) { str = str.replace("abc", "replaced text"); }`
	* This approach uses a while loop to repeatedly check if the string includes "abc" and replace it until no more matches are found.
	* Pros: Simple and efficient, suitable for simple cases where only one replacement is needed.
	* Cons: May not be suitable for large strings or complex patterns, as it can lead to an infinite loop if the string contains "abc" repeatedly without a clear termination condition.
4. **while replace indexOf**: Uses `while (str.indexOf("abc") !== -1) { str = str.replace("abc", "replaced text"); }`
	* This approach uses a while loop to repeatedly check if the string includes "abc" using the indexOf method, and replace it until no more matches are found.
	* Pros: Similar to the previous approach, but uses the indexOf method instead of includes. May be more suitable for large strings or complex patterns.
	* Cons: May have similar issues with infinite loops as the includes-based approach.

**Library Usage**

None of the test cases use any external libraries. However, the `RegExp` object is used in the "Regular Expression Literal" and "Regular Expression:" approaches, which is a built-in JavaScript object.

**Special JS Feature or Syntax**

The benchmark uses JavaScript's regular expression matching syntax to match the substring "abc". There is no special JavaScript feature or syntax explicitly mentioned, but the use of `g` flag in some test cases suggests using the global matching mode, which can improve performance for certain types of patterns.

Related benchmarks:

compare string replace all RegExp and split + join and replace (version: 2)

Comparing performance of: Regular Expression Literal: vs split and join vs Regular Expression: vs while replace includes vs while replace indexOf

Created: 4 years ago by: Registered User

Jump to the latest result

Regular Expression Literal:

split and join

Regular Expression:

while replace includes

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