Benchmark: arity 3 string join vs concat vs plus with separator

Script Preparation code:

function joinPairJoin(separator, fst, snd) { return [fst, snd].join(separator) }
function joinPairConcat(separator, fst, snd) { return fst.concat(separator, snd) }
function joinPairConcatConcat(separator, fst, snd) { return fst.concat(separator).concat(snd) }
function joinPairAdd(separator, fst, snd) { return fst + separator + snd }

Tests:

Join string parts
const str = joinPairJoin('-', 'foo', 'bar')
Concat string parts
const str = joinPairConcat('-', 'foo', 'bar')
Chained concat string parts
const str = joinPairConcatConcat('-', 'foo', 'bar')
Add string parts
const str = joinPairAdd('-', 'foo', 'bar')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Join string parts
Concat string parts
Chained concat string parts
Add string parts

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

The provided JSON represents a JavaScript benchmarking test case, specifically designed to compare the performance of different methods for joining or concatenating strings in JavaScript.

**Benchmark Definition:**

The benchmark definition consists of four functions:

1. `joinPairJoin(separator, fst, snd)`: Uses the `Array.prototype.join()` method with a separator.
2. `joinPairConcat(separator, fst, snd)`: Uses the `Array.prototype.concat()` method with a separator.
3. `joinPairConcatConcat(separator, fst, snd)`: Concatenates two arrays using `concat()`, and then concatenates the result to another array using `concat()` again.
4. `joinPairAdd(separator, fst, snd)`: Simply concatenates three strings using the `+` operator with a separator.

**Options compared:**

The benchmark compares the performance of these four functions:

1. Using `Array.prototype.join()`
2. Using `Array.prototype.concat()`
3. Chaining multiple calls to `concat()`
4. Using the `+` operator with a separator

**Pros and Cons:**

* **join()**: Pros:
	+ Simple and concise
	+ Fast, as it uses a built-in method optimized for performance
Cons:
	+ May not be as readable or maintainable for complex cases
* **concat():** Pros:
	+ Flexible and reusable
	+ Can handle complex arrays or concatenated strings
Cons:
	+ May be slower than `join()` due to the overhead of creating an array
* **Chaining concat():** Pros:
	+ Allows for more control over the concatenation process
	+ Can be useful in certain scenarios where multiple operations are needed
Cons:
	+ Can lead to performance overhead due to repeated calls to `concat()`
* **Add operator (+):** Pros:
	+ Simple and concise
	+ Fast, as it uses a built-in method optimized for performance
Cons:
	+ May not be suitable for complex cases or large strings

**Library usage:**

None of the functions explicitly use any external libraries.

**Special JS feature/syntax:**

The benchmark does not utilize any special JavaScript features or syntax. It only relies on standard JavaScript methods and operators.

**Other alternatives:**

If you were to write a similar benchmark, you might also consider including tests for other string concatenation methods, such as:

* Using a template string
* Using the `String.prototype.repeat()` method
* Using a loop to concatenate strings

Keep in mind that these additional tests would require more extensive code and may not provide significant performance differences compared to the existing benchmark.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.77 Safari/537.36

Browser/OS: Chrome 91 on Linux

View result in a separate tab

Test name	Executions per second
Join string parts	5938286.0 Ops/sec
Concat string parts	8549126.0 Ops/sec
Chained concat string parts	11140872.0 Ops/sec
Add string parts	11487271.0 Ops/sec

Related benchmarks:

arity 3 string join vs concat vs plus with separator (version: 1)

Comparing performance of: Join string parts vs Concat string parts vs Chained concat string parts vs Add string parts

Created: 3 years ago by: Registered User

Jump to the latest result

Join string parts

Concat string parts

Chained concat string parts

Add string parts

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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