Benchmark: String concatenation vs array join

Script Preparation code:

var str = "";
var i;
var sArr = [];

Tests:

String concatentation
for (i = 1000; i > 0; i--) { str += "String concatenation. "; }
Array join
for (i = 1000; i > 0; i--) { sArr[i] = "String concatenation. "; } str = sArr.join("");
Array join (w/ push)
for (i = 1000; i > 0; i--) { sArr.push("String concatenation. "); } str = sArr.join("");

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
String concatentation
Array join
Array join (w/ push)

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The benchmark, as defined in the provided JSON, tests three different approaches for concatenating strings: using string concatenation (`str +=`), array join (`sArr.join()`), and array push with subsequent join (`sArr.push()`).

**Comparison of Approaches**

1. **String Concatenation**: This approach involves appending a string to another string using the `+=` operator.
	* Pros:
		+ Simple and straightforward.
		+ Fast, since it avoids creating new strings.
	* Cons:
		+ Can lead to memory fragmentation and performance issues in JavaScript engines due to frequent string reallocations.
2. **Array Join**: This approach involves storing individual strings in an array and then joining them using the `join()` method.
	* Pros:
		+ More efficient than string concatenation for large numbers of strings, since it avoids creating new strings and only creates a single string object.
	* Cons:
		+ Requires creating an array and populating it with individual strings, which can be slower than string concatenation.
3. **Array Push with Join**: This approach is similar to the previous one, but instead of storing the individual strings in an array and then joining them, it pushes new strings onto the end of an existing array.
	* Pros:
		+ Similar efficiency benefits as array join, since it avoids creating new strings.
	* Cons:
		+ Requires modifying the original array, which can be slower than string concatenation.

**Library Used: None**

The benchmark does not use any external libraries or dependencies other than JavaScript's built-in `Array` and `String` objects.

**Special JS Features/Syntax: None**

There are no special JavaScript features or syntax used in this benchmark that would require specific knowledge of the language to understand.

**Other Alternatives**

Alternative approaches to string concatenation could include:

* Using a `StringBuilder` class, if available in the JavaScript engine being tested.
* Using a template literal (e.g., `${}`), which can provide a more efficient way to concatenate strings than traditional string concatenation.
* Using a third-party library like Lodash or Underscore.js, which provides utility functions for string manipulation.

However, these alternatives may not be supported by all JavaScript engines or platforms being tested in the benchmark.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15

Browser/OS: Safari 18 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
String concatentation	8614.5 Ops/sec
Array join	14452.7 Ops/sec
Array join (w/ push)	43.7 Ops/sec

Related benchmarks:

String concatenation vs array join (version: 5)

Comparing performance of: String concatentation vs Array join vs Array join (w/ push)

Created: 6 years ago by: Registered User

Jump to the latest result

String concatentation

Array join

Array join (w/ push)

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