Benchmark: String(num) vs num.toString() vs ""+num

Tests:

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
String(num)
num.toString()
""+num

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.61 Safari/537.36

Browser/OS: Chrome 94 on Windows

View result in a separate tab

Test name	Executions per second
String(num)	48508.2 Ops/sec
num.toString()	671344.8 Ops/sec
""+num	1936634.6 Ops/sec

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

LLMs can make mistakes. Check important info.

The provided JSON represents a JavaScript microbenchmark test case on the MeasureThat.net website.

**Benchmark Definition:**

The benchmark defines three variations of creating strings in JavaScript:

1. `String(num)`: Using the `String()` constructor to convert a number to a string.
2. `num.toString()`: Calling the `toString()` method directly on a number.
3. `"\"+num" (Template literals): Using template literals with backticks (`) to concatenate a string and a number.

**Options Compared:**

The benchmark compares the performance of these three approaches:

Pros and Cons:

* **String(num)**:
	+ Pros: Creates a new string object, which can be useful if you need to manipulate or store the string.
	+ Cons: Can be slower due to the overhead of creating a new object.
* **num.toString()**:
	+ Pros: Calling `toString()` on a number is a built-in method that returns a primitive value, making it faster than creating a new object.
	+ Cons: Returns a primitive value, which may not be desirable if you need to manipulate the string as an object.
* `"\"+num"` (Template literals):
	+ Pros: Creates a new string by concatenating the template literal with the number, and is generally faster than using `String()` or `toString()`.
	+ Cons: Limited support in older browsers, and may not be desirable if you need to work with primitive values.

**Library/Language Features Used:**

None are explicitly mentioned in this benchmark. However, it's worth noting that template literals (the `"\"+num"` approach) were introduced in ECMAScript 2015 (ES6).

**Special JS Feature/Syntax Used:**

Template literals (`"\"+num"`). While not a special feature per se, they are a relatively recent addition to the JavaScript language.

**Other Considerations:**

The benchmark measures the performance of these approaches on a specific test case, where 100 iterations are performed with a large number (500) being converted and stored in an array. The results should be taken as representative of this specific scenario, rather than a general comparison of all string creation methods in JavaScript.

**Alternatives:**

If you're interested in exploring other approaches to creating strings in JavaScript, consider:

* Using the `StringBuilder` class from the `util` module (Node.js-specific).
* Implementing a simple string builder class yourself.
* Using a library like `string-pool` for more efficient string creation.

Keep in mind that these alternatives may have their own trade-offs and may not be as performant as the approaches tested in this benchmark.

Related benchmarks:

String(num) vs num.toString() vs ""+num (version: 0)

Comparing performance of: String(num) vs num.toString() vs ""+num

Created: 3 years ago by: Guest

Jump to the latest result

String(num)

num.toString()

""+num

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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