Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
Math.floor vs parseInt against number type
(version: 1)
Comparing performance of:
Math.floor vs parseInt
Created:
one year ago
by:
Guest
Go to the latest result
Script Preparation code:
let number = Math.random();
Tests:
Math.floor
let floor = Math.floor(number);
parseInt
let parse = parseInt(number);
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (2)
Previous results
Fork
Test case name
Result
Math.floor
parseInt
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
4 months ago
)
User agent:
Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:148.0) Gecko/20100101 Firefox/148.0
Browser/OS:
Firefox 148 on Mac OS X 10.15
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=626875" width="100%" height="500px"></iframe>
parseInt
1578.2M/s
Math.floor
1569.2M/s
View exact numbers
Test name
Executions per second
✓
parseInt
1,578,186,368 Ops/sec
Math.floor
1,569,249,024 Ops/sec
Autogenerated LLM Summary
(model
gpt-4o-mini
, generated one year ago):
The benchmark you're looking at compares the performance of two different JavaScript functions: `Math.floor` and `parseInt`, specifically focusing on how they handle numerical input in JavaScript. ### Options Compared 1. **Math.floor(number)**: - This function takes a number (or a numeric expression) and rounds it down to the nearest integer. It is designed to work with valid numerical types and does not attempt to coerce strings or other types to numbers. 2. **parseInt(number)**: - This function is used to parse a string and returns an integer of the specified radix (base). However, if passed a number directly (as in this benchmark), it will first convert the number to a string and will attempt to parse it. For instance, it will only convert until it encounters a non-numeric character. This can lead to unexpected results if the input isn't strictly a numeric string. ### Performance Results From the benchmark results: - **Math.floor** had an execution rate of approximately 246,384,672 executions per second. - **parseInt** had a significantly lower execution rate of about 57,070,724 executions per second. ### Pros and Cons #### Math.floor **Pros**: - More straightforward and faster in execution since it is specifically designed to round down numbers. - Designed for numeric types, thus eliminating any ambiguity regarding input types. **Cons**: - Limited functionality to only rounding down; may not be applicable in scenarios where parsing strings into integers is necessary. #### parseInt **Pros**: - More versatile as it can parse strings and interpret them as integers. - Allows you to specify the base for parsing (for example, binary, hexadecimal, etc.). **Cons**: - Slower performance demonstrated in this benchmark indicates that it incurs a higher computational cost. - Might lead to unexpected results if used with non-numeric strings, as it stops parsing upon encountering a non-numeric character. - Requires additional consideration for base and NaN results for invalid inputs. ### Considerations When deciding between `Math.floor` and `parseInt`, you should consider: - The type of input you expect (strings vs. numbers). - The performance requirements of your application—if speed is a crucial factor, `Math.floor` is the clear winner based on this test. - Clarity and intention of your code—using functions that align closely with your input data types can improve code maintainability and reduce bugs. ### Alternatives 1. **Math.round**: If rounding to the nearest integer is acceptable, you can consider using `Math.round`, which will round to the nearest whole number (up or down based on the fractional part). 2. **Math.ceil**: If you need to round up instead of down, `Math.ceil` is appropriate. 3. **Number()**: If you're primarily dealing with string inputs and you want to convert them to numbers, using `Number()` can be beneficial; however, it behaves differently than `parseInt` in that it converts the entire string into a number or returns `NaN`. 4. **Bitwise Operators**: Using bitwise operators (like `number | 0`) can also convert a number to an integer quickly but may produce unexpected results with non-integer inputs. Each of these alternatives has its specific use cases, and your choice should depend on the context of your application and the types of inputs you expect.
Related benchmarks
Number vs + vs parseInt
parseInt vs Math.trunc
Number vs + vs parseFloat vs parseInt
Number.parseFloat vs parseFloat
Math.floor Vs parseInt (random and fixed)
Comments
Confirm delete:
Do you really want to delete benchmark?