Benchmark: chunk string - MeasureThat.net

Script Preparation code:

var strTxt = Array(100).fill("@".repeat(128)).join(" "), len = 4, asize = Math.ceil(strTxt.length/len);

Tests:

RegEx Match
var ar = strTxt.match(new RegExp('.{1,'+len+'}','g'));
For Slice
var ar = Array(asize); for(i=0,y=0;i<asize;i++,y=i*len){ ar[i] = strTxt.slice(y,y+len); }
For SubStr
var ar = Array(asize); for(i=0,y=0;i<asize;i++,y=i*len){ ar[i] = strTxt.substr(y,len); }
While Slice
var ar = Array(asize),i = 0; while(i<asize){ ar[i] = strTxt.slice(i*len,i*len+len); i++; }
While SubStr
var ar = Array(asize),i = 0; while(i<asize){ ar[i] = strTxt.substr(i*len,len); i++; }
Generator SubStr
var ar = [...(function *(){for(i=0;i<asize;i++){yield strTxt.substr(i*len,len);}})()];
Map SubStr
var ar = [...Array(asize)].map((v,i)=> strTxt.substr(i*len,len));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
RegEx Match
For Slice
For SubStr
While Slice
While SubStr
Generator SubStr
Map SubStr

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 4 years ago)

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

Browser/OS: Chrome 85 on Windows 7

View result in a separate tab

Test name	Executions per second
RegEx Match	7322.8 Ops/sec
For Slice	283.7 Ops/sec
For SubStr	344.6 Ops/sec
While Slice	552.1 Ops/sec
While SubStr	680.1 Ops/sec
Generator SubStr	592.3 Ops/sec
Map SubStr	844.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and analyze what's being tested.

**Benchmark Definition**

The `Script Preparation Code` section defines a string variable `strTxt`, which is a large chunk of text created by filling an array with repeated characters (`@`) using the `Array.fill()` method. The length of each chunk is determined by `len = 4`, and the total number of chunks is `asize = Math.ceil(strTxt.length/len)`.

**Test Cases**

The benchmark consists of six test cases, each measuring the performance of a different approach to extract substrings from `strTxt`. The approaches are:

1. **Regex Match**: Using the `match()` method with a regular expression.
2. **For Slice**: Iterating over an array and using the `slice()` method to extract substrings.
3. **For SubStr**: Iterating over an array and using the `substr()` method to extract substrings.
4. **While Slice**: Using a while loop and the `slice()` method to extract substrings.
5. **While SubStr**: Using a while loop and the `substr()` method to extract substrings.
6. **Generator SubStr** and **Map SubStr**: Using generators and the `map()` function, respectively, to extract substrings.

**Comparison**

The test cases are comparing the performance of different approaches to extract substrings from a large string. The results show that:

* Regex Match is generally slower than other methods.
* For Slice and For SubStr are similar in performance, but slightly faster than While Slice and While SubStr.
* Generator SubStr and Map SubStr are significantly faster than the other methods.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

1. **Regex Match**: Pros: simple to implement, efficient for fixed-length substrings. Cons: can be slow for large inputs, may not work well with variable-length substrings.
2. **For Slice/For SubStr**: Pros: straightforward, works well for fixed-length substrings. Cons: can be slower than other methods due to the loop overhead.
3. **While Slice/While SubStr**: Pros: efficient, uses minimal memory. Cons: can be harder to implement correctly, may not work well with variable-length substrings.
4. **Generator SubStr/Map SubStr**: Pros: efficient, easy to implement, works well for large inputs. Cons: requires understanding of generators and map functions.

**Library Used**

None of the test cases use any external libraries.

**Special JS Features/Syntax**

The benchmark uses several advanced JavaScript features, including:

* `Array.prototype.fill()`
* Regular expressions (`match()` function)
* Generators (using the `function *(){...}()` syntax)
* Map functions (using the `map()` function)

These features are used to implement efficient and concise solutions for extracting substrings from large strings.

**Alternatives**

Other approaches to extract substrings from a string include:

* Using slicing with array literals (`strTxt.slice(0, len)`): slower than using the built-in methods.
* Using string indexing (`strTxt[0]` to `strTxt[len-1]`): slow and inefficient for large inputs.

Note that these alternatives are not included in the benchmark, but they can be used as reference points when considering different approaches to substring extraction.

Related benchmarks:

chunk string (version: 0)

Comparing performance of: RegEx Match vs For Slice vs For SubStr vs While Slice vs While SubStr vs Generator SubStr vs Map SubStr

Created: 4 years ago by: Guest

Jump to the latest result

RegEx Match

For Slice

For SubStr

While Slice

While SubStr

Generator SubStr

Map SubStr

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