Benchmark: String() vs .toString() vs plus empty string

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()); }
plus empty string
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()
.toString()
plus empty string

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 114 on Windows

View result in a separate tab

Test name	Executions per second
String()	74062.4 Ops/sec
.toString()	1049564.1 Ops/sec
plus empty string	2955134.5 Ops/sec

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

LLMs can make mistakes. Check important info.

**What is being tested?**

MeasureThat.net is testing the performance of three different ways to convert a number to a string in JavaScript: using the `String()` function, calling the `toString()` method on the number itself (`num.toString()`), and concatenating an empty string (`+ ''`).

**Options compared**

The three options are being compared in terms of their execution time. The benchmark is measuring how many executions per second each option can handle.

**Pros and Cons of each approach:**

1. **String() function**: This method creates a new string object using the `String()` function, which involves creating an intermediate object before converting it to a string.
	* Pros: Can be useful when you need to perform additional operations on the resulting string (e.g., formatting).
	* Cons: Creates an intermediate object, which can increase memory usage and potentially slow down performance.
2. **toString() method**: This method calls the `toString()` method directly on the number itself, which is a built-in method that converts numbers to strings.
	* Pros: Fast and efficient, as it avoids creating an intermediate object.
	* Cons: May not work correctly with non-numeric values (e.g., NaN).
3. **Concatenating an empty string (`+ ''`)**: This method uses the `+` operator to concatenate an empty string with the number, effectively converting the number to a string.
	* Pros: Simple and easy to understand, but may be slower than other methods due to the overhead of concatenation.
	* Cons: May not work correctly with non-numeric values (e.g., NaN).

**Library usage**

None of the provided benchmark cases uses any external libraries.

**Special JavaScript features or syntax**

The benchmark cases use a simple `for` loop and array push method (`nums.push(...)`) to test each option. No special JavaScript features or syntax are used.

**Other alternatives**

There may be other ways to convert numbers to strings in JavaScript, such as using template literals (e.g., `num.toString()` with template literals) or the `Number.prototype.toString()` method. However, these alternatives are not being tested in this benchmark.

In general, when converting numbers to strings, it's essential to consider performance and potential edge cases (e.g., non-numeric values). The choice of method ultimately depends on the specific requirements and constraints of your application.

Related benchmarks:

String() vs .toString() vs plus empty string (version: 0)

Comparing performance of: String() vs .toString() vs plus empty string

Created: one year ago by: Guest

Jump to the latest result

String()

.toString()

plus empty string

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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