Benchmark: * 10, round vs trunc vs floor vs parseFloat vs ~~ vs 0 | vs parseInt vs parseInt, 10 loop

Script Preparation code:

var count = 1000;

Tests:

trunc
for (var i = 0; i < count; i++) { Math.trunc(12.34 * 10); Math.trunc(567.89 * 10); }
round
for (var i = 0; i < count; i++) { Math.round(12.34 * 10); Math.round(567.89 * 10); }
floor
for (var i = 0; i < count; i++) { Math.floor(12.34 * 10); Math.floor(567.89 * 10); }
parseFloat to int
for (var i = 0; i < count; i++) { parseFloat((12.34 * 10).toFixed()); parseFloat((567.89 * 10).toFixed()); }
~~
for (var i = 0; i < count; i++) { ~~(12.34 * 10); ~~(567.89 * 10); }
|0
for (var i = 0; i < count; i++) { (12.34 * 10 |0); (567.89 * 10 |0); }
parseInt
for (var i = 0; i < count; i++) { parseInt(12.34 * 10); parseInt(567.89 * 10); }
parseInt, 10
for (var i = 0; i < count; i++) { parseInt(12.34 * 10, 10); parseInt(567.89 * 10, 10); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
trunc
round
floor
parseFloat to int
~~
\|0
parseInt
parseInt, 10

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 11 months ago)

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

Browser/OS: Firefox 123 on Windows

View result in a separate tab

Test name	Executions per second
trunc	3857105.2 Ops/sec
round	3845987.2 Ops/sec
floor	3858572.5 Ops/sec
parseFloat to int	11734.7 Ops/sec
~~	3888677.5 Ops/sec
\|0	3912829.8 Ops/sec
parseInt	3732859.0 Ops/sec
parseInt, 10	3873018.2 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 2 months ago):

LLMs can make mistakes. Check important info.

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks, providing insights into the performance of various functions in different browsers.

The benchmark being discussed uses six different functions to convert a floating-point number to an integer:

1. `Math.trunc()`
2. `Math.round()`
3. `Math.floor()`
4. `parseFloat()` with `.toFixed()` (which is essentially equivalent to `parseInt()` with a radix of 10)
5. The bitwise AND operator (`|`) followed by `0` (which is equivalent to `parseInt()` with a radix of 10)
6. The bitwise NOT operator (`~~`) followed by the value itself (which is not a standard JavaScript function, but is used as an alternative in this benchmark)

Let's break down each function and their pros and cons:

**1. Math.trunc()**

* Purpose: Returns the largest integer less than or equal to the input number.
* Pros: Fast and efficient, suitable for most use cases.
* Cons: May not be accurate if the input is a negative number (since it returns the largest integer less than or equal to the input).

**2. Math.round()**

* Purpose: Returns the closest integer to the input number.
* Pros: Suitable for use cases where rounding is required, such as financial calculations.
* Cons: May not be accurate if the input is a very large or small number.

**3. Math.floor()**

* Purpose: Returns the largest integer less than or equal to the input number.
* Pros: Similar to `Math.trunc()`, but may not be as efficient in some cases.
* Cons: May not be accurate if the input is a negative number (since it returns the largest integer less than or equal to the input).

**4. parseFloat() with .toFixed()**

* Purpose: Converts a string representation of a number to a float, and then converts that float to an integer using `.toFixed()`.
* Pros: Suitable for use cases where the input is a string representation of a number.
* Cons: May not be as efficient as other methods, since it involves converting between strings and numbers.

**5. `|` followed by 0**

* Purpose: Uses the bitwise AND operator to extract the integer part of the input number, followed by `0`.
* Pros: Fast and efficient, suitable for most use cases.
* Cons: May not be as readable or intuitive as other methods.

**6. ~~ (bitwise NOT) with value itself**

* Purpose: Not a standard JavaScript function, but used in this benchmark to provide an alternative method.
* Pros: None.
* Cons: Not suitable for general use, since it relies on bitwise operations that may not be supported by all browsers or systems.

The results of the benchmark show that `Math.trunc()` and `|` followed by 0 are the fastest methods, while `parseFloat()` with `.toFixed()` is significantly slower. The order of performance is:

1. `Math.trunc()`
2. `|` followed by 0
3. `Math.floor()`
4. `Math.round()`
5. `parseInt()` (with radix 10)
6. `parseFloat()` with `.toFixed()`

Note that the performance results may vary depending on the specific browser and system being used.

Related benchmarks:

* 10, round vs trunc vs floor vs parseFloat vs ~~ vs 0 | vs parseInt vs parseInt, 10 loop (version: 0)

fastest from float to int with multiplication

Comparing performance of: trunc vs round vs floor vs parseFloat to int vs ~~ vs |0 vs parseInt vs parseInt, 10

Created: 11 months ago by: Registered User

Jump to the latest result

trunc

round

floor

parseFloat to int

~~

|0

parseInt

parseInt, 10

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 2 months ago):