Benchmark: Math.floor vs parseInt against number type

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>

Previous results

Test case name	Result
Math.floor
parseInt

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 17 days ago)

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

Browser/OS: Chrome 135 on Windows

View result in a separate tab

Test name	Executions per second
Math.floor	246384672.0 Ops/sec
parseInt	57070724.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 17 days ago):

LLMs can make mistakes. Check important info.

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:

Math.floor vs parseInt against number type (version: 1)

Comparing performance of: Math.floor vs parseInt

Created: 17 days ago by: Guest

Jump to the latest result

Math.floor

parseInt

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 17 days ago):