Benchmark: repeat - MeasureThat.net

Script Preparation code:

function repeatify(string, repetitions) {
   if (repetitions < 0 || repetitions === Infinity) {
      throw new RangeError('Invalid repetitions number');
   }
 
   let result = '';
 
   for (let i = 0; i < repetitions; i++) {
      result += string;
   }
 
   return result;
}

function repeatifyWithArrayAndJoin(string, repetitions) {
   if (repetitions < 0 || repetitions === Infinity) {
      throw new RangeError('Invalid repetitions number');
   }
 
   const result = [];
 
   for (let i = 0; i < repetitions; i++) {
      result.push(string);
   }
 
   return result.join('');
}

function repeatifyWithNewArray(string, repetitions) {
   if (repetitions < 0 || repetitions === Infinity) {
      throw new RangeError('Invalid repetitions number');
   }
  
   return new Array(repetitions).join(string);
}

function _checkRepeations(repetitions) {
	if (repetitions < 0 || repetitions === Infinity) {
      throw new RangeError('Invalid repetitions number');
   }
}

function repeatifyWithNewArrayAndExternalThrow(string, repetitions) {
   _checkRepeations(repetitions);
  
   return new Array(repetitions).join(string);
}

function repeatifyWithNewArrayAndExternalThrowWithProps(string, repetitions) {
   this.checkRepeations(repetitions);
  
   return new this.Array(repetitions).join(string);
}

var ctx = {
	checkRepeations: _checkRepeations,
  	Array: Array
}

repeatifyWithNewArrayAndExternalThrowWithProps = repeatifyWithNewArrayAndExternalThrowWithProps.bind(ctx);

var TEST_STRING = 'home, sweet home';
var COUNT = 1e6;

Tests:

native repeat
TEST_STRING.repeat(COUNT);
stupid repeatify
repeatify(TEST_STRING, COUNT);
repeatifyWithArrayAndJoin
repeatifyWithArrayAndJoin(TEST_STRING, COUNT);
repeatifyWithNewArray
repeatifyWithNewArray(TEST_STRING, COUNT);
repeatifyWithNewArrayAndExternalThrow
repeatifyWithNewArrayAndExternalThrow(TEST_STRING, COUNT);
repeatifyWithNewArrayAndExternalThrowWithProps
repeatifyWithNewArrayAndExternalThrowWithProps(TEST_STRING, COUNT);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
native repeat
stupid repeatify
repeatifyWithArrayAndJoin
repeatifyWithNewArray
repeatifyWithNewArrayAndExternalThrow
repeatifyWithNewArrayAndExternalThrowWithProps

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Taking a deep breath...

Measuring JavaScript performance is crucial, and MeasureThat.net provides a great platform for benchmarking various approaches.

**Benchmark Definition JSON**

The provided Benchmark Definition JSON defines a simple string repetition task. The script preparation code consists of four different implementations of the `repeatify` function with varying levels of complexity:

1.  **native repeat**: Uses the built-in string multiplication operator (`*`) to repeat the input string.
2.  **stupid repeatify**: A naive implementation that uses a loop to concatenate strings.
3.  **repeatifyWithArrayAndJoin**: Utilizes an array and the `join()` method to repeat the input string.
4.  **repeatifyWithNewArray**: Creates a new array with repeated elements using the `new Array(repetitions)` constructor.
5.  **repeatifyWithNewArrayAndExternalThrow**: Similar to the previous implementation, but uses an external function to throw an error for invalid repetitions.

**Individual Test Cases**

Each test case corresponds to one of the above implementations, with a unique name:

1.  `native repeat`: The built-in string multiplication operator approach.
2.  `stupid repeatify`: A simple loop-based concatenation implementation.
3.  `repeatifyWithArrayAndJoin`: Uses an array and `join()` for repetition.
4.  `repeatifyWithNewArray`: Creates a new array with repeated elements.
5.  `repeatifyWithNewArrayAndExternalThrow`: Similar to the previous implementation, but uses an external function.

**Benchmark Results**

The latest benchmark results show the performance of each test case across different devices and browsers. The results are expressed in executions per second (`ExecutionsPerSecond`).

**Pros and Cons**

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

1.  **native repeat**: Fast, built-in functionality. However, it may not be as flexible or efficient for larger repetition counts.
2.  `stupid repeatify`: Simple to implement but can lead to performance issues with large input strings due to string concatenation overhead.
3.  `repeatifyWithArrayAndJoin`: Efficient and scalable, using array operations under the hood. However, it may have a slight performance hit compared to native repeat.
4.  `repeatifyWithNewArray`: Creates a new array for each repetition, leading to memory allocation and deallocation overhead. This approach can be less efficient than others.

**Recommendations**

Based on the benchmark results, `repeatifyWithArrayAndJoin` appears to be the most efficient implementation, offering a good balance between performance and scalability. However, the built-in string multiplication operator (`native repeat`) remains a close second.

When choosing an implementation for your specific use case, consider factors such as:

*   Repetition count: For small repetition counts, `native repeat` might be sufficient.
*   Input size: Larger input strings may benefit from more efficient approaches like `repeatifyWithArrayAndJoin`.
*   Performance requirements: If you need the best possible performance, `repeatifyWithArrayAndJoin` is a good choice.

Keep in mind that these are general guidelines, and the optimal approach may vary depending on your specific requirements.

Latest run results:

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

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

Browser/OS: Chrome 57 on Mac OS X 10.11.6

View result in a separate tab

Test name	Executions per second
native repeat	2025898.0 Ops/sec
stupid repeatify	10.2 Ops/sec
repeatifyWithArrayAndJoin	12.5 Ops/sec
repeatifyWithNewArray	58.9 Ops/sec
repeatifyWithNewArrayAndExternalThrow	60.6 Ops/sec
repeatifyWithNewArrayAndExternalThrowWithProps	61.8 Ops/sec

Related benchmarks:

repeat (version: 4)

Comparing performance of: native repeat vs stupid repeatify vs repeatifyWithArrayAndJoin vs repeatifyWithNewArray vs repeatifyWithNewArrayAndExternalThrow vs repeatifyWithNewArrayAndExternalThrowWithProps

Created: 7 years ago by: Registered User

Jump to the latest result

native repeat

stupid repeatify

repeatifyWithArrayAndJoin

repeatifyWithNewArray

repeatifyWithNewArrayAndExternalThrow

repeatifyWithNewArrayAndExternalThrowWithProps

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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