Benchmark: StartsWith vs Regex

Script Preparation code:

var str = "http://www.wehkamp.nl/";
var str2 = "wehkamp.nl/baby/pampers";
var str3 = "/baby/pampers";

Tests:

startsWith
var k = str && !str.startsWith('/') && !str.startsWith('http') var k2 = str2 && !str2.startsWith('/') && !str2.startsWith('http') var k3 = str3 && !str3.startsWith('/') && !str3.startsWith('http')
regex
var k = str && !(/^(http|\/)/).test(str) var k2 = str2 && !(/^(http|\/)/).test(str2) var k3 = str3 && !(/^(http|\/)/).test(str3)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
startsWith
regex

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 16_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.2 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 16 on iOS 16.2

View result in a separate tab

Test name	Executions per second
startsWith	1501495.8 Ops/sec
regex	1927831.6 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

The provided benchmark tests two approaches for checking if a string starts with a certain prefix: `startsWith` and regular expression (`regex`). We'll explore what's being tested, pros and cons of each approach, and some additional considerations.

**What is being tested?**

In this benchmark, the following strings are defined:

* `str`: "http://www.wehkamp.nl/"
* `str2`: "wehkamp.nl/baby/pampers"
* `str3`: "/baby/pampers"

The test cases check if each string starts with a specific prefix. For `str`, we're checking for the absence of two prefixes: `/` and `http`. The same checks are performed on `str2` and `str3`.

**Options compared**

There are two options being compared:

1. **`startsWith` method**: This is a built-in JavaScript method that checks if a string starts with a specified prefix.
2. **Regular expression (`regex`) approach**: This uses a regular expression to match the prefixes.

**Pros and cons of each approach:**

### `startsWith` method

Pros:

* Fast and efficient, as it's implemented in native code.
* Easy to use and understand.

Cons:

* May not be available or supported by all browsers (e.g., older versions).
* Can be slow for very large strings due to the overhead of the JavaScript engine.

### Regular expression (`regex`) approach

Pros:

* More flexible and powerful than `startsWith`, as it can match complex patterns.
* Available in most browsers, even older ones.

Cons:

* Can be slower than `startsWith` due to the overhead of compiling and executing regular expressions.
* May not be as easy to read or understand, especially for complex patterns.

**Additional considerations:**

* The use of the `&&` operator with the `!` negation in both approaches ensures that only strings without the prefixes are considered "true".
* The absence of any other prefixes in the input strings makes this benchmark quite simple and focused on comparing these two specific methods.

**Library and special JavaScript feature/syntax**

No libraries or special JavaScript features/syntax are used in this benchmark. It's a straightforward test of two built-in methods.

**Other alternatives:**

If you're interested in exploring other approaches for checking if a string starts with a certain prefix, some alternative methods could be:

* Using the `indexOf()` method and checking for negative results.
* Utilizing the `substring()` method to extract the prefix and check its length.
* Employing a custom implementation using bitwise operations or character indexing.

Keep in mind that these alternatives might not offer significant performance improvements over the built-in `startsWith` and regular expression methods. However, they can provide an interesting exercise for exploring different approaches to this common string manipulation problem.

Related benchmarks:

StartsWith vs Regex (version: 0)

Comparing performance of: startsWith vs regex

Created: 4 years ago by: Guest

Jump to the latest result

startsWith

regex

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