Benchmark: Get last part from URL (Regex vs Split vs Substring)

Script Preparation code:

var str = 'https://www.testsite.com/some-path/another-path/2019/my-amazing-page-name.html';

Tests:

Regex 1
str.replace(/^(.*[\\\/])/, '');
Regex 2
str.replace(/([^\/]+)(?=[^\/]*\/?$)/, '');
Split
str.split('/').pop();
Substring
str.substring(str.lastIndexOf('/')+1);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Regex 1
Regex 2
Split
Substring

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 10 hours ago)

User agent: Mozilla/5.0 (iPad; CPU OS 17_7_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) EdgiOS/131.0.2903.92 Version/17.0 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 17 on iOS 17.7.2

View result in a separate tab

Test name	Executions per second
Regex 1	265502112.0 Ops/sec
Regex 2	299503008.0 Ops/sec
Split	3602437.2 Ops/sec
Substring	19658652.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark tests the performance of three different approaches to extract the last part from a URL: using regular expressions (`Regex 1` and `Regex 2`), splitting by `/` (`Split`), and using the `substring()` method with `lastIndexOf()`. The benchmark aims to determine which approach is the fastest on the specified hardware configuration.

**Benchmark Definitions**

The three test cases are:

*   `Regex 1`: Uses a regular expression to remove everything before the first `/`, leaving only the last part of the URL. The pattern used is `^(.*[\\\\\\/])`, which matches any characters (`.`) followed by either a backslash or a forward slash (`\\` or `/`). The parentheses create a capture group, allowing us to extract the matched text.
*   `Regex 2`: Similar to `Regex 1`, but with an additional positive lookahead assertion (`(?=[^\\/]*\\/?$)`) to ensure that the extracted string does not contain any more forward slashes. This is done by checking if there are no more non-slash characters before or after the last forward slash.
*   `Split`: Splits the URL into substrings using `/` as the separator and returns the last part of the array using `pop()`.
*   `Substring`: Uses `lastIndexOf()` to find the position of the last occurrence of `/` in the URL and then extracts a substring starting from that index, effectively getting the last part.

**Approach Comparison**

1.  **Regular Expressions (Regex)**:
    *   Pros: Flexibility and precision in pattern matching.
    *   Cons: Can be slow due to the overhead of compiling regular expressions and executing complex patterns. In this case, `Regex 2` has a slight performance advantage over `Regex 1` likely because of the additional lookahead assertion which makes it less ambiguous for the engine.

**Library Used**: JavaScript's built-in `String.prototype.replace()` method uses regular expressions under the hood.
2.  **Split**:
    *   Pros: Simple and straightforward approach that is easy to understand.
    *   Cons: May not be suitable for complex URLs or cases where only a portion of the URL needs to be extracted.

3.  **Substring**:
    *   Pros: Efficient for simple substring extraction and may be faster than `Regex` due to fewer overheads.
    *   Cons: Requires an additional operation (`lastIndexOf()`) to find the last occurrence of `/`, which can add to overall execution time.

**Special Features**

None mentioned in this explanation.

Related benchmarks:

Get last part from URL (Regex vs Split vs Substring) (version: 1)

Comparing performance of: Regex 1 vs Regex 2 vs Split vs Substring

Created: 5 years ago by: Registered User

Jump to the latest result

Regex 1

Regex 2

Split

Substring

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