Benchmark: Split strings by character count

Script Preparation code:

var cnt = 500 * 1024;
var str = []
for(var i=0; i < cnt; i++) {
  str.push( String.fromCharCode(Math.random() * 94 + 32) );
}
str = str.join("");

var regex = function(count) {
  var rgx = new RegExp("[\\s\\S]{1," + count + "}", "g");
  var parts = str.match(rgx);
};

var slice = function(count) {
  var parts = [];
  for(var i = 0, len = str.length; i < len; i += count) {
    parts.push( str.slice(i, i + count) );
  }
};

Tests:

Testing Regex, Length 1
regex(1);
Testing Regex, Length 10
regex(10);
Testing Regex, Length 100
regex(100);
Testing Regex, Length 9 kB
regex(9 * 1024);
Testing Slice, Length 1
slice(1);
Testing Slice, Length 10
slice(10);
Testing Slice, Length 100
slice(100);
Testing Slice, Length 9 kB
slice(9 * 1024);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Testing Regex, Length 1
Testing Regex, Length 10
Testing Regex, Length 100
Testing Regex, Length 9 kB
Testing Slice, Length 1
Testing Slice, Length 10
Testing Slice, Length 100
Testing Slice, Length 9 kB

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 121 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Testing Regex, Length 1	112.6 Ops/sec
Testing Regex, Length 10	628.7 Ops/sec
Testing Regex, Length 100	1774.2 Ops/sec
Testing Regex, Length 9 kB	2232.3 Ops/sec
Testing Slice, Length 1	54.5 Ops/sec
Testing Slice, Length 10	465.4 Ops/sec
Testing Slice, Length 100	4541.1 Ops/sec
Testing Slice, Length 9 kB	479225.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring performance and optimizing code is a crucial aspect of software development. MeThatNet provides a platform for JavaScript microbenchmarks to help developers understand the performance implications of their code.

**Benchmark Definition**

The provided JSON represents a benchmark definition, which defines a test scenario for measuring performance. In this case, we have two functions:

1. `regex(count)`: This function creates a regular expression with a specified length (`count`) and searches for matches in a randomly generated string.
2. `slice(count)`: This function splits the input string into substrings of equal length (`count`) using the `String.prototype.slice()` method.

**Options Comparison**

We have two main options to compare:

1. **Regex approach (regex count)**: This option uses regular expressions to split the input string. The performance impact depends on the complexity of the regex pattern and the size of the input string.
2. **Slice approach (slice count)**: This option uses the `String.prototype.slice()` method to split the input string into substrings. Performance-wise, this method is generally faster since it's implemented in native code.

**Pros and Cons**

* **Regex approach:**
	+ Pros:
		- Can be used for more complex splitting scenarios.
		- Might be suitable for edge cases where slicing doesn't work as expected.
	+ Cons:
		- May incur a significant performance penalty due to the overhead of creating and executing regex patterns.
		- Can lead to slower performance for larger input sizes.
* **Slice approach:**
	+ Pros:
		- Generally faster than regex-based solutions.
		- Suitable for most use cases where simple slicing is required.
	+ Cons:
		- Might not work as expected for more complex splitting scenarios.

**Library: RegExp**

The `RegExp` library is used to create regular expressions. While it's a built-in JavaScript library, it might not be immediately obvious due to its versatility and flexibility.

**Special JS feature or syntax**

There are no special JavaScript features or syntax in this benchmark definition.

**Other Alternatives**

If you prefer alternative approaches for splitting strings:

* **Array.prototype.map()**: You can use `Array.prototype.map()` to create an array of substrings, but it might be slower than the slice approach due to the overhead of iterating over the array.
* **String.prototype.split()**: Some older browsers still support `String.prototype.split()`, which can be used for substring splitting. However, this method is generally slower and less flexible than the slice approach.

Keep in mind that performance optimization should always be guided by the specific requirements and constraints of your project.

Related benchmarks:

Split strings by character count (version: 0)

Comparing performance of: Testing Regex, Length 1 vs Testing Regex, Length 10 vs Testing Regex, Length 100 vs Testing Regex, Length 9 kB vs Testing Slice, Length 1 vs Testing Slice, Length 10 vs Testing Slice, Length 100 vs Testing Slice, Length 9 kB

Created: 6 years ago by: Guest

Jump to the latest result

Testing Regex, Length 1

Testing Regex, Length 10

Testing Regex, Length 100

Testing Regex, Length 9 kB

Testing Slice, Length 1

Testing Slice, Length 10

Testing Slice, Length 100

Testing Slice, Length 9 kB

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