Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
Number vs + vs parseFloat + eval
(version: 0)
Comparing performance of:
Number vs Unary + vs parseFloat vs Eval
Created:
2 years ago
by:
Guest
Go to the latest result
Tests:
Number
var number = Number(Math.random().toFixed(2));
Unary +
var unary = +Math.random().toFixed(2);
parseFloat
var parse = parseFloat(Math.random().toFixed(2));
Eval
var eval1 = eval(Math.random().toFixed(2));
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (4)
Previous results
Fork
Test case name
Result
Number
Unary +
parseFloat
Eval
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/122.0.0.0 Safari/537.36
Browser/OS:
Chrome 122 on Mac OS X 10.15.7
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=512928" width="100%" height="500px"></iframe>
Unary +
5.8M/s
parseFloat
4.7M/s
Number
4.5M/s
Eval
3.2M/s
View exact numbers
Test name
Executions per second
✓
Unary +
5,782,326 Ops/sec
parseFloat
4,659,840 Ops/sec
Number
4,474,322 Ops/sec
Eval
3,218,631 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
Let's break down the provided benchmark and its components. **What is tested:** The benchmark tests four different approaches to convert a string representation of a number from `Math.random().toFixed(2)`: 1. **Number**: Uses the built-in JavaScript function `Number()` to parse the string. 2. **Unary +**: Uses the unary `+` operator to convert the string. 3. **parseFloat**: Uses the `parseFloat()` function to parse the string. 4. **Eval**: Uses the `eval()` function to execute a script that converts the string. **Options compared:** The benchmark compares the performance of these four approaches: * **Number**: Directly uses the built-in JavaScript function to convert the string. * **Unary +**: Uses the unary `+` operator, which can be seen as equivalent to calling `Number()`, but is more efficient due to a historical reason (more on this later). * **parseFloat**: Uses a separate function to parse the string. * **Eval**: Uses a separate function to execute a script that converts the string. **Pros and Cons:** 1. **Number**: * Pros: Directly uses the built-in JavaScript function, which is likely optimized for performance. * Cons: May not be as efficient due to overhead of calling a function. 2. **Unary +**: (Historical reason) The unary `+` operator was introduced in older versions of JavaScript and was meant to be more efficient than calling `Number()`. However, modern JavaScript engines have optimized the behavior of both approaches, making them comparable. This approach is still used for compatibility reasons or when direct function calls are not possible. * Pros: More efficient due to reduced overhead compared to calling a separate function. * Cons: May seem less efficient at first glance due to its historical context. 3. **parseFloat**: * Pros: Separates the parsing logic from the conversion, which might improve performance in certain scenarios. * Cons: Requires an extra function call, which can add overhead. 4. **Eval**: (Not recommended) * Pros: None, as using `eval()` can be a security risk if not used carefully due to its ability to execute arbitrary JavaScript code. * Cons: Significantly slower than the other approaches due to its dynamic nature and potential for malicious input. **Library/Function:** The benchmark uses several built-in JavaScript functions: * **Number()**: A built-in function that parses a string as a number. * **parseFloat()**: A built-in function that parses a string as a floating-point number. These functions are optimized for performance and security, making them suitable choices in most cases. **Special JS feature/Syntax:** The benchmark does not require any special JavaScript features or syntax beyond what's required to run the tests. The use of `eval()` is generally discouraged due to potential security risks, but it's used here to illustrate its behavior in a controlled environment. I hope this explanation helps! Let me know if you have further questions.
Related benchmarks
Implicit vs parseInt vs Number string to num
Implicit vs parseFloat vs Number string to num
Comments
Confirm delete:
Do you really want to delete benchmark?