Benchmark: Teste Truncar numero

Tests:

toFixed
let numero = 123.45678; let resultado = numero.toFixed(2); // "123.46" como string resultado = Number(resultado); // Converte de volta para número, se necessário
Round
let numero = 123.45678; let resultado = Math.round(numero * 100) / 100; // 123.46
floor
let numero = 123.45678; let resultado = Math.floor(numero * 100) / 100; // 123.45
Bitwise
let numero = 123.45678; let resultado = (numero * 100 | 0) / 100; // 123.45
Math.trunc
let numero = 123.45678; let resultado = Math.trunc(numero * 100) / 100; // 123.45

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
toFixed
Round
floor
Bitwise
Math.trunc

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 120 on Android

View result in a separate tab

Test name	Executions per second
toFixed	229651.9 Ops/sec
Round	705876.2 Ops/sec
floor	700182.2 Ops/sec
Bitwise	149503312.0 Ops/sec
Math.trunc	712237.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

The provided JSON represents a benchmarking test suite for various methods to truncate decimal numbers in JavaScript. The tests are designed to compare the performance of different approaches.

**Test Cases**

Each test case has a unique `Benchmark Definition` string that describes how to perform the truncation using JavaScript's built-in functions or bitwise operations. Here's a brief explanation of each approach:

1. **toFixed**: This method uses the `toFixed()` function, which converts a number to a fixed-point string with a specified number of digits after the decimal point.
2. **Round**: This method uses the `Math.round()` function, which rounds a number to the nearest integer.
3. **Floor**: This method uses the `Math.floor()` function, which returns the largest integer less than or equal to a given number.
4. **Bitwise**: This method uses bitwise operations (the `|` operator) to truncate the decimal part of a number. Specifically, `(numero * 100 | 0)` shifts the bits of `numero * 100` one position to the right and then performs a bitwise OR operation with 0, effectively removing any fractional part.
5. **Math.trunc**: This method uses the `Math.trunc()` function, which returns the integer part of a number.

**Options Compared**

The tests compare different options for truncating decimal numbers:

* Performance: The test measures how many executions per second each approach can handle on a specific device and browser configuration.
* Accuracy: Each approach should produce the same result (the truncated decimal value) as long as the input is a valid number.

**Pros and Cons of Each Approach**

Here's a brief summary of the pros and cons of each approach:

1. **toFixed**: Pros:
	* Easy to use
	* Can handle fractional parts with a specified number of digits after the decimal point.
Cons:
	* May not be as efficient as other methods, especially for large numbers or high-performance applications.
2. **Round**: Pros:
	* Generally fast and accurate
	* Works well for integer-only values.
Cons:
	* Rounding errors can occur if the input value is not an integer.
3. **Floor**: Pros:
	* Fast and efficient
	* Returns the largest integer less than or equal to the input value.
Cons:
	* Does not preserve fractional parts, which may be important for certain applications.
4. **Bitwise**: Pros:
	* Extremely fast (using bitwise operations)
	* Works well for large numbers and high-performance applications.
Cons:
	* Requires understanding of binary arithmetic and bitwise operations.
5. **Math.trunc**: Pros:
	* Fast and efficient
	* Returns the integer part of a number without rounding errors.
Cons:
	* May not be as widely supported or understood as other methods.

**Libraries and Special Features**

There are no libraries mentioned in the provided code, but JavaScript has several built-in functions that can be used for mathematical operations, such as `Math.round()`, `Math.floor()`, `Math.trunc()`, and bitwise operators (`|`).

No special JavaScript features (e.g., ES6+ syntax) are explicitly mentioned, but it's worth noting that some of the approaches may rely on modern JavaScript versions or specific browser implementations.

**Other Alternatives**

If you need more accurate results or want to explore alternative methods, consider the following:

* **Decimal.js**: A library for decimal arithmetic in JavaScript.
* **Big.js**: A library for large integer and decimal arithmetic in JavaScript.
* **Bignumber.js**: A library for arbitrary-precision arithmetic in JavaScript.

These libraries can provide more precise calculations and handling of fractional parts compared to built-in functions or bitwise operations. However, they may introduce additional overhead or complexity depending on the specific use case.

Related benchmarks:

Teste Truncar numero (version: 0)

Comparing performance of: toFixed vs Round vs floor vs Bitwise vs Math.trunc

Created: 11 months ago by: Guest

Jump to the latest result

toFixed

Round

floor

Bitwise

Math.trunc

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):