Benchmark: JavaScript Checking That A String Starts With A Value - A Value Is Found - Benchmarks - Playground

HTML Preparation code:

<div></div>

Script Preparation code:

const iterationNum = 250000;
const possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz";
const possibleLen = possible.length;

function getRandomIntInclusive(max, min = 1) {
  const minCeiled = Math.ceil(min);
  const maxFloored = Math.floor(max);
  return Math.floor(Math.random() * (maxFloored - minCeiled + 1) + minCeiled); // The maximum is inclusive and the minimum is inclusive
}

function makeRandomString(len, defaultWord = '') {
  let text = defaultWord;
  for(let i = 0; i < len; i++) {
    text += possible.charAt(getRandomIntInclusive(possibleLen, 0));
  }
  return text + defaultWord;
}

const testWord = window.testWord = makeRandomString(getRandomIntInclusive(10));
const allStrings = window.allStrings = new Array(iterationNum);
const numberOfStrings = window.numberOfStrings = iterationNum;

for(let i = 0; i < numberOfStrings; i++) {
    allStrings[i] = makeRandomString(getRandomIntInclusive(20), testWord);
}

Tests:

Value Found - string.startsWith method
let x = 0; const numberOfStrings = window.numberOfStrings; const allStrings = window.allStrings; const testWord = window.testWord; while (x < numberOfStrings) { const str = allStrings[x]; str.startsWith(testWord); x += 1; }
Value Found - string.indexOf method
let x = 0; const numberOfStrings = window.numberOfStrings; const allStrings = window.allStrings; const testWord = window.testWord; const testWordLen = testWord.length; while (x < numberOfStrings) { const str = allStrings[x]; str.indexOf(testWord) === 0; x += 1; }
Value Found - string.search method
let x = 0; const numberOfStrings = window.numberOfStrings; const allStrings = window.allStrings; const testWord = window.testWord; const testWordLen = testWord.length; while (x < numberOfStrings) { const str = allStrings[x]; str.search(testWord) === 0; x += 1; }
Value Found - string.match method
let x = 0; const numberOfStrings = window.numberOfStrings; const allStrings = window.allStrings; const testWord = window.testWord; const testWordRegExp = new RegExp(`^${testWord}`); while (x < numberOfStrings) { const str = allStrings[x]; str.match(testWordRegExp); x += 1; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Value Found - string.startsWith method
Value Found - string.indexOf method
Value Found - string.search method
Value Found - string.match method

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36

Browser/OS: Chrome 122 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Value Found - string.startsWith method	174.4 Ops/sec
Value Found - string.indexOf method	4108.8 Ops/sec
Value Found - string.search method	44.1 Ops/sec
Value Found - string.match method	138.6 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark and explain what's being tested, compared options, pros and cons, and other considerations.

**Benchmark Overview**

The benchmark is designed to measure the performance of four different methods for checking if a string starts with a specified value:

1. `string.startsWith()`
2. `string.indexOf()`
3. `string.search()`
4. Using a regular expression (`RegExp`) to match the start of a string

**Test Cases**

Each test case has a similar structure, which consists of:

* A loop that iterates over an array of strings (`allStrings`)
* For each iteration, a random string is generated and stored in `str`
* The corresponding method (e.g., `startsWith()`, `indexOf()`) is called on the `str` variable with the test word as an argument
* The result of the method call is checked to see if it returns true

**Methods Compared**

The four methods are compared in terms of their performance, measured by the number of executions per second (ExecutionsPerSecond) for each browser and device.

1. **string.startsWith()**: This method checks if the string starts with the specified value.
2. **string.indexOf()**: This method searches for the first occurrence of the specified value in the string and returns its index. If not found, it returns -1.
3. **string.search()**: Similar to `indexOf()`, but throws an exception if not found.
4. **RegExp match**: This method uses a regular expression to match the start of the string with the test word.

**Pros and Cons**

* **string.startsWith()**: Pros:
	+ Fastest among the four methods
	+ Most efficient for short strings
Cons:
	+ May not work as expected if the test word is empty or null
	+ Requires a null check before calling `startsWith()`
* **string.indexOf()**: Pros:
	+ Works well even if the test word is empty or null
Cons:
	+ Slower than `startsWith()` for short strings
	+ Returns an index, which may not be what the user expects
* **string.search()**: Similar to `indexOf()`, but throws an exception if not found. This can lead to errors if the code doesn't handle exceptions properly.
* **RegExp match**: Pros:
	+ Works well even if the test word is empty or null
Cons:
	+ Slower than `startsWith()` and `indexOf()`
	+ May cause performance issues for very long strings

**Other Considerations**

* The benchmark uses a random string generator to create the test data, which helps to simulate real-world usage.
* The number of iterations (250000) is relatively high, which provides a good estimate of performance under heavy load.
* The benchmark runs on different browsers and devices, which gives a better understanding of how the methods perform in different environments.

**Alternatives**

Other alternatives for checking if a string starts with a specified value include:

* Using `string.includes()` or `string.startsWith()` with a null check
* Implementing a custom function to check for the start of a string
* Using a different data structure, such as an array or a trie, to store and search strings.

In conclusion, this benchmark provides a good overview of the performance differences between four common methods for checking if a string starts with a specified value. The results can help developers choose the most efficient method for their specific use case.

Related benchmarks:

JavaScript Checking That A String Starts With A Value - A Value Is Found - Benchmarks - Playground (version: 0)

Comparing performance of: Value Found - string.startsWith method vs Value Found - string.indexOf method vs Value Found - string.search method vs Value Found - string.match method

Created: 2 years ago by: Registered User

Jump to the latest result

Value Found - string.startsWith method

Value Found - string.indexOf method

Value Found - string.search method

Value Found - string.match method

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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