Benchmark: Regex vs split/join - actual replace

Regex vs split/join - actual replace (version: 0)

Now regex flies and split crawls. BTW that regex match split plus join is what jQuery's removeClass() does - just much worse. Had to double check just in case that there's some hidden trick involved.

Comparing performance of: Regex vs Regex match as Split - jQuery style :-) vs Split and Join

Created: 6 years ago by: Guest

Jump to the latest result

Script Preparation code:

var sep = "[\x20\t\r\n\f]";
var not_sep = "[^\x20\t\r\n\f]";

var str = 'Abcd efghij klmnopqrstuv wxy Abcd efghij klmnopqrstuv wxy Abcd efghij klmnopqrstuv wxyAbcd efghij klmnopqrstuv wxy Abcd efghij klmnopqrstuv wxy Abcd efghij klmnopqrstuv wxy';

Tests:

Regex
var name = "skin-oasis|background-dynamic"; let re = new RegExp(name + "(?:" + sep + "+|$)"); var res = str.replace(re, "");
Regex match as Split - jQuery style :-)
let re = new RegExp(not_sep + "+", 'g'); let arr = str.match(re); for (i = 0; i < arr.length; ++i) { if ( arr[i] == "skin-oasis" ) arr[i] = null; } arr.join(" ");
Split and Join
let re = new RegExp(name + "(?:" + sep + "|$)"); let arr = str.split(re); for (i = 0; i < arr.length; ++i) { if ( arr[i] == "skin-oasis" ) arr[i] = null; } arr.join(" ");

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Regex
Regex match as Split - jQuery style :-)
Split and Join

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 break down the benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark compares three approaches to perform an actual replace operation on a given string:

1. Using regular expressions (Regex)
2. Using `String.prototype.match()` followed by filtering and joining
3. Using `String.prototype.split()` followed by joining

**Options Compared**

Each test case uses one of the following approaches:

* Regex: `new RegExp()`, `str.replace()`
* Match as Split: `String.prototype.match()`, `arr.join()` after filtering
* Split and Join: `String.prototype.split()`, `arr.join()`

**Pros and Cons**

Here's a brief summary of each approach:

1. **Regex**: Fast, but requires manual memory management (e.g., `str.replace()`). Can be complex to write and maintain.
2. **Match as Split**: More efficient than Regex for this specific use case, but still requires two separate operations. Can be slower if the string is very large.
3. **Split and Join**: Simple and easy to understand, but may be slower due to the overhead of creating an array from the split result.

**Library/Features**

There are no external libraries used in this benchmark. However, it's worth noting that `String.prototype.match()` uses a regular expression engine under the hood.

**Special JS Feature/Syntax**

No special JavaScript features or syntax are used beyond what's standard in modern browsers.

Related benchmarks: