Benchmark: Count char occurrence in string

Script Preparation code:

function regex (s, c) {
  return (s.match(new RegExp(c, "g")) || []).length;
}

function split (s, c) {
  return s.split(c).length - 1;
}

function indexOf1 (s, c) {
  var i = 0, count = 0;
  while ((i = s.indexOf(c, i)) >= 0) {
    count++;
    i++;
  }
  return count;
}

function indexOf2 (s, c) {
  for (let i = -2, count = -1; i != -1; count++, i = s.indexOf(c, i + 1));
}

function singleChar (s, c) {
  for(let i = 0, count = 0, l = s.length; i < l; count += +(c === s[i++]));
}

var s = "Maecenas sed lacus erat. Sed fringilla dui ac mollis condimentum. Suspendisse bibendum nulla eros, ut lobortis orci posuere quis. Nunc fringilla ut metus ultrices dictum. Nunc elementum feugiat leo. Ut fermentum, enim vel vehicula posuere, metus eros imperdiet risus, at elementum mauris urna et quam. Ut vehicula, velit at placerat ornare, nulla nisi finibus sapien, non elementum tellus purus in ex. Donec pharetra elit in rhoncus placerat. Sed volutpat eget justo ut dapibus. Mauris consectetur turpis ac euismod aliquam. Sed pellentesque pretium nunc, nec rhoncus leo euismod ut. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur gravida sed urna quis tempus. Nam aliquet tortor convallis libero mollis luctus.";
var c = "a";

Tests:

regex
window.result = regex(s, c);
split
window.result = split(s, c);
indexOf1
window.result = indexOf1(s, c);
indexOf2
window.result = indexOf2(s, c);
singleChar
window.result = singleChar(s, c);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
regex
split
indexOf1
indexOf2
singleChar

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 MeasureThat.net and analyze the provided benchmark.

**Benchmark Definition JSON**

The benchmark definition represents a simple task: counting the occurrence of a specific character in a given string. The benchmark is divided into four test cases, each with its own implementation:

1. `regex(s, c)`: uses regular expressions to find all occurrences of the character `c` in the string `s`.
2. `split(s, c)`: splits the string `s` into an array using the character `c` as the delimiter and then returns the length of the resulting array minus 1 (since the split operation creates an empty string at the end).
3. `indexOf1(s, c)`: uses a loop to find all occurrences of the character `c` in the string `s`.
4. `indexOf2(s, c)`: uses a loop with an index increment that starts from -2 and iterates over the string `s` to find all occurrences of the character `c`.

**Options Compared**

The four test cases use different approaches to achieve the same goal:

1. **Regular Expressions (regex)**: uses patterns to search for characters in strings, which can be slow due to the complexity of pattern matching.
2. **String Splitting (split)**: uses the string's natural delimiter properties to split the string into substrings, which can lead to inefficient results if the delimiter is not common enough.
3. **Linear Search (indexOf1)**: iterates over the string using a simple loop, making it suitable for small strings but slow for large ones.
4. **Optimized Linear Search (indexOf2)**: uses a more efficient search strategy by incrementing the index from -2, reducing the number of iterations.

**Pros and Cons**

Here's a brief analysis of each approach:

1. **Regex**: Pros: simple to implement, supports complex patterns; Cons: slow due to pattern matching, may not be suitable for very large strings.
2. **Splitting**: Pros: easy to implement, can handle common delimiters; Cons: inefficient if the delimiter is not frequent enough, may lead to empty results at the end of the string.
3. **Linear Search (indexOf1)**: Pros: simple to understand and implement; Cons: slow for large strings due to the number of iterations.
4. **Optimized Linear Search (indexOf2)**: Pros: more efficient than traditional linear search by reducing iterations; Cons: requires a specific increment strategy, which may not be suitable for all use cases.

**Library Usage**

None of the provided test cases uses an external library.

**Special JavaScript Features or Syntax**

The benchmark defines custom functions `regex`, `split`, `indexOf1`, and `indexOf2` using the JavaScript syntax. The `window.result = ...` syntax is used to store the result in a variable, which will be executed by the browser.

**Other Alternatives**

If you were to rewrite this benchmark, you could consider alternative approaches like:

* Using built-in string methods (`String.prototype.split()`, `String.prototype.indexOf()`)
* Utilizing native functions like `Array.prototype.includes()` or `RegExp.prototype.test()`
* Employing more advanced algorithms, such as Boyer-Moore search
* Comparing performance using libraries like Benchmark.js

However, for this specific benchmark, the provided custom implementations are suitable for demonstrating the different approaches to solving the problem.

Latest run results:

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

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

Browser/OS: Chrome 128 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
regex	720311.9 Ops/sec
split	3245172.5 Ops/sec
indexOf1	1459711.2 Ops/sec
indexOf2	1503799.6 Ops/sec
singleChar	535844.1 Ops/sec

Related benchmarks:

Count char occurrence in string (version: 0)

http://stackoverflow.com/questions/4009756/how-to-count-string-occurrence-in-string http://stackoverflow.com/questions/881085/count-the-number-of-occurences-of-a-character-in-a-string-in-javascript

Comparing performance of: regex vs split vs indexOf1 vs indexOf2 vs singleChar

Created: 2 years ago by: Guest

Jump to the latest result

regex

split

indexOf1

indexOf2

singleChar

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