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

HTML Preparation code:

<div></div>

AخA
 
<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)));
}

​x
 
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; }
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;
}

 
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;
}

 
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;
}

 
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

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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: 11 months 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 6 months ago):

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

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

Pros and Cons

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

Using a dedicated library like path-normalize or normalize-url.
Implementing a custom normalization function using a loop or recursion.
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.

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: 3 years ago by: Guest

Jump to the latest result

regex replace normalize