Benchmark: substr vs repeat

Script Preparation code:

window.x20k = 'x'.repeat( 20000 );

Tests:

substr
const xx = window.x20k.substr(0, 19921);
repeat
const yy = 'x'.repeat(19921);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
substr
repeat

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark definition and test cases.

**What is being tested?**

MeasureThat.net is testing two different approaches to create a string of 20,000 'x' characters: using the `substr` method or creating a repeated string using the `repeat` method. The goal is to compare their performance.

**Options compared**

Two options are being compared:

1. **Using `substr`**: This approach uses the `substr` method of strings in JavaScript, which extracts a portion of a string. In this case, it's used to extract 20,001 characters (0-based indexing) from the `x20k` variable.
2. **Creating repeated string using `repeat`**: This approach creates a new string by repeating a pattern ("x".repeat(20000)) 20,000 times.

**Pros and Cons**

* Using `substr`:
	+ Pros: This method is concise and may be faster due to the optimized implementation in JavaScript engines.
	+ Cons: It can lead to issues with null or undefined values, as well as unexpected behavior if the string is modified externally. Additionally, it might not work as expected on certain platforms or browsers.
* Creating repeated string using `repeat`:
	+ Pros: This method avoids potential issues related to null or undefined values and can provide better control over the resulting string. However, it may be slower due to the overhead of creating a new string for each iteration.
	+ Cons: The repeated string creation might lead to additional memory allocation and garbage collection, which could impact performance.

**Library usage**

The `x20k` variable is used as a library, specifically a generated string of 20,000 'x' characters. This allows the benchmark to focus on the different approaches for creating a large string without having to generate it manually or load an external resource.

**Special JS feature or syntax**

There's no specific special JavaScript feature or syntax being tested here. However, the use of `const` and the `window.x20k` variable might be considered some advanced concepts in JavaScript.

**Other alternatives**

While MeasureThat.net is focusing on `substr` and repeated string creation, other approaches could also be used to create a large string:

* **Array-based approach**: Using an array and concatenating it 20,000 times.
* **StringBuilder-like approach**: Implementing a custom implementation using a StringBuilder-like data structure (if not built-in to the browser).

It's worth noting that these alternatives might have different performance characteristics compared to the `substr` and repeated string creation methods being tested.

Related benchmarks:

substr vs repeat (version: 0)

Comparing performance of: substr vs repeat

Created: 8 years ago by: Guest

Jump to the latest result

substr

repeat

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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