Benchmark: lodash.round VS toFixed() VS toFixed() and parseFloat vs L.formmatNum

lodash.round VS toFixed() VS toFixed() and parseFloat vs L.formmatNum (version: 0)

Compare round lodash function vs javascript native toFixed() function

Comparing performance of: Round floating number using lodash round function vs Round floating number using toFixed() vs Round floating number using toFixed() and parseFloat vs Leaflet formatNum

Created: 6 years ago by: Guest

Jump to the latest result

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

 <script src="https://unpkg.com/leaflet@1.6.0/dist/leaflet.js"
   integrity="sha512-gZwIG9x3wUXg2hdXF6+rVkLF/0Vi9U8D2Ntg4Ga5I5BZpVkVxlJWbSQtXPSiUTtC0TjtGOmxa1AJPuV0CPthew=="
   crossorigin=""></script>

Script Preparation code:

var x = 5.236;

Tests:

Round floating number using lodash round function
for (var i = 0; i < 1000; i++) { _.round(x,2); }
Round floating number using toFixed()
for (var i = 0; i < 1000; i++) { x.toFixed(2); }
Round floating number using toFixed() and parseFloat
for (var i = 0; i < 1000; i++) { parseFloat(x.toFixed(2)); }
Leaflet formatNum
for (var i = 0; i < 1000; i++) { L.Util.formatNum(x, 2); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Round floating number using lodash round function
Round floating number using toFixed()
Round floating number using toFixed() and parseFloat
Leaflet formatNum

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36

Browser/OS: Chrome 136 on Linux

View result in a separate tab

Test name	Executions per second
Round floating number using lodash round function	5347.9 Ops/sec
Round floating number using toFixed()	21754.2 Ops/sec
Round floating number using toFixed() and parseFloat	15638.4 Ops/sec
Leaflet formatNum	378597.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark measures the performance of three approaches for rounding floating-point numbers in JavaScript:

1. Lodash's `round` function
2. JavaScript's built-in `toFixed` method
3. A combination of `toFixed` and `parseFloat`

**Options Compared**

* `lodash.round`: rounds a number to a specified precision using Lodash's custom implementation.
* `toFixed`: rounds a number to a specified precision using the standard format specifier syntax (e.g., `x.toFixed(2)`).
* `toFixed` + `parseFloat`: uses `toFixed` to convert the float to a string, and then parses it back to a float using `parseFloat`.

**Pros and Cons of Each Approach**

1. **Lodash's `round` function**:
	* Pros: custom implementation might be optimized for specific use cases or edge cases.
	* Cons: requires including an external library (Lodash), which can introduce additional overhead.
2. **`toFixed` method**:
	* Pros: widely available and well-documented, uses standard JavaScript syntax.
	* Cons: may not be as efficient or flexible as custom implementations, especially for large numbers of iterations.
3. **`toFixed` + `parseFloat` combination**:
	* Pros: avoids external library dependencies, uses a straightforward and well-known algorithm (parse-then-format).
	* Cons: introduces additional function calls and string conversions, which can be expensive in terms of performance.

**Library: Leaflet's `formatNum` method**

Leaflet is a popular JavaScript library for interactive maps. Its `formatNum` method is used in one of the benchmark test cases to format floating-point numbers. This method likely uses a similar approach to Lodash's `round` function, but with its own implementation and optimizations.

**Special JS Feature: No specific features or syntax are mentioned in this benchmark.**

**Benchmark Preparation Code**

The provided code prepares the test environment by including necessary libraries (Lodash and Leaflet) before running the benchmark tests. This ensures that the test cases can execute correctly on the target devices.

**Alternative Approaches**

Other approaches to round floating-point numbers in JavaScript include:

1. **Math.floor` + Math.round`: uses the `floor` method to truncate the decimal part, followed by the `round` method to add rounding precision.
2. **Binary search**: a more complex approach that iteratively searches for an approximate value within a given range, using binary search techniques.

These alternative approaches might offer better performance or more control over rounding behavior in specific use cases, but may also introduce additional complexity and dependencies.

Related benchmarks: