Benchmark: parseInt vs parseFloat vs number vs multiply vs +

Script Preparation code:

var strB = "42";

Tests:

ParseInt
var res =parseInt(strB);
Number
var res =Number(strB);
+
var res = +strB;
multiply
var res = strB * 1
parseFloat
var res =parseFloat(strB);

Historical Performance Data aggregated from 12 community runs

Desktop Results:

Chrome 7 runs

21.3M/s

multiply

21.0M/s

parseFloat

7.7M/s

Number

7.5M/s

ParseInt

7.0M/s

Fastest: + (3.0x faster)

View exact numbers

✓ +: 21,294,186 ops/sec
• multiply: 20,995,368 ops/sec
• parseFloat: 7,746,233 ops/sec
• Number: 7,522,042 ops/sec
• ParseInt: 7,004,614 ops/sec

Firefox 5 runs

Number

1050.3M/s

1040.8M/s

ParseInt

1037.0M/s

multiply

1030.1M/s

parseFloat

95.5M/s

Fastest: Number (11.0x faster)

View exact numbers

✓ Number: 1,050,276,352 ops/sec
• +: 1,040,788,288 ops/sec
• ParseInt: 1,036,999,296 ops/sec
• multiply: 1,030,075,264 ops/sec
• parseFloat: 95,475,912 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
ParseInt
Number
+
multiply
parseFloat

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 126 on Mac OS X 10.15.7

View result in a separate tab

28.0M/s

multiply

26.5M/s

ParseInt

10.8M/s

Number

10.7M/s

parseFloat

10.6M/s

View exact numbers

Test name	Executions per second
✓ +	27,966,088 Ops/sec
multiply	26,490,734 Ops/sec
ParseInt	10,752,385 Ops/sec
Number	10,718,670 Ops/sec
parseFloat	10,612,814 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested, compared, and their pros and cons.

**Benchmark Definition:**
The benchmark defines five test cases to compare the performance of different operations:

1. `parseInt(strB)`
2. `Number(strB)`
3. `+strB` (using the unary plus operator)
4. `strB * 1`
5. `parseFloat(strB)`

**Options Compared:**

The benchmark compares the performance of these five options on a string literal `"42"` assigned to the variable `strB`.

Here's what each option does:

* `parseInt(strB)` attempts to convert the string to an integer.
* `Number(strB)` attempts to convert the string to a number, which can be an integer or a float.
* `+strB` uses the unary plus operator to coerce the string to a number. This works because in JavaScript, `0 + "42"` is equivalent to `"42" * 1`.
* `strB * 1` multiplies the string by 1, which has no effect and returns the original string.
* `parseFloat(strB)` attempts to convert the string to a floating-point number.

**Pros and Cons:**

Here's a brief summary of each option:

* `parseInt(strB)`: Pros - simple and efficient for integer conversions. Cons - fails if the string is not a valid integer, which may lead to errors.
* `Number(strB)`: Pros - attempts to convert to a number, which can handle both integers and floats. Cons - slower than `parseInt` because it has to perform additional checks.
* `+strB`: Pros - efficient and works for strings that can be coerced to numbers. Cons - assumes the string is numeric and fails otherwise.
* `strB * 1`: Pros - no effect on the original string, returns the original value. Cons - slower than multiplication by a non-zero number because it creates an intermediate result.
* `parseFloat(strB)`: Pros - attempts to convert to a floating-point number, handles decimal strings. Cons - slower than `parseInt` and may fail if the string is not a valid float.

**Library:**
None of the options use any external libraries.

**Special JS Features or Syntax:**
The only notable feature used in this benchmark is the unary plus operator (`+strB`), which coerces the string to a number. This feature is widely supported in modern JavaScript engines and is often used for implicit conversion from strings to numbers.

**Alternative Approaches:**

If you wanted to write an alternative benchmark, you could consider adding more test cases, such as:

* Using `toString()` or `valueOf()` on the result of each operation
* Converting the string to a specific data type (e.g., boolean)
* Handling edge cases like empty strings or non-numeric characters

Keep in mind that the main goal of this benchmark is to compare the performance of different methods for converting strings to numbers, so it's essential to focus on those aspects.

By understanding the options compared and their pros and cons, you can make informed decisions about when to use each approach in your own JavaScript code.

parseInt vs parseFloat vs number vs multiply vs + (version: 0)

Comparing performance of: `ParseInt vs Number vs + vs multiply vs parseFloat`

Created: 5 years ago by: Guest

Go to the latest result

ParseInt

Number

+

multiply

parseFloat

Historical Performance Data aggregated from 12 community runs

Desktop Results:

Chrome 7 runs

Firefox 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):

parseInt vs parseFloat vs number vs multiply vs + (version: 0)

Comparing performance of: ParseInt vs Number vs + vs multiply vs parseFloat

Created: 5 years ago by: Guest

Go to the latest result

ParseInt

Number

+

multiply

parseFloat

Historical Performance Data aggregated from 12 community runs

Desktop Results:

Chrome 7 runs

Firefox 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: `ParseInt vs Number vs + vs multiply vs parseFloat`