Benchmark: parseInt vs Number // toString vs 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
strNumbers.forEach(n => parseInt(n));
Number
strNumbers.forEach(n => Number(n));
toString
numbers.forEach(n => n.toString());
String
numbers.forEach(n => String(n));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
parseInt
Number
toString
String

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 11 days ago):

LLMs can make mistakes. Check important info.

Let's dive into the benchmark.

**Benchmark Definition**

The benchmark measures the performance of three different methods to convert numbers from strings:

1. `parseInt` (intended for parsing integers, but also works with strings)
2. `Number` (built-in JavaScript function to convert a string to a number)
3. `toString` (converting numbers to strings)

The test creates two arrays: `numbers` and `strNumbers`, containing numeric values and their string representations, respectively.

**Options Compared**

The benchmark compares the performance of each method on both arrays:

* `numbers.forEach(n => n.toString());` and `numbers.forEach(n => String(n));`
* `strNumbers.forEach(n => parseInt(n));` and `strNumbers.forEach(n => Number(n));`

These methods are compared in terms of execution speed, measured as "ExecutionsPerSecond".

**Pros and Cons**

Here's a brief summary of the pros and cons of each method:

1. **parseInt**: Pros:
	* Fastest execution ( highest ExecutionPerSecond)
	* Most JavaScript-like syntax
	* Can parse integers and strings with a radix parameter

Cons:
	* May throw errors if parsing fails or if the radix is not provided
	* Not as straightforward to use as `Number`
2. **Number**: Pros:
	* Simple and intuitive syntax
	* Works well for most numeric values

Cons:
	+ Can be slower than `parseInt` (lower ExecutionPerSecond)
3. **toString** / **String**: Pros:
	+ Fast execution (similar ExecutionPerSecond to `Number`)
	+ Works well for converting numbers to strings

Cons:
	+ Requires a call to the method (`n.toString()` or `String(n)`)
	+ Less JavaScript-like syntax compared to `parseInt`

**Other Considerations**

When choosing between these methods, consider the specific requirements of your use case:

* If you need to parse integers with optional radix, `parseInt` is a good choice.
* For simple conversions from strings to numbers, `Number` might be sufficient.
* When converting numbers to strings, either `toString` or `String` can work well.

**Library Usage**

None of the benchmark methods rely on external libraries. However, if you're using modern JavaScript features (e.g., arrow functions, destructuring), those libraries might not be necessary for this specific use case.

**Special JS Features**

The benchmark doesn't explicitly test any special JavaScript features or syntax, but it does use:

* Array methods (`forEach`)
* Arrow functions
* Property access syntax (`n.toString()`)

These are standard JavaScript features and don't require a deep understanding of the language to comprehend.

Latest run results:

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

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

Browser/OS: Chrome 126 on Windows

View result in a separate tab

Test name	Executions per second
parseInt	679142.8 Ops/sec
Number	728182.9 Ops/sec
toString	6599262.0 Ops/sec
String	779144.1 Ops/sec

Related benchmarks:

parseInt vs Number // toString vs String (version: 0)

Comparing performance of: parseInt vs Number vs toString vs String

Created: 3 years ago by: Guest

Jump to the latest result

parseInt

Number

toString

String

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 11 days ago):