Benchmark: toFixed vs toPrecision vs Math.round() vs Math.floorfast vs new Math.trunc

toFixed vs toPrecision vs Math.round() vs Math.floorfast vs new Math.trunc (version: 0)

Comparing performance of: toFixed(4) vs toPrecision(4).toString() vs (Math.round(*10000)/10000).toString() vs Math.floor fast vs the new Math.trunc

Comparing performance of: `toFixed(4) someFloat.toFixed(4); someFloat.t vs toPrecision(4).toString() vs (Math.round(*10000)/10000).toString() vs Math.floor fast vs Math.trunc`

Created: 6 years ago by: Guest

Go to the latest result

Script Preparation code:

var someFloat = 0.123456789;

Tests:

toFixed(4) someFloat.toFixed(4); someFloat.t
someFloat.toFixed(4);
toPrecision(4).toString()
someFloat.toPrecision(4);
(Math.round(*10000)/10000).toString()
(Math.round(someFloat*10000)/10000);
Math.floor fast
~~(someFloat * 10000) / 10000;
Math.trunc
Math.trunc(someFloat * 10000) / 10000;

Historical Performance Data aggregated from 39 community runs

Desktop Results:

Chrome 32 runs

Math.floor fast

29.8M/s

(Math.round(*10000)/10000).toString()

11.2M/s

Math.trunc

10.9M/s

toPrecision(4).toString()

7.7M/s

toFixed(4) someFloat.toFixed(4); someFloat.t

6.8M/s

Fastest: Math.floor fast (4.4x faster)

View exact numbers

✓ Math.floor fast: 29,809,358 ops/sec
• (Math.round(*10000)/10000).toString(): 11,224,034 ops/sec
• Math.trunc: 10,888,918 ops/sec
• toPrecision(4).toString(): 7,656,532 ops/sec
• toFixed(4) someFloat.toFixed(4); someFloat.t: 6,833,404 ops/sec

Firefox 7 runs

(Math.round(*10000)/10000).toString()

1582.0M/s

Math.trunc

1562.5M/s

Math.floor fast

1454.9M/s

toFixed(4) someFloat.toFixed(4); someFloat.t

18.1M/s

toPrecision(4).toString()

13.0M/s

Fastest: (Math.round(*10000)/10000).toString() (121.3x faster)

View exact numbers

✓ (Math.round(*10000)/10000).toString(): 1,582,026,112 ops/sec
• Math.trunc: 1,562,475,776 ops/sec
• Math.floor fast: 1,454,891,776 ops/sec
• toFixed(4) someFloat.toFixed(4); someFloat.t: 18,130,968 ops/sec
• toPrecision(4).toString(): 13,039,024 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
toFixed(4) someFloat.toFixed(4); someFloat.t
toPrecision(4).toString()
(Math.round(*10000)/10000).toString()
Math.floor fast
Math.trunc

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 147 on Windows

View result in a separate tab

Math.floor fast

130.1M/s

(Math.round(*10000)/10000).toString()

127.3M/s

Math.trunc

121.9M/s

toPrecision(4).toString()

16.6M/s

toFixed(4) someFloat.toFixed(4); someFloat.t

11.0M/s

View exact numbers

Test name	Executions per second
✓ Math.floor fast	130,093,736 Ops/sec
(Math.round(*10000)/10000).toString()	127,316,816 Ops/sec
Math.trunc	121,926,080 Ops/sec
toPrecision(4).toString()	16,568,263 Ops/sec
toFixed(4) someFloat.toFixed(4); someFloat.t	10,964,273 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in the provided JSON.

**Benchmark Definition**

The benchmark is testing the performance of different methods to round or truncate a floating-point number:

1. `toFixed(4)`: This method rounds the number to 4 decimal places using the "fixed" rounding mode.
2. `toPrecision(4).toString()`: This method uses the `toPrecision()` method to specify the precision and then converts the result to a string.
3. `(Math.round(*10000)/10000).toString()`: This method multiplies the number by 10,000, rounds the result using `Math.round()`, and then divides by 10,000 before converting to a string.
4. `~~(someFloat * 10000) / 10000`: This method uses bitwise NOT (`~`) to effectively truncate the number (more on this later).
5. `Math.trunc(someFloat * 10000) / 10000`: This method uses the new `Math.trunc()` function (introduced in ECMAScript 2020) to truncate the number.

**Options Compared**

The benchmark is comparing these five different methods:

* `toFixed(4)` vs `toPrecision(4).toString()`: These two methods use different rounding modes, but both aim to achieve a similar result.
* `(Math.round(*10000)/10000).toString()` vs `~~(someFloat * 10000) / 10000`: Both methods use bitwise operations or multiplication/division by large numbers to truncate the number.
* `(Math.round(*10000)/10000).toString()` vs `Math.trunc(someFloat * 10000) / 10000`: The first method uses a more traditional rounding approach, while the second method uses the new `Math.trunc()` function.

**Pros and Cons**

Here's a brief summary of each method:

* `toFixed(4)`:
	+ Pros: Easy to use, straightforward.
	+ Cons: May not work as expected for very large numbers or non-integer results.
* `toPrecision(4).toString()`:
	+ Pros: More precise than `toFixed(4)`, but may be slower due to the extra conversion step.
	+ Cons: Can be less intuitive for some users, as it relies on the `toPrecision()` method.
* `(Math.round(*10000)/10000).toString()`:
	+ Pros: Simple and effective, but may not work well with very large or very small numbers.
	+ Cons: Uses multiplication/division by large numbers, which can be slower than other methods.
* `~~(someFloat * 10000) / 10000`:
	+ Pros: Fast and efficient, as it uses bitwise NOT to truncate the number.
	+ Cons: May not work well with very large or very small numbers due to integer overflow/underflow issues.
* `Math.trunc(someFloat * 10000) / 10000`:
	+ Pros: More precise than `~~(someFloat * 10000) / 10000`, and easier to read for some users.
	+ Cons: May be slower due to the division step, but is generally faster than the traditional rounding methods.

**Library and Special JS Features**

The benchmark uses the following library:

* None explicitly mentioned. However, `Math.trunc()` is a new function introduced in ECMAScript 2020, which provides an efficient way to truncate numbers without using bitwise operations.

If any special JavaScript features are used, they might be implicit in the `~~(someFloat * 10000) / 10000` method, as it relies on the `~` operator (bitwise NOT). This feature was introduced in ECMAScript 2015.

**Alternatives**

Other alternatives for rounding or truncating numbers include:

* Using a library like `lodash` or `moment.js`, which provide more complex and powerful rounding functions.
* Implementing a custom rounding function using arithmetic operations, as done in the `~~(someFloat * 10000) / 10000` method.
* Using a different data type, such as an integer, to represent the rounded/truncated number.

Keep in mind that the choice of rounding method depends on the specific use case and requirements.

toFixed vs toPrecision vs Math.round() vs Math.floorfast vs new Math.trunc (version: 0)

Comparing performance of: toFixed(4) vs toPrecision(4).toString() vs (Math.round(*10000)/10000).toString() vs Math.floor fast vs the new Math.trunc

Comparing performance of: toFixed(4) someFloat.toFixed(4); someFloat.t vs toPrecision(4).toString() vs (Math.round(*10000)/10000).toString() vs Math.floor fast vs Math.trunc

Created: 6 years ago by: Guest

Go to the latest result

toFixed(4) someFloat.toFixed(4); someFloat.t

toPrecision(4).toString()

(Math.round(*10000)/10000).toString()

Math.floor fast

Math.trunc

Historical Performance Data aggregated from 39 community runs

Desktop Results:

Chrome 32 runs

Firefox 7 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `toFixed(4) someFloat.toFixed(4); someFloat.t vs toPrecision(4).toString() vs (Math.round(*10000)/10000).toString() vs Math.floor fast vs Math.trunc`