Benchmark: string split vs indexOf vs yield

Script Preparation code:

var str = "123 ".repeat(1000000)

Tests:

split
var split = str.split(" ") var count = 0; for (const s of split) count++;
indexOf
var count = 0; var i = 0; while (i >= 0) { count++; i = str.indexOf(" ", i + 1); }
yield
function* splitIter(str, needle) { let i = 0; while (i >= 0) { const iOld = i; i = str.indexOf(" ", i + 1); if (i > 0) yield str.substring(iOld, i) else if (iOld < str.length) yield str.substring(iOld) } } let count = 0 for (const s of splitIter(str, " ")) count++;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
split
indexOf
yield

Fastest: N/A

Slowest: N/A

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 JSON represents three benchmark test cases: `split`, `indexOf`, and `yield`. We'll explore each test case, discussing what's being tested, the pros and cons of different approaches, and other considerations.

**Test Case 1: String Split**

In this test case, we're comparing the performance of three ways to split a string:

```javascript
var str = "123 ".repeat(1000000);
```

The three methods being compared are:

* `str.split(" ")`: This method splits the string into an array using the space character as a delimiter.
* `while (i >= 0) { ... }` loop with `str.indexOf(" ", i + 1)`: This method uses a loop to find the index of the next space character and then extracts the substring from that index to the previous one.
* `yield` function with `splitIter(str, " ")`: This method uses a generator function to iterate over the split string and extract each substring.

**Pros and Cons:**

* `str.split(" ")`: Pros - concise and efficient. Cons - may not be suitable for very large strings due to memory constraints.
* `while (i >= 0) { ... }` loop with `str.indexOf(" ", i + 1)`: Pros - flexible and can handle various delimiter types. Cons - less concise and may have performance issues due to the loop overhead.
* `yield` function with `splitIter(str, " ")`: Pros - memory-efficient and allows for flexible iteration. Cons - requires a generator function, which might be unfamiliar to some developers.

**Test Case 2: String IndexOf**

In this test case, we're comparing the performance of two ways to find the index of a substring in a string:

```javascript
var count = 0;
var i = 0;
while (i >= 0) {
    count++;
    i = str.indexOf(" ", i + 1);
}
```

* `str.indexOf(" ")`: This method returns the index of the first occurrence of the specified value.
* `while (i >= 0) { ... }` loop with `str.indexOf(" ", i + 1)`: This method uses a loop to find the index of the next space character and then updates the variable.

**Pros and Cons:**

* `str.indexOf(" ")`: Pros - efficient and concise. Cons - only finds the first occurrence.
* `while (i >= 0) { ... }` loop with `str.indexOf(" ", i + 1)`: Pros - flexible and can find multiple occurrences. Cons - less concise and may have performance issues due to the loop overhead.

**Test Case 3: String Yield**

In this test case, we're comparing the performance of a generator function that iterates over the split string:

```javascript
function* splitIter(str, needle) {
    let i = 0;
    while (i >= 0) {
        const iOld = i;
        i = str.indexOf(needle, i + 1);
        if (i > 0)
            yield str.substring(iOld, i);
        else if (iOld < str.length)
            yield str.substring(iOld);
    }
}

let count = 0;
for (const s of splitIter(str, " ")) {
    count++;
}
```

* `splitIter(str, " ")`: This method uses a generator function to iterate over the split string and extract each substring.

**Pros and Cons:**

* `splitIter(str, " ")`: Pros - memory-efficient and allows for flexible iteration. Cons - requires a generator function, which might be unfamiliar to some developers.

**Library Used:**

None of these test cases use any external libraries.

**Special JS Feature/Syntax:**

There are no special JavaScript features or syntax used in these benchmark test cases.

**Other Alternatives:**

If you're looking for alternative approaches to string manipulation, consider the following:

* Using `Array.prototype.map()` instead of generator functions
* Utilizing `String.prototype.replace()` with a callback function
* Leveraging `String.prototype.split()` with a regular expression as the delimiter

These alternatives might provide different performance characteristics and trade-offs depending on your specific use case.

By understanding the pros and cons of each approach, you can choose the most suitable method for your string manipulation needs.

Latest run results:

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

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

Browser/OS: Chrome 124 on Windows

View result in a separate tab

Test name	Executions per second
split	12.1 Ops/sec
indexOf	24.2 Ops/sec
yield	34.8 Ops/sec

Related benchmarks:

string split vs indexOf vs yield (version: 0)

Comparing performance of: split vs indexOf vs yield

Created: 6 months ago by: Guest

Jump to the latest result

split

indexOf

yield

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