Benchmark: .charAt vs .indexOf vs Str[idx] vs startWith

HTML Preparation code:

<div></div>

Script Preparation code:

window.regex = /^test/;
window.match = '9';
var data = window.data = [];
const possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
var TOTAL_STRINGS = window.TOTAL_STRINGS = 100000;

function getRandomInt(max) {
  return Math.floor(Math.random() * max);
}

function makeRandomString(len) {
  var text = "";
  for( var i=0; i < len; i++ ) {
    text += possible.charAt(getRandomInt(possible.length));
  }
  return text;
}

while (data.length < TOTAL_STRINGS) {
  data.push(makeRandomString(getRandomInt(20)));
}

Tests:

.charAt
var x = 0; var TOTAL_STRINGS = window.TOTAL_STRINGS; var data = window.data; var match = window.match; while (x < TOTAL_STRINGS) { const str = data[x]; str.charAt(0) === match; x += 1; }
.indexOf
var x = 0; var TOTAL_STRINGS = window.TOTAL_STRINGS; var data = window.data; var match = window.match; while (x < TOTAL_STRINGS) { const str = data[x]; str.indexOf(match) === 0; x += 1; }
Str[index]
var x = 0; var TOTAL_STRINGS = window.TOTAL_STRINGS; var data = window.data; var match = window.match; while (x < TOTAL_STRINGS) { const str = data[x]; str[0] === match; x += 1; }
.startWith
var x = 0; var TOTAL_STRINGS = window.TOTAL_STRINGS; var data = window.data; var match = window.match; while (x < TOTAL_STRINGS) { const str = data[x]; str.startsWith(match) === 0; x += 1; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
.charAt
.indexOf
Str[index]
.startWith

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/133.0.0.0 Safari/537.36 Edg/133.0.0.0

Browser/OS: Chrome 133 on Windows

View result in a separate tab

Test name	Executions per second
.charAt	949.3 Ops/sec
.indexOf	10918.5 Ops/sec
Str[index]	1789.4 Ops/sec
.startWith	535.3 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of different JavaScript methods for substring operations is a crucial task, and MeasuredThat.net provides a valuable platform for doing so.

The benchmark tests four different methods:

1. `.charAt()`: This method returns the character at a specific index in a string.
2. `.indexOf()`: This method searches for the first occurrence of a specified value in a string and returns its index.
3. `Str[index]` (or indexing syntax): This is equivalent to `.charAt()` but uses the array indexing syntax instead.
4. `.startsWith()`: This method checks if a string starts with a specified value.

**Options Comparison**

Let's break down each option:

* `.charAt()` and `Str[index]` both access a single character in a string using its index, but they differ in how they are implemented:
	+ `.charAt()` is a standard JavaScript method that returns the character at the specified index.
	+ `Str[index]` uses array indexing syntax to access the character, which can be more concise and efficient in some cases (e.g., when working with large arrays or strings).
* `.indexOf()`: This method searches for the first occurrence of a value in a string and returns its index. It's generally slower than accessing a single character using either `.charAt()` or `Str[index]`.
* `.startsWith()`: This method checks if a string starts with a specified value, which can be more efficient than searching for the entire value using `.indexOf()`.

**Pros and Cons**

Here are some pros and cons of each approach:

* `.charAt()` and `Str[index]`:
	+ Pros: Simple, straightforward, and well-supported by most browsers.
	+ Cons: May be slower than indexing syntax or other methods in some cases.
* `.indexOf()`: Pros: Can handle more complex searches, but may be slower than direct access to a single character.
	+ Cons: May not be as efficient as other methods for simple substring operations.
* `.startsWith()`: Pros: Efficient and concise way to check if a string starts with a value.
	+ Cons: May not be suitable for all cases (e.g., when searching for multiple values).

**Special Considerations**

In this benchmark, the `Str[index]` syntax is used instead of `.charAt()` likely because it's more concise and efficient in some cases. This is an example of using a non-standard JavaScript feature to achieve better performance.

**Alternative Approaches**

If you're looking for alternative methods to measure substring operations, here are a few options:

* Using regular expressions: You can use the `test()` method with a regular expression to search for a pattern in a string.
* Using array indexing and slicing: If you have an array of strings, you can use array indexing and slicing to access specific characters or substrings.
* Measuring string concatenation performance: You can create a benchmark that tests the performance of different string concatenation methods.

Keep in mind that these alternatives may not be as straightforward to implement as the standard JavaScript methods, but they can provide valuable insights into the performance characteristics of your code.

Related benchmarks:

.charAt vs .indexOf vs Str[idx] vs startWith (version: 4)

Testing some things

Comparing performance of: .charAt vs .indexOf vs Str[index] vs .startWith

Created: 6 years ago by: Registered User

Jump to the latest result

.charAt

.indexOf

Str[index]

.startWith

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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