Benchmark: Battle of strings

Script Preparation code:

var demoStr = 'This is a  demo of a  long string with  multiple spaces occasionally  added throughout  it.';

function regexReplace(str) {
  return str.replace(/\s+/g, ' ');
};

function arrayReplace(str) {
  let resultArr = [];
  const strArr = str.split(' ');
  for (let i = 0; i < strArr.length; i++) {
    if (strArr[i] != '') {
      resultArr.push(strArr[i]);
    }
  }
  return resultArr.join(' ');
};

function collapseSpaces(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;
}

Tests:

regexReplace
regexReplace(demoStr)
arrayReplace
arrayReplace(demoStr)
collapseSpaces
collapseSpaces(demoStr)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
regexReplace
arrayReplace
collapseSpaces

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Measuring JavaScript performance is a complex task, and the provided benchmark test cases cover various approaches to achieving the same goal: removing multiple consecutive spaces from a string.

**Benchmark Definition JSON**

The benchmark definition represents three test cases:

1. `regexReplace(demoStr)`: This function uses a regular expression (`/\\s+/g`) to replace one or more whitespace characters with a single space.
2. `arrayReplace(demoStr)`: This function splits the input string into an array, iterates over it, and pushes non-empty strings back into the array, joined by spaces.
3. `collapseSpaces(s)`: This function manually checks each character in the input string; if it's a space, it collapses adjacent spaces until it encounters another non-space character.

**Options Compared**

The three approaches differ in their implementation:

* **Regex-based approach (`regexReplace`)**: Uses regular expressions to simplify the process of removing multiple consecutive spaces.
	+ Pros:
		- Concise and efficient code
		- Well-supported by most browsers
	+ Cons:
		- May be slower than other methods due to the overhead of regular expression compilation
* **Array-based approach (`arrayReplace`)**: Splits the input string into an array, iterates over it, and joins the non-empty strings.
	+ Pros:
		- Easy to understand and implement
		- Fast and efficient in most cases
	+ Cons:
		- Creates temporary arrays and may consume more memory than other methods
* **Manual iteration approach (`collapseSpaces`)**: Iterates over each character in the input string, collapsing adjacent spaces manually.
	+ Pros:
		- Low overhead and minimal memory usage
	+ Cons:
		- Longer and more complex code compared to other methods

**Library Usage**

None of the provided functions use external libraries. However, if you were to implement this benchmark using a library like Lodash (a popular JavaScript utility library), you might use its `compact` function, which can simplify the array-based approach.

**Special JS Features or Syntax**

The benchmark uses standard JavaScript features such as:

* Regular expressions (`/\\s+/g`)
* Array methods (`split`, `join`, `push`, `indexOf`)
* Looping constructs (`for`)
* String manipulation techniques (`charAt`, `length`)

Note that the manual iteration approach (`collapseSpaces`) demonstrates a more low-level, character-by-character processing style, which can be useful for educational purposes or when working with specific edge cases.

**Other Alternatives**

If you were to implement this benchmark using other approaches, some alternatives could include:

* Using a string replacement library like `string-replace` (a lightweight, polyfill-based solution)
* Implementing the `trim()` method using regular expressions
* Utilizing a more advanced string processing library like `js-string-regex`
* Employing a custom implementation of the `reduce()` method for array manipulation

Keep in mind that these alternatives might introduce additional overhead, complexity, or dependencies compared to the original benchmark.

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
regexReplace	842735.9 Ops/sec
arrayReplace	1242272.8 Ops/sec
collapseSpaces	406133.4 Ops/sec

Related benchmarks:

Battle of strings (version: 0)

Comparing performance of: regexReplace vs arrayReplace vs collapseSpaces

Created: 7 years ago by: Guest

Jump to the latest result

regexReplace

arrayReplace

collapseSpaces

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