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

HTML Preparation code:

<div></div>

Script Preparation code:

const iterationNum = 250000;
const possible = "ACDEFGHIJKLMNOPQRSTUVWXYZ0123456789acdefghijklmnopqrstuvwxyz"; // The letter B (and b) is removed
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)) + 'Bb'; // B or b shouldn't be in any generated word
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 Not 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 Not 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 Not 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 Not 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 Not Found - string.startsWith method
Value Not Found - string.indexOf method
Value Not Found - string.search method
Value Not 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 Not Found - string.startsWith method	106.3 Ops/sec
Value Not Found - string.indexOf method	3023.9 Ops/sec
Value Not Found - string.search method	43.2 Ops/sec
Value Not Found - string.match method	121.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its various components.

**Benchmark Overview**

The benchmark is designed to measure the performance of different string comparison methods in JavaScript: `startsWith`, `indexOf`, `search`, and `match`. The test creates an array of random strings, where each string starts with a randomly generated word that excludes the letter "B" (both uppercase and lowercase). The goal is to find out which method is the fastest.

**Benchmark Preparation Code**

The preparation code generates:

1. A random integer generator function `getRandomIntInclusive`.
2. A function to create a random string of a specified length using a predefined character set.
3. An array of test words, where each word starts with "B" (excluded).
4. An array of strings, where each string is generated randomly and has a length between 10 and 20 characters.

**Individual Test Cases**

There are four test cases:

1. **Value Not Found - string.startsWith method**
	* This test checks if the `startsWith` method returns `false` for a given string that does not start with the specified word.
2. **Value Not Found - string.indexOf method**
	* This test checks if the `indexOf` method returns `-1` for a given string that does not contain the specified word.
3. **Value Not Found - string.search method**
	* This test checks if the `search` method returns `-1` for a given string that does not contain the specified word.
4. **Value Not Found - string.match method**
	* This test checks if the `match` method returns an empty array for a given string that does not match the specified regular expression.

**Options Compared**

The benchmark compares the performance of four different string comparison methods:

1. `startsWith`
2. `indexOf`
3. `search`
4. `match`

Each method has its own strengths and weaknesses:

* `startsWith`: Fast, but only checks if the string starts with the specified word. If the word is not found, it returns `false`.
* `indexOf`: Slow for large strings, as it scans the entire string to find the index of the specified word. Returns `-1` if not found.
* `search`: Similar to `indexOf`, but can be faster for large strings since it uses a more efficient algorithm. Returns `-1` if not found.
* `match`: Uses regular expressions and can be slow due to the overhead of compiling the regex. Returns an empty array if no match is found.

**Pros and Cons**

* `startsWith`:
	+ Pros: Fast, simple implementation.
	+ Cons: May return false positives if the word is not exact.
* `indexOf`:
	+ Pros: Can be used for finding substrings, not just starting points.
	+ Cons: Slow for large strings.
* `search`:
	+ Pros: Can be faster than `indexOf` for large strings.
	+ Cons: May still be slow due to regex compilation overhead.
* `match`:
	+ Pros: Can be used with regular expressions for complex patterns.
	+ Cons: Slow due to regex compilation and scanning.

**Performance Results**

The benchmark results show that the fastest method is `startsWith`, followed closely by `search`. The `indexOf` method is slower, while `match` is significantly slower due to its overhead.

Related benchmarks:

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

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

Created: 2 years ago by: Registered User

Jump to the latest result

Value Not Found - string.startsWith method

Value Not Found - string.indexOf method

Value Not Found - string.search method

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

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

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

Created: 2 years ago by: Registered User

Jump to the latest result

Value Not Found - string.startsWith method

Value Not Found - string.indexOf method

Value Not Found - string.search method

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

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