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

parseInt vs toString vs string literal vs + empty string vs String constructor (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 vs String constructor on a number vs String constructor on a string

Created: one year ago by: Guest

Jump to the latest result

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"];

AخA
 
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));
numbers.forEach(n => parseInt(n, 10));
parseInt a string
strNumbers.forEach(n => parseInt(n, 10));
strNumbers.forEach(n => parseInt(n, 10));
toString a number
numbers.forEach(n => n.toString());
numbers.forEach(n => n.toString());
toString a string
strNumbers.forEach(n => n.toString());
strNumbers.forEach(n => n.toString());
string literal a number
numbers.forEach(n => `${n}`);
numbers.forEach(n => `${n}`);
string literal a string
strNumbers.forEach(n => `${n}`);
strNumbers.forEach(n => `${n}`);
add empty string to number
numbers.forEach(n => n + "");
numbers.forEach(n => n + "");
add empty string to string
strNumbers.forEach(n => n + "");
strNumbers.forEach(n => n + "");
String constructor on a number
numbers.forEach(n => String(n));
numbers.forEach(n => String(n));
String constructor on a string
strNumbers.forEach(n => String(n));
strNumbers.forEach(n => String(n));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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
String constructor on a number
String constructor on a string

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 23 days ago)

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

Browser/OS: Chrome 133 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
parseInt a number	109923440.0 Ops/sec
parseInt a string	11348308.0 Ops/sec
toString a number	26995610.0 Ops/sec
toString a string	25914776.0 Ops/sec
string literal a number	109509896.0 Ops/sec
string literal a string	45735916.0 Ops/sec
add empty string to number	109673256.0 Ops/sec
add empty string to string	95952936.0 Ops/sec
String constructor on a number	20568506.0 Ops/sec
String constructor on a string	32321870.0 Ops/sec

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

Let's break down the benchmark and explain what is being tested.

Benchmark Overview

The benchmark measures the performance of various JavaScript operations on numbers and strings, specifically:

Converting numbers to integers using parseInt()
Converting numbers to strings using toString() or template literals (${n})
Adding an empty string to a number
Creating a string from a number using the String() constructor

Options Being Compared

There are four main options being compared:

A) parseInt(n, 10) (converting a string to an integer) B) n.toString() (converting a number to a string) C) ${n} (template literal with a number as its value) D) n + "" (adding an empty string to a number)

Pros and Cons of Each Approach

A) parseInt(n, 10):

Pros: Fast conversion from string to integer Cons: Can be slower than other approaches for large numbers or strings

B) n.toString():

Pros: Fast conversion from number to string Cons: May not work as expected for very large numbers due to string size limits

C) ${n} (template literal):

Pros: Fast and efficient way to create a string from a number Cons: Requires modern JavaScript engines that support template literals

D) n + "":

Pros: Simple and straightforward way to add an empty string to a number Cons: May be slower than other approaches due to the addition operation

Library Usage

There is no explicit library usage in this benchmark, but it's worth noting that some of these operations may rely on underlying libraries or engines.

Special JS Features/Syntax

The template literal syntax (${n}) is a modern JavaScript feature introduced in ECMAScript 2015. It allows embedding expressions inside string literals. The String() constructor and the addition operation (n + "") are standard JavaScript operators.

Other Alternatives

Some alternative approaches could be:

Using a library like parse-int or string-parser to convert numbers to integers
Using a function to create a string from a number, such as function toString(n) { return n.toString(); }
Using a different template literal syntax, such as ${n} + ""

However, these alternatives are not being tested in this benchmark.

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what is being tested.

**Benchmark Overview**

The benchmark measures the performance of various JavaScript operations on numbers and strings, specifically:

1. Converting numbers to integers using `parseInt()`
2. Converting numbers to strings using `toString()` or template literals (`${n}`)
3. Adding an empty string to a number
4. Creating a string from a number using the `String()` constructor

**Options Being Compared**

There are four main options being compared:

A) `parseInt(n, 10)` (converting a string to an integer)
B) `n.toString()` (converting a number to a string)
C) `${n}` (template literal with a number as its value)
D) `n + ""` (adding an empty string to a number)

**Pros and Cons of Each Approach**

A) `parseInt(n, 10)`:

Pros: Fast conversion from string to integer
Cons: Can be slower than other approaches for large numbers or strings

B) `n.toString()`:

Pros: Fast conversion from number to string
Cons: May not work as expected for very large numbers due to string size limits

C) `${n}` (template literal):

Pros: Fast and efficient way to create a string from a number
Cons: Requires modern JavaScript engines that support template literals

D) `n + ""`:

Pros: Simple and straightforward way to add an empty string to a number
Cons: May be slower than other approaches due to the addition operation

**Library Usage**

There is no explicit library usage in this benchmark, but it's worth noting that some of these operations may rely on underlying libraries or engines.

**Special JS Features/Syntax**

The template literal syntax (`${n}`) is a modern JavaScript feature introduced in ECMAScript 2015. It allows embedding expressions inside string literals. The `String()` constructor and the addition operation (`n + ""`) are standard JavaScript operators.

**Other Alternatives**

Some alternative approaches could be:

* Using a library like `parse-int` or `string-parser` to convert numbers to integers
* Using a function to create a string from a number, such as `function toString(n) { return n.toString(); }`
* Using a different template literal syntax, such as `${n} + ""`

However, these alternatives are not being tested in this benchmark.

Related benchmarks: