Benchmark: Number vs + vs parseFloat vs parseInt

Tests:

Number
let number = Number(Math.random().toString());
Unary +
let unary = +Math.random().toString();
parseFloat
let parse = parseFloat(Math.random().toString());
parseInt
let parse = parseInt(Math.random().toString());

Historical Performance Data aggregated from 75 community runs

Desktop Results:

Chrome 64 runs

Unary +

4.8M/s

parseInt

4.6M/s

parseFloat

4.1M/s

Number

4.0M/s

Fastest: Unary + (1.2x faster)

View exact numbers

✓ Unary +: 4,783,781 ops/sec
• parseInt: 4,566,700 ops/sec
• parseFloat: 4,050,352 ops/sec
• Number: 4,002,904 ops/sec

Firefox 11 runs

parseInt

568.1M/s

Unary +

4.6M/s

Number

4.6M/s

parseFloat

4.4M/s

Fastest: parseInt (128.8x faster)

View exact numbers

✓ parseInt: 568,072,576 ops/sec
• Unary +: 4,618,406 ops/sec
• Number: 4,550,124 ops/sec
• parseFloat: 4,411,436 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
Unary +
parseFloat
parseInt

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:151.0) Gecko/20100101 Firefox/151.0

Browser/OS: Firefox 151 on Windows

View result in a separate tab

parseInt

28.7M/s

Unary +

7.1M/s

Number

7.1M/s

parseFloat

7.1M/s

View exact numbers

Test name	Executions per second
✓ parseInt	28,743,944 Ops/sec
Unary +	7,147,196 Ops/sec
Number	7,131,533 Ops/sec
parseFloat	7,106,326 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark is designed to test the performance of different numerical value creation methods in JavaScript: `Number`, unary `+`, `parseFloat`, and `parseInt`. The goal is to compare the execution speed of these methods.

**Options Compared**

The four options being compared are:

1. **`Number`**: Creates a number from a string using the built-in `Number` function.
2. **Unary `+`**: Uses the unary `+` operator to create a number from a string (e.g., `+Math.random().toString()`).
3. **`parseFloat`**: Creates a floating-point number from a string using the `parseFloat` function.
4. **`parseInt`**: Creates an integer from a string using the `parseInt` function.

**Pros and Cons of Each Approach**

1. **`Number`**:
	* Pros: Simple, widely supported, and fast (usually).
	* Cons: May not work correctly with non-numeric strings or NaN inputs.
2. **Unary `+`**:
	* Pros: Fast, widely supported, and works well with most numeric strings.
	* Cons: Can be slower than other methods for very large numbers due to the string conversion overhead.
3. **`parseFloat`**:
	* Pros: More accurate than `Number` for floating-point values, handles NaN inputs better.
	* Cons: May be slower than `Number` or unary `+` due to the parsing logic.
4. **`parseInt`**:
	* Pros: Fast and efficient for integer creation, can handle numeric prefixes (e.g., "0123").
	* Cons: May not work correctly with non-numeric strings or NaN inputs.

**Library Usage**

None of the individual test cases use a library beyond the built-in JavaScript functions (`Number`, `parseFloat`, and `parseInt`).

**Special JS Feature or Syntax**

The benchmark uses a simple, feature-rich syntax:

1. **`Math.random().toString()`**: Generates a random string representation of a number, which is then passed to the numerical creation methods.
2. **Unary `+`**: The unary `+` operator is used to convert the string to a number.

**Other Considerations**

The benchmark's use of random strings and the focus on execution speed make it suitable for comparing performance characteristics of these numerical creation methods. However, keep in mind that this benchmark only tests the JavaScript engine's performance on specific inputs and may not accurately represent real-world usage scenarios.

In terms of alternatives, other benchmarks might test different aspects of numerical value creation, such as precision, rounding mode, or handling edge cases like infinity and NaN values.

Number vs + vs parseFloat vs parseInt (version: 0)

Comparing performance of: `Number vs Unary + vs parseFloat vs parseInt`

Created: 5 years ago by: Guest

Go to the latest result

Number

Unary +

parseFloat

parseInt

Historical Performance Data aggregated from 75 community runs

Desktop Results:

Chrome 64 runs

Firefox 11 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Number vs + vs parseFloat vs parseInt (version: 0)

Comparing performance of: Number vs Unary + vs parseFloat vs parseInt

Created: 5 years ago by: Guest

Go to the latest result

Number

Unary +

parseFloat

parseInt

Historical Performance Data aggregated from 75 community runs

Desktop Results:

Chrome 64 runs

Firefox 11 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 Unary + vs parseFloat vs parseInt`