Benchmark: parseInt vs toString vs string literal vs + empty string

Script Preparation code:

var numbers = [1, 12, 123, 1234, 12345, 123456, 1234567, 12345678, 123456789];
var strNumbers = ["1", "12", "123", "1234", "12345", "123456", "1234567", "12345678", "123456789"];

Tests:

parseInt a number
numbers.forEach(n => parseInt(n, 10));
parseInt a string
strNumbers.forEach(n => parseInt(n, 10));
toString a number
numbers.forEach(n => n.toString());
toString a string
strNumbers.forEach(n => n.toString());
string literal a number
numbers.forEach(n => `${n}`);
string literal a string
strNumbers.forEach(n => `${n}`);
add empty string to number
numbers.forEach(n => n + "");
add empty string to string
strNumbers.forEach(n => n + "");

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
parseInt a number
parseInt a string
toString a number
toString a string
string literal a number
string literal a string
add empty string to number
add empty string to string

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the details of what's being tested in this benchmark.

**Benchmark Definition**

The benchmark is designed to compare the performance of different approaches for converting numbers and strings between their numeric and string representations.

**Options Compared**

1. `parseInt(n, 10)`: This function converts a string representation of a number to its numeric equivalent.
2. `n.toString()`: This method converts a number to its string representation.
3. String literal concatenation: `n + ""` (or `"${n}"` in some JavaScript versions)
4. String concatenation with empty string: `n + ""`

**Pros and Cons**

* `parseInt(n, 10)`: Pros:
	+ Fast, as it uses a built-in function to perform the conversion.
	+ Robust, as it can handle a wide range of input formats.
Cons:
	+ May fail if the input is not a valid number string.
	+ Requires an optional second argument (base 10 in this case) to specify the radix.
* `n.toString()`: Pros:
	+ Fast, as it uses a built-in method to perform the conversion.
	+ Robust, as it can handle most numeric and string inputs.
Cons:
	+ May not be suitable for all use cases, such as converting numbers with decimal points or scientific notation.
	+ May require additional processing steps to handle edge cases.
* String literal concatenation: Pros:
	+ Simple and straightforward, as it only requires a single operator (`+`).
	+ Works well for most numeric inputs.
Cons:
	+ May not be suitable for string inputs that contain non-numeric characters.
	+ Can lead to slower performance due to the overhead of creating a new string object.
* String concatenation with empty string: Pros:
	+ Similar to string literal concatenation, but may be slightly faster due to caching effects.
Cons:
	+ May not be suitable for all use cases, such as converting numbers or strings that contain non-numeric characters.

**Library**

None of the options in this benchmark rely on external libraries. However, it's worth noting that some JavaScript engines and platforms (such as some Node.js implementations) may have built-in optimizations or special handling for certain numeric and string conversions.

**Special JS Features/Syntax**

This benchmark does not use any special JavaScript features or syntax beyond what is standard in the language. It only relies on basic arithmetic operators, method calls, and string concatenation.

**Other Alternatives**

If you were to design an alternative benchmark with different options, you might consider exploring other approaches, such as:

1. Converting numbers between different numeric formats (e.g., binary, hexadecimal).
2. Comparing the performance of different algorithms for numerical computations (e.g., linear algebra, random number generation).
3. Evaluating the efficiency of various data structures and algorithms for handling large datasets.

However, keep in mind that any alternative benchmark would need to be designed with careful consideration of the specific requirements and constraints of the problem domain, as well as the target audience and use cases for the benchmark.

Latest run results:

Run details: (Test run date: 2 months ago)

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

Browser/OS: Chrome 128 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
parseInt a number	1851577.4 Ops/sec
parseInt a string	1590688.2 Ops/sec
toString a number	14837847.0 Ops/sec
toString a string	14394832.0 Ops/sec
string literal a number	28242462.0 Ops/sec
string literal a string	19633814.0 Ops/sec
add empty string to number	27736540.0 Ops/sec
add empty string to string	25903146.0 Ops/sec

Related benchmarks:

parseInt vs toString vs string literal vs + empty string (version: 0)

Comparing performance of: parseInt a number vs parseInt a string vs toString a number vs toString a string vs string literal a number vs string literal a string vs add empty string to number vs add empty string to string

Created: 4 years ago by: Guest

Jump to the latest result

parseInt a number

parseInt a string

toString a number

toString a string

string literal a number

string literal a string

add empty string to number

add empty string to 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):