Benchmark: String() vs .toString() vs concat vs template

Tests:

String()
let num = 500; let nums = []; for(let i = 0; i < 100; ++i) { nums.push(String(num)); }
.toString()
let num = 500; let nums = []; for(let i = 0; i < 100; ++i) { nums.push(num.toString()); }
concat
let num = 500; let nums = []; for(let i = 0; i < 100; ++i) { nums.push(num + ""); }
template
let num = 500; let nums = []; for(let i = 0; i < 100; ++i) { nums.push(`${num}`); }

Historical Performance Data aggregated from 30 community runs

Desktop Results:

Chrome 20 runs

concat

5.4M/s

template

5.3M/s

.toString()

1.6M/s

String()

849K/s

Fastest: concat (6.3x faster)

View exact numbers

✓ concat: 5,352,386 ops/sec
• template: 5,349,708 ops/sec
• .toString(): 1,604,912 ops/sec
• String(): 848,886 ops/sec

Firefox 10 runs

.toString()

4.1M/s

concat

3.8M/s

String()

3.6M/s

template

1.2M/s

Fastest: .toString() (3.5x faster)

View exact numbers

✓ .toString(): 4,139,128 ops/sec
• concat: 3,828,662 ops/sec
• String(): 3,614,190 ops/sec
• template: 1,186,858 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
String()
.toString()
concat
template

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: yesterday)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:153.0) Gecko/20100101 Firefox/153.0

Browser/OS: Firefox 153 on Windows

View result in a separate tab

.toString()

4.0M/s

concat

3.9M/s

String()

3.8M/s

template

1.4M/s

View exact numbers

Test name	Executions per second
✓ .toString()	4,010,818 Ops/sec
concat	3,893,603 Ops/sec
String()	3,834,582 Ops/sec
template	1,362,244 Ops/sec

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

LLMs can make mistakes. Check important info.

I'd be happy to help break down the provided benchmark and explain what's being tested.

**Benchmark Definition**

The benchmark is designed to compare the performance of different approaches for converting a large number (500) to a string in JavaScript:

1. `String()`: Using the built-in `String()` function.
2. `.toString()`: Using the `toString()` method, which is another way to convert an object to a string.
3. `concat`: Concatenating strings using the `+` operator.
4. `template`: Using template literals (the `${}` syntax).

**Options Compared**

Each test case compares one specific approach against others, allowing users to see how different methods perform in this particular scenario.

* The first test case (`String()`) is compared to two other approaches: `.toString()` and `concat`.
* The second test case (`concat`) is compared to another two approaches: `.toString()` and `template`.
* The third test case (`template`) is the baseline, serving as a reference for comparison with the other three approaches.

**Pros and Cons**

Here's a brief overview of each approach:

1. **String()**: This method uses the built-in function specifically designed for converting values to strings. It's often fast and efficient.
	* Pros: Lightweight, easy to use, and widely supported.
	* Cons: May not be as flexible or powerful as other options.
2. `.toString()`**: The `toString()` method converts an object to a string using the implementation defined by its constructor. This can lead to unexpected behavior if the object has custom methods that get called during conversion.
	* Pros: Can be useful for objects with custom string representations.
	* Cons: May not always produce the desired output, and can be slower than built-in `String()` due to potential method calls.
3. **concat**: Concatenating strings using the `+` operator is a simple but less efficient approach. It creates temporary intermediate strings and copies data between them.
	* Pros: Easy to understand and use.
	* Cons: Creates unnecessary objects and can be slow for large datasets.
4. **template**: Template literals (the `${}` syntax) provide a more modern and flexible way to convert values to strings. They allow for multi-line strings, interpolation, and even arbitrary expressions inside the string.
	* Pros: Powerful, readable, and efficient.
	* Cons: Requires support for template literals in older browsers or environments.

**Library and Special JS Features**

The benchmark uses no specific libraries, but it does utilize a syntax feature that might not be familiar to all developers:

1. **Template Literals**: Template literals are a relatively new feature introduced in ECMAScript 2015 (ES6). They allow for more readable string interpolation using the `${}` syntax.

**Other Alternatives**

If you want to explore alternative approaches, consider these options:

1. **Internationalization API**: You can use the `Intl` object and its `NumberFormat` interface to format numbers as strings with locale-specific formatting.
2. **Array methods**: For creating an array of string values, you could use methods like `map()`, `forEach()`, or even `reduce()` instead of a simple loop.

Keep in mind that these alternatives might have different performance characteristics, depending on the specific use case and requirements.

String() vs .toString() vs concat vs template (version: 0)

Comparing performance of: `String() vs .toString() vs concat vs template`

Created: 3 years ago by: Guest

Go to the latest result

String()

.toString()

concat

template

Historical Performance Data aggregated from 30 community runs

Desktop Results:

Chrome 20 runs

Firefox 10 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

String() vs .toString() vs concat vs template (version: 0)

Comparing performance of: String() vs .toString() vs concat vs template

Created: 3 years ago by: Guest

Go to the latest result

String()

.toString()

concat

template

Historical Performance Data aggregated from 30 community runs

Desktop Results:

Chrome 20 runs

Firefox 10 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `String() vs .toString() vs concat vs template`