Benchmark: Normalize path: JS Regex vs .endsWith vs .indexOf vs .slice

HTML Preparation code:

<div></div>

Script Preparation code:

var data = window.data = [];
const possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.";
var TOTAL_STRINGS = window.TOTAL_STRINGS = 100000;

function getRandomInt(max) {
    return Math.floor(Math.random() * max);
}

function makeRandomString(len) {
    var text = "";
    for (var i = 0; i < len; i++) {
        text += possible.charAt(getRandomInt(possible.length));
    }
    return text;
}

function makeRandomUrl(len) {
    var url = "file:///";
    for (var i = 0; i < len; i++) {
        url += makeRandomString(5 + getRandomInt(10));
        if (getRandomInt(2)) {
            url += "/";
        }
    }
    return url;
}

while (data.length < TOTAL_STRINGS) {
    data.push(makeRandomUrl(getRandomInt(10)));
}

Tests:

regex replace normalize
var x = 0; var TOTAL_STRINGS = window.TOTAL_STRINGS; var data = window.data; while (x < TOTAL_STRINGS) { const str = data[x]; const url = str.replace(/\/?$/, ''); x += 1; }
endsWith slice normalize
var x = 0; var TOTAL_STRINGS = window.TOTAL_STRINGS; var data = window.data; while (x < TOTAL_STRINGS) { const str = data[x]; const url = str.endsWith("/") ? str.slice(0, -1) : str; x += 1; }
slice slice normalize
var x = 0; var TOTAL_STRINGS = window.TOTAL_STRINGS; var data = window.data; while (x < TOTAL_STRINGS) { const str = data[x]; const url = str.slice(-1) === "/" ? str.slice(0, -1) : str; x += 1; }
lastIndexOf slice normalize
var x = 0; var TOTAL_STRINGS = window.TOTAL_STRINGS; var data = window.data; while (x < TOTAL_STRINGS) { const str = data[x]; const url = str.lastIndexOf("/") === str.length - 1 ? str.slice(0, -1) : str; x += 1; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
regex replace normalize
endsWith slice normalize
slice slice normalize
lastIndexOf slice normalize

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36

Browser/OS: Chrome 125 on Linux

View result in a separate tab

Test name	Executions per second
regex replace normalize	75.7 Ops/sec
endsWith slice normalize	109.7 Ops/sec
slice slice normalize	96.4 Ops/sec
lastIndexOf slice normalize	65.6 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark compares the performance of three different approaches to normalize path strings: regular expression (`regex`), `endsWith`, and `slice`. The test creates a large dataset of random URLs, which are then processed using each normalization approach.

**Options Compared**

1. **Regular Expression (Regex)**: Uses the `replace()` method with a regular expression to remove the trailing slash from the URL.
2. **endsWith**: Checks if the URL ends with a slash using the `endsWith()` method and replaces it with an empty string if true.
3. **slice**: Uses the `slice()` method to remove the last character of the URL (the trailing slash) if it exists.

**Pros and Cons**

1. **Regular Expression (Regex)**:
	* Pros: Can be flexible and powerful, but may have performance overhead due to regex parsing.
	* Cons: May be slower than other approaches for large datasets or simple normalization tasks.
2. **endsWith**:
	* Pros: Simple and efficient, as it only checks the end of the string.
	* Cons: May not perform well if the URL is very long or contains many consecutive slashes.
3. **slice**:
	* Pros: Fast and memory-efficient, as it only requires a single slice operation.
	* Cons: May be slower than other approaches if the URL needs to be manipulated extensively.

**Library Usage**

None of the options explicitly use any external libraries.

**Special JS Features/Syntax**

The benchmark uses various modern JavaScript features, including:

* Arrow functions (e.g., `x => { ... }`)
* Template literals (`const url = 'file:///';`)
* Spread syntax (`url += makeRandomString(5 + getRandomInt(10))`)

These features are not critical to the understanding of the benchmark's purpose and comparisons.

**Alternatives**

Other alternatives for normalizing path strings could include:

1. Using a dedicated library like `path-normalize` or `normalize-url`.
2. Implementing a custom normalization function using a loop or recursion.
3. Utilizing a streaming approach with a library like `stream`.

However, the benchmark's focus on performance and simplicity makes the three approaches being compared (regex, `endsWith`, and `slice`) particularly relevant for understanding optimization strategies in JavaScript.

Related benchmarks:

Normalize path: JS Regex vs .endsWith vs .indexOf vs .slice (version: 0)

Comparing performance of: regex replace normalize vs endsWith slice normalize vs slice slice normalize vs lastIndexOf slice normalize

Created: 4 years ago by: Guest

Jump to the latest result

regex replace normalize

endsWith slice normalize

slice slice normalize

lastIndexOf slice normalize

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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