Benchmark: Count string occurrence

Script Preparation code:

function regex(s, re) {
  var r = s.match(re);
  if (r) return r.length;
  return 0;
}

function split(s, oc) {
  return s.split(oc).length - 1;
}

function indexOf(s, oc) {
  var i = 0, count = 0;
  while ((i = s.indexOf(oc, i)) >= 0) {
    count++;
    i++;
  }
  return count;
}

Tests:

Use regex
window.result = regex("This is a pen", /is/g);
Use split
window.result = split("This is a pen", "is");
Use indexOf
window.result = indexOf("This is a pen", "is");

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Use regex
Use split
Use indexOf

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 21 days ago)

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
Use regex	12649322.0 Ops/sec
Use split	30692560.0 Ops/sec
Use indexOf	23808120.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what's being tested.

**Benchmark Definition**

The benchmark is to measure which method (regex, split, or indexOf) is the fastest for counting the occurrences of a substring in a string. The description links to Stack Overflow questions that provide context for the problem.

**Script Preparation Code**

The script preparation code includes three functions:

1. `regex(s, re)`: This function takes two arguments: the input string `s` and a regular expression `re`. It returns the number of matches found in the string.
2. `split(s, oc)`: This function takes two arguments: the input string `s` and a separator character or string `oc`. It splits the string into substrings separated by `oc` and returns the length of the resulting array minus one (which effectively removes the empty strings at the start and end).
3. `indexOf(s, oc)`: This function takes two arguments: the input string `s` and a substring `oc`. It iterates through the string to find all occurrences of `oc` starting from the current position and returns the number of matches.

**Html Preparation Code**

There is no HTML preparation code provided, which suggests that the benchmark is focused solely on JavaScript performance.

**Individual Test Cases**

The three test cases are:

1. "Use regex"
2. "Use split"
3. "Use indexOf"

These test cases execute each function once with a specific input string ("This is a pen") and a substring ("is").

**Latest Benchmark Result**

The benchmark result shows the performance metrics for each test case, including:

* `RawUAString`: The raw user agent string of the browser that executed the benchmark.
* `Browser` and `DevicePlatform`: Information about the browser and device platform used.
* `OperatingSystem`: The operating system used by the browser.
* `ExecutionsPerSecond`: The average number of executions per second for each test case.

**Approaches Compared**

The three approaches are:

1. **Regex**: Using a regular expression to find all occurrences of the substring in the input string.
2. **Split**: Splits the input string into substrings separated by the substring and returns the length of the resulting array minus one.
3. **IndexOf**: Iterates through the input string to find all occurrences of the substring and returns the number of matches.

**Pros and Cons**

Here are some pros and cons for each approach:

1. **Regex**:
	* Pros: Can be highly efficient, flexible, and powerful for complex pattern matching.
	* Cons: Can be slow for simple patterns, requires careful optimization, and may have security concerns if not used properly.
2. **Split**:
	* Pros: Simple, fast, and easy to implement.
	* Cons: Requires the substring to be separated from other characters, which might not always be possible or desired.
3. **IndexOf**:
	* Pros: Fast and efficient for simple substring matching.
	* Cons: May not work well for complex patterns or very large strings.

**Library Use**

None of the test cases use external libraries.

**Special JS Features**

The benchmark does not appear to use any special JavaScript features beyond standard ES6 syntax. If you're interested in exploring other features, such as async/await or Promises, I can help with that!

**Other Alternatives**

If you'd like to explore alternative methods for counting substring occurrences, here are a few options:

1. **String.prototype.includes()**: This method is similar to indexOf() but returns false if the substring is not found.
2. **Array.prototype.indexOf()**: If you split the string into an array of substrings and then use indexOf(), this approach can be more efficient for large strings.
3. **A regular expression with a flag (e.g., /i) for case-insensitive matching**

These alternatives may offer different trade-offs in terms of performance, simplicity, or feature set. Let me know if you'd like to explore any of these options further!

Related benchmarks:

Count string occurrence (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: Use regex vs Use split vs Use indexOf

Created: 7 years ago by: Registered User

Jump to the latest result

Use regex

Use split

Use indexOf

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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