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());

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: 7 days ago)

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

Browser/OS: Chrome 147 on Windows

View result in a separate tab

Test name	Executions per second
Number	9515148.0 Ops/sec
Unary +	9722142.0 Ops/sec
parseFloat	10121472.0 Ops/sec
parseInt	11611020.0 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.

Related benchmarks:

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

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

Created: 4 years ago by: Guest

Jump to the latest result

Number

Unary +

parseFloat

parseInt

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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