Benchmark: Trunc vs Floor vs Number vs ParseInt vs ~~ using time

Tests:

Trunc
Math.trunc((new Date()).getMinutes()/10.0);
Floor
Math.floor((new Date()).getMinutes()/10.0);
Number
Number((new Date()).getMinutes()/10.0);
ParseInt
parseInt((new Date()).getMinutes()/10.0);
Bitwise invert2
~~((new Date()).getMinutes()/10.0);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Trunc
Floor
Number
ParseInt
Bitwise invert2

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:132.0) Gecko/20100101 Firefox/132.0

Browser/OS: Firefox 132 on Windows

View result in a separate tab

Test name	Executions per second
Trunc	7019245.0 Ops/sec
Floor	7081973.0 Ops/sec
Number	6718807.5 Ops/sec
ParseInt	6824253.5 Ops/sec
Bitwise invert2	7092045.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

The benchmark in question compares five different methods of converting a number (specifically, the current minutes divided by 10) to its integer representation using JavaScript. The methods tested are:

1. **Math.trunc()**
2. **Math.floor()**
3. **Number()**
4. **parseInt()**
5. **Bitwise NOT operator (~~)**

### Method Comparisons

1. **Math.trunc()**
   - **Usage**: `Math.trunc(value)`
   - **Behavior**: Returns the integer part of a number by removing any fractional digits. It does not round up or down; it simply truncates.
   - **Pros**: Explicit intent to truncate makes the code easier to read.
   - **Cons**: Might not be as performant as bitwise operations (though performance is usually acceptable).

2. **Math.floor()**
   - **Usage**: `Math.floor(value)`
   - **Behavior**: Rounds down to the nearest integer. Useful for always rounding down, even for negative numbers.
   - **Pros**: Provides a clear semantic meaning when rounding is necessary.
   - **Cons**: Slightly slower than truncation if you only need to discard the fractional part.

3. **Number()**
   - **Usage**: `Number(value)`
   - **Behavior**: Converts the given value to a number but does not truncate or round—just converts. 
   - **Pros**: It's a versatile method for various types.
   - **Cons**: Does not provide any truncation functionality and is not specifically designed for this purpose.

4. **parseInt()**
   - **Usage**: `parseInt(value, base)`
   - **Behavior**: Parses a string argument and returns an integer, optionally given a base. When the input is a float, it will convert it to an integer by ignoring the decimal part.
   - **Pros**: Useful for parsing strings to integers, especially when dealing with different numeral systems.
   - **Cons**: Less efficient for numerical operations since it requires string conversion first and can be slower and error-prone if the input is not a string.

5. **Bitwise NOT operator (~~)**
   - **Usage**: `~~value`
   - **Behavior**: Applies the bitwise NOT operator twice, effectively converting the number to a 32-bit signed integer, which also truncates decimals.
   - **Pros**: Fastest method in terms of performance among these options due to low-level bitwise operations.
   - **Cons**: Less readable and clear than other methods, and it may cause issues when dealing with non-integer representations or out-of-range numbers due to JavaScript's handling of numbers.

### Performance Insights

The benchmark results indicate that the Bitwise NOT operator (`~~`) has the highest number of executions per second, followed closely by `Math.floor()` and `Math.trunc()`, whereas `parseInt()` and `Number()` are comparatively slower.

### Other Considerations

- **Readability vs. Performance**: When choosing between these methods, one should consider the trade-off between performance and code readability. While bitwise operations are faster, they can make the code harder to understand for others unfamiliar with such techniques.
- **Precision and Edge Cases**: While comparing these approaches, edge cases like very large or negative numbers should be taken into account, especially for `Math.floor()` and `~~`, which behave differently with negative values.
  
### Alternatives

While the methods presented are effective for integer conversion and truncation, there are alternative approaches in JavaScript, such as:

- **Using an integer casting function**: Creating a custom function that uses any of the methods discussed based on specific needs.
- **Handling Numbers with Libraries**: Libraries like `Math.js` can also provide additional mathematical capabilities and might simplify numerical operations significantly for complex applications.

In conclusion, this benchmark serves to illustrate different strategies for integer conversion in JavaScript and indicates that while performance is critical, clarity and maintainability of code are equally essential for long-term development practices.

Related benchmarks:

Trunc vs Floor vs Number vs ParseInt vs ~~ using time (version: 1)

Trunc vs Floor vs Number vs ParseInt vs ~~

Comparing performance of: Trunc vs Floor vs Number vs ParseInt vs Bitwise invert2

Created: one month ago by: Guest

Jump to the latest result

Trunc

Floor

Number

ParseInt

Bitwise invert2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):