Benchmark: Compare the ways to convert String to Number in JS

Script Preparation code:

const minimum = 1
const maximum = 1000
var arr = Array.from({ length: 1000000 }, () => Math.floor(Math.random() * (maximum - minimum + 1)) + minimum)

Tests:

Number
return arr.map((el) => Number(el))
parseInt
return arr.map((el) => parseInt(el))
>>0
return arr.map((el) => el >> 0)
*1
return arr.map((el) => el * 1)
~~
return arr.map((el) => ~~el)
+
return arr.map((el) => +el)

Historical Performance Data aggregated from 34 community runs

Desktop Results:

Chrome 18 runs

>>0

69/s

68/s

parseInt

62/s

Number

51/s

Fastest: >>0 (1.3x faster)

View exact numbers

✓ >>0: 69 ops/sec
• *1: 69 ops/sec
• ~~: 69 ops/sec
• +: 68 ops/sec
• parseInt: 62 ops/sec
• Number: 51 ops/sec

Firefox 11 runs

110/s

>>0

108/s

parseInt

83/s

Number

57/s

Fastest: + (1.9x faster)

View exact numbers

✓ +: 110 ops/sec
• *1: 110 ops/sec
• >>0: 108 ops/sec
• ~~: 108 ops/sec
• parseInt: 83 ops/sec
• Number: 57 ops/sec

Other 5 runs

125/s

124/s

>>0

124/s

119/s

Number

12/s

parseInt

12/s

Fastest: *1 (10.3x faster)

View exact numbers

✓ *1: 125 ops/sec
• +: 124 ops/sec
• >>0: 124 ops/sec
• ~~: 119 ops/sec
• Number: 12 ops/sec
• parseInt: 12 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Number
parseInt
>>0
*1
~~
+

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 150 on Windows

View result in a separate tab

>>0

119/s

118/s

115/s

Number

112/s

parseInt

111/s

View exact numbers

Test name	Executions per second
✓ >>0	119 Ops/sec
*1	118 Ops/sec
+	115 Ops/sec
~~	115 Ops/sec
Number	112 Ops/sec
parseInt	111 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided benchmark compares the ways to convert strings to numbers in JavaScript.

**Benchmark Definition**

The benchmark definition json provides a basic structure for the test, which includes:

* `Name`: The name of the benchmark.
* `Description`: A brief description of the benchmark.
* `Script Preparation Code`: The code that prepares the data used in the benchmark. In this case, it generates an array of 1 million random integers between 1 and 1000.
* `Html Preparation Code`: Not used in this benchmark.

**Individual Test Cases**

The individual test cases are defined by multiple json objects, each representing a different way to convert strings to numbers:

* `Number()`: Uses the built-in `Number()` function to convert strings to numbers.
* `parseInt()`: Uses the `parseInt()` function to convert strings to numbers. Note that this will truncate any decimal part of the number.
* `>> 0` (bit shift): Uses the bit shift operator (`>>`) to convert a string to an integer by shifting the bits to the right and then casting it back to an integer.
* `*1`: Multiplies the string by 1, effectively converting it to a number. This works because in JavaScript, multiplying any value by 0 returns 0, so multiplying by 1 has no effect.
* `~~` (integer sign): Uses the bitwise NOT operator (`~`) and then takes the absolute value of the result with `Math.abs()`. However, since this does not cover all edge cases (like `-0`), it is considered slower than `parseInt`.
* `+`: Concatenates two strings together and then converts the resulting string to a number using the unary plus operator (`+`). This is a very slow way to convert strings to numbers.

**Library Usage**

None of these test cases use any libraries.

**Special JS Features/Syntax**

The following special JavaScript features/syntax are used in some of the test cases:

* `>> 0`: A bit shift operator that can be confusing to those not familiar with bitwise operations.
* `~~`: The integer sign operator, which is a less common feature and may not be supported by all browsers or environments.

**Pros and Cons**

Here's a summary of the pros and cons for each approach:

* `Number()`, `parseInt()`, and `+` are built-in functions that provide fast and reliable conversions. They have no significant downsides.
* `>> 0`: This is a clever way to convert strings to integers, but it relies on bitwise operations, which may be slower than the others. It also assumes that the string can be converted directly to an integer without fractional part.
* `*1` is a quick fix, but it doesn't work well for negative numbers or strings containing decimal parts.
* `~~`: While this might seem like a good idea, it's not reliable and will fail with certain edge cases. It's generally slower than the other methods.

**Other Alternatives**

Some alternative methods to convert strings to numbers could be used, such as:

* Using a regular expression to extract numerical characters from the string.
* Using a library like `json` or `number-expr` that provides functions for parsing and converting strings to numbers.
* Using a language-specific function like `python's int()`.

However, these alternatives are likely to be slower and less portable than the methods tested in this benchmark.

Compare the ways to convert String to Number in JS (version: 0) Benchmark.js

Compare the most popular ways to convert string to number

Comparing performance of: `Number vs parseInt vs >>0 vs *1 vs ~~ vs +`

Created: 2 years ago by: Guest

Go to the latest result

Number

parseInt

>>0

*1

~~

+

Historical Performance Data aggregated from 34 community runs

Desktop Results:

Chrome 18 runs

Firefox 11 runs

Other 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Compare the ways to convert String to Number in JS (version: 0) Benchmark.js

Compare the most popular ways to convert string to number

Comparing performance of: Number vs parseInt vs >>0 vs *1 vs ~~ vs +

Created: 2 years ago by: Guest

Go to the latest result

Number

parseInt

>>0

*1

~~

+

Historical Performance Data aggregated from 34 community runs

Desktop Results:

Chrome 18 runs

Firefox 11 runs

Other 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `Number vs parseInt vs >>0 vs *1 vs ~~ vs +`