Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
parseInt vs Number vs plus
(version: 0)
Comparing performance of:
plus vs parseInt vs Number
Created:
4 years ago
by:
Guest
Go to the latest result
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>
Run tests (3)
Previous results
Fork
Test case name
Result
plus
parseInt
Number
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
one year 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
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=568901" width="100%" height="500px"></iframe>
plus
8.9M/s
parseInt
5.6M/s
Number
5.1M/s
View exact numbers
Test name
Executions per second
✓
plus
8,870,430 Ops/sec
parseInt
5,648,142 Ops/sec
Number
5,085,882 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
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 addition
parseInt vs Number parsing
parseInt vs Number vs implicit conversion
Comments
Confirm delete:
Do you really want to delete benchmark?