Benchmark: test collapse strings

Script Preparation code:

var test = "a a   sdf   s  d  s d f          s df k sd l l sdlk        sdlf l l sdf sdlf      s dlf   sd f   f  df  f f f  f"
function clean(str) {

var cleanedStr = "";

for (var i = 0; i < str.length; i++) {
let char = str[i];
  let prevChar = str[i - 1];

  if (!(char === " " && prevChar === " ")) {
    cleanedStr += char;
  }
}
return cleanedStr; 
}

function collapseSpaces(str) {
return str.replace(/\s+/g, ' ');
};

function collapseSpacesHalden(s) {
let result = '';
 for (let i = 0; i < s.length; i++) {
 	const c = s.charAt(i);
   result += c;
 	if (c === ' ') {
   	while (i < s.length - 1 && s.charAt(i + 1) === ' ') {
     	i++;
     }
   }
 }
 return result;
}

function collapseSpacesDonnie(str) {
var out = ""
str.split(" ").forEach((c) => {
if (!!c) {
out += c + " "
}
})
return out.trim()
}

Tests:

kaushal
clean(test)
jon / andrew
collapseSpaces(test)
halden
collapseSpacesHalden(test)
donnie
collapseSpacesDonnie(test)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
kaushal
jon / andrew
halden
donnie

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Definition JSON**

The provided JSON defines a benchmark for measuring the performance of three different string collapse functions: `clean()`, `collapseSpaces()`, and two variations of `collapseSpaces()` implemented by Donnie, Halden, and Donnie (again). The script preparation code includes a sample input string `test` with multiple spaces. The HTML preparation code is empty.

**Options Compared**

The three options being compared are:

1. **Cleaned String (clean())**: This function removes consecutive duplicate spaces from the input string.
2. **Replace Whitespace (collapseSpaces())**: This function replaces one or more whitespace characters (`\\s+`) with a single space character using regular expressions.
3. **Halden's Variation (collapseSpacesHalden())**: This function iterates through the input string, skipping consecutive spaces and adding only one space at the end of each group of non-space characters.
4. **Donnie's Variation 1 (collapseSpacesDonnie())**: This function splits the input string into an array of non-space strings, joins them back together with a single space character in between, and trims any leading or trailing whitespace.
5. **Donnie's Variation 2 (collapseSpacesDonnie())** ( identical to above ): Another iteration of Donnie's variation.

**Pros and Cons**

Here are some pros and cons for each approach:

1. **Cleaned String (clean())**:
	* Pros: Simple, straightforward implementation; likely to be optimized by modern JavaScript engines.
	* Cons: May not perform well for very large input strings or edge cases with multiple consecutive spaces.
2. **Replace Whitespace (collapseSpaces())**:
	* Pros: Efficient use of regular expressions; should perform well for most input strings.
	* Cons: May be slower than other approaches due to the overhead of regex engine execution.
3. **Halden's Variation (collapseSpacesHalden())**:
	* Pros: Simple, linear iteration over input string; may be more efficient than `clean()` for very large inputs.
	* Cons: Less intuitive implementation compared to `clean()`, which may lead to slower performance due to increased function call overhead.
4. **Donnie's Variation 1 (collapseSpacesDonnie())**:
	* Pros: Simple, array-based implementation; should perform well for most input strings.
	* Cons: May be slower than other approaches due to the overhead of array manipulation and string concatenation.

**Other Considerations**

When evaluating these options, it's essential to consider factors such as:

* **Cache locality**: The order in which characters are accessed can impact performance. `clean()` might perform better on modern CPUs due to its sequential access pattern.
* **Regular expression engine overhead**: While regular expressions can be efficient for certain tasks, the overhead of parsing and executing regex engines may offset their benefits.
* **Array manipulation efficiency**: Donnie's variations might be slower than other approaches due to the overhead of array creation, concatenation, and iteration.

**Library Usage**

There is no explicit library usage in the provided benchmark definition. However, it's worth noting that some JavaScript engines (like SpiderMonkey) use a custom regex engine for regular expression execution, which might impact performance characteristics.

**Special JS Features or Syntax**

None of the test cases explicitly utilize any special JavaScript features or syntax beyond standard ES5 capabilities.

Latest run results:

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

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

Browser/OS: Chrome 60 on Mac OS X 10.12.6

View result in a separate tab

Test name	Executions per second
kaushal	135824.2 Ops/sec
jon / andrew	622421.7 Ops/sec
halden	241091.3 Ops/sec
donnie	323308.8 Ops/sec

Related benchmarks:

test collapse strings (version: 0)

Comparing performance of: kaushal vs jon / andrew vs halden vs donnie

Created: 7 years ago by: Guest

Jump to the latest result

kaushal

jon / andrew

halden

donnie

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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