Benchmark: parseInt vs Number vs plus

Script Preparation code:


var strB = "42.034";

Tests:

plus
var res = +strB;
parseInt
var res = parseInt(strB);
Number
var res = Number(strB);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
plus
parseInt
Number

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 130 on Android

View result in a separate tab

Test name	Executions per second
plus	8870430.0 Ops/sec
parseInt	5648142.0 Ops/sec
Number	5085881.5 Ops/sec

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

LLMs can make mistakes. Check important info.

I'd be happy to help you understand the benchmark.

**What is being tested?**

The provided JSON represents a JavaScript microbenchmark test case that compares three different ways to convert a string to a number: `parseInt`, `Number`, and the unary `+` operator (which is equivalent to `Math.floor` or `Number.parseInt(str, 10)`).

In this specific benchmark, the input string is `"42.034"`. The goal is to determine which method produces the fastest execution time.

**Options compared:**

The three options being compared are:

1. **Unary `+` operator (`plus`)**: This uses the unary `+` operator to convert the string to a number. It's equivalent to using `Math.floor` or `Number.parseInt(str, 10)`.
2. **`parseInt`**: This uses the built-in `parseInt` function to convert the string to an integer. The second argument (10 in this case) specifies the radix (base) of the input string.
3. **`Number`**: This uses the built-in `Number` function to convert the string to a number.

**Pros and Cons:**

* **Unary `+` operator (`plus`)**:
	+ Pros: Simple, efficient, and widely supported.
	+ Cons: May not work correctly with non-numeric strings or strings with decimal points (like `"42.034"`).
* **`parseInt`**:
	+ Pros: More robust than the unary `+` operator, as it can handle decimal points and non-numeric characters.
	+ Cons: May be slower due to the function call overhead.
* **`Number`**:
	+ Pros: Similar to `parseInt`, but with fewer function calls (one instead of two).
	+ Cons: May not work correctly with non-numeric strings or strings with decimal points.

**Other considerations:**

In JavaScript, when converting a string to a number, the engine will try to parse the string as an integer if possible. If the string contains a decimal point, it will be parsed as a float instead. This means that `parseInt` and `Number` may produce different results for the input string `"42.034"`, depending on how you expect the result to be treated (as an integer or a floating-point number).

**Library used:**

None.

**Special JS feature or syntax:**

No special features or syntax are mentioned in this benchmark.

Now, let's look at some alternative approaches:

* **Using `parseFloat`**: This function can also be used to convert a string to a float. However, it would not be a good candidate for this benchmark since it's slower than the unary `+` operator and `Number`.
* **Using regular expressions**: You could use regular expressions to extract numeric values from the input string, but this would likely be much slower than the current methods.
* **Using a custom implementation**: You could write your own function to convert strings to numbers using JavaScript's native data types. This might be an interesting benchmark, but it's unlikely to produce results that differ significantly from the existing methods.

Keep in mind that this benchmark is focused on comparing different ways to perform simple string-to-number conversions. The goal is to determine which method produces the fastest execution time for a specific input scenario.

Related benchmarks:

parseInt vs Number vs plus (version: 0)

Comparing performance of: plus vs parseInt vs Number

Created: 3 years ago by: Guest

Jump to the latest result

plus

parseInt

Number

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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