Benchmark: startsWith vs ===

Script Preparation code:

function get_data (){
const a = [ ], b = [ ] 
for(let i=0; i<1000; ++i)
  {
    const v = Math.random().toPrecision(50)
    a.push(v)
    b.push(v)
  }
  return [a, b]
}

Tests:

a[i].startsWith(b[i]) when a[i] strictly equals b[i]
{ const [a, b] = get_data() const pre = Date.now() let test = true for(let j=0; j<1000; ++j) for(let i=0; i<1000; ++i) test &= a[i].startsWith(b[i]) const post = Date.now() console.log(test === true, post - pre) }
a[i].startsWith(b[j]) when a[i] different than b[j]
{ const [a, b] = get_data() const pre = Date.now() let test = true for(let j=1; j<1000; ++j) for(let i=0; i<1000; ++i) test |= a[i].startsWith(b[j]) const post = Date.now() console.log(test === false, post - pre) }
a[i] === b[i] when a[i] strictly equals b[i]
{ const [a, b] = get_data() const pre = Date.now() let test = true for(let j=0; j<1000; ++j) for(let i=0; i<1000; ++i) test &= a[i] === b[i] const post = Date.now() console.log(test === true, post - pre) }
a[i] === b[j] when a[i] different than b[j]
{ const [a, b] = get_data() const pre = Date.now() let test = true for(let j=1; j<1000; ++j) for(let i=0; i<1000; ++i) test |= a[i] === b[j] const post = Date.now() console.log(test === false, post - pre) }

Historical Performance Data aggregated from 8 community runs

Desktop Results:

Chrome 8 runs

a[i] === b[i] when a[i] strictly equals b[i]

394/s

a[i] === b[j] when a[i] different than b[j]

216/s

a[i].startsWith(b[j]) when a[i] different than b[j]

131/s

a[i].startsWith(b[i]) when a[i] strictly equals b[i]

12/s

Fastest: a[i] === b[i] when a[i] strictly equals b[i] (33.8x faster)

View exact numbers

✓ a[i] === b[i] when a[i] strictly equals b[i]: 394 ops/sec
• a[i] === b[j] when a[i] different than b[j]: 216 ops/sec
• a[i].startsWith(b[j]) when a[i] different than b[j]: 131 ops/sec
• a[i].startsWith(b[i]) when a[i] strictly equals b[i]: 12 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
a[i].startsWith(b[i]) when a[i] strictly equals b[i]
a[i].startsWith(b[j]) when a[i] different than b[j]
a[i] === b[i] when a[i] strictly equals b[i]
a[i] === b[j] when a[i] different than b[j]

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36

Browser/OS: Chrome 147 on Windows

View result in a separate tab

a[i] === b[i] when a[i] strictly equals b[i]

386/s

a[i] === b[j] when a[i] different than b[j]

215/s

a[i].startsWith(b[j]) when a[i] different than b[j]

123/s

a[i].startsWith(b[i]) when a[i] strictly equals b[i]

10/s

View exact numbers

Test name	Executions per second
✓ a[i] === b[i] when a[i] strictly equals b[i]	386 Ops/sec
a[i] === b[j] when a[i] different than b[j]	215 Ops/sec
a[i].startsWith(b[j]) when a[i] different than b[j]	123 Ops/sec
a[i].startsWith(b[i]) when a[i] strictly equals b[i]	10 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Overview**

The provided benchmark compares the performance of three different approaches to check if two strings are equal or start with each other. The test cases use arrays of random strings generated by the `get_data` function, which is defined in the script preparation code.

**Test Cases**

There are four test cases:

1. **a[i] === b[i]**: This test case checks if two strings at the same index in two arrays are equal. It uses both the strict equality operator (`===`) and the loose equality operator (`==`).
2. **a[i].startsWith(b[j])** when `a[i] different than b[j]`: This test case checks if a string from one array starts with a string from another array, even if they are not equal at that index.
3. **a[i].startsWith(b[i])** when `a[i] strictly equals b[i]`: This test case is similar to the first one but uses the `startsWith` method instead of the equality operator.
4. **a[i] === b[j]** when `a[i] different than b[j]`: This test case checks if a string from one array is equal to a string from another array, even if they are not at the same index.

**Options Compared**

The benchmark compares three options:

1. **Strict Equality Operator (`===`)**: Uses the strict equality operator to check if two strings are exactly equal.
2. **Loose Equality Operator (`==`)**: Uses the loose equality operator to check if two strings are "equal" (i.e., one is a string representation of the other).
3. **String StartsWith Method**: Uses the `startsWith` method to check if a string starts with another string.

**Pros and Cons**

* **Strict Equality Operator (`===`)**:
	+ Pros: precise, predictable behavior.
	+ Cons: can be slower than other options, may not work as expected for non-ASCII characters.
* **Loose Equality Operator (`==`)**:
	+ Pros: fast, works with most types of data (including strings).
	+ Cons: can lead to unexpected results due to type coercion, may not work as expected for non-ASCII characters.
* **String StartsWith Method**:
	+ Pros: fast, works well with strings, and is more readable than using `===` or `==`.
	+ Cons: may be slower than `===` or `==`, can lead to unexpected results if the string is not a match.

**Library**

There is no explicit library mentioned in the benchmark code. However, the use of the `startsWith` method suggests that it might be using the built-in JavaScript method with the same name.

**Special JS Feature/Syntax**

The use of template literals (`\r\nconst v = Math.random().toPrecision(50)` and `\r\nfunction get_data (){\r\n...}`) is a modern JavaScript feature, but it's not specific to this benchmark.

**Alternatives**

Other alternatives for string comparison in JavaScript include:

* Using the `localeCompare` method for locale-sensitive comparisons.
* Using a library like Lodash or Underscore.js for more complex string manipulation and comparison tasks.
* Using a custom implementation using bitwise operations or regular expressions.

startsWith vs === (version: 0)

Comparing performance of: `a[i].startsWith(b[i]) when a[i] strictly equals b[i] vs a[i].startsWith(b[j]) when a[i] different than b[j] vs a[i] === b[i] when a[i] strictly equals b[i] vs a[i] === b[j] when a[i] different than b[j]`

Created: 4 years ago by: Guest

Go to the latest result

a[i].startsWith(b[i]) when a[i] strictly equals b[i]

a[i].startsWith(b[j]) when a[i] different than b[j]

a[i] === b[i] when a[i] strictly equals b[i]

a[i] === b[j] when a[i] different than b[j]

Historical Performance Data aggregated from 8 community runs

Desktop Results:

Chrome 8 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

startsWith vs === (version: 0)

Comparing performance of: a[i].startsWith(b[i]) when a[i] strictly equals b[i] vs a[i].startsWith(b[j]) when a[i] different than b[j] vs a[i] === b[i] when a[i] strictly equals b[i] vs a[i] === b[j] when a[i] different than b[j]

Created: 4 years ago by: Guest

Go to the latest result

a[i].startsWith(b[i]) when a[i] strictly equals b[i]

a[i].startsWith(b[j]) when a[i] different than b[j]

a[i] === b[i] when a[i] strictly equals b[i]

a[i] === b[j] when a[i] different than b[j]

Historical Performance Data aggregated from 8 community runs

Desktop Results:

Chrome 8 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `a[i].startsWith(b[i]) when a[i] strictly equals b[i] vs a[i].startsWith(b[j]) when a[i] different than b[j] vs a[i] === b[i] when a[i] strictly equals b[i] vs a[i] === b[j] when a[i] different than b[j]`