Benchmark: Float string optimization: parseFloat() vs regex

Tests:

parseFloat()
var string = parseFloat((3/2).toFixed(4)).toString();
regex
var string = (3/2).toFixed(4).replace(/\.?0*$/, '');

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

regex

3.8M/s

parseFloat()

2.9M/s

Fastest: regex (1.3x faster)

View exact numbers

✓ regex: 3,761,475 ops/sec
• parseFloat(): 2,868,881 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
parseFloat()
regex

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Firefox 141 on Windows

View result in a separate tab

parseFloat()

25.6M/s

regex

15.9M/s

View exact numbers

Test name	Executions per second
✓ parseFloat()	25,606,124 Ops/sec
regex	15,921,439 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested, compared options, pros and cons of each approach, library usage, special JS features, and other considerations.

**Benchmark Definition**
The benchmark measures the performance difference between two approaches to convert a float number with limited precision to a string: using `parseFloat()` versus a regular expression.

**Options Compared**

1. **`parseFloat()`**: This function parses a string representing a floating-point number and returns its decimal value as a number.
2. **Regular Expression (Regex)**: A regex pattern is used to extract the numeric part of the float string, effectively limiting precision to 4 decimal places (`toFixed(4)`).

**Pros and Cons**

* **`parseFloat()`**:
	+ Pros:
		- Shorter code length
		- Easier to read and understand for developers familiar with `parseFloat()`
	+ Cons:
		- May be slower due to string parsing and casting to float
* **Regular Expression (Regex)**:
	+ Pros:
		- Faster execution time, as it avoids unnecessary string operations
		- More flexible, allowing for more complex string manipulation
	+ Cons:
		- Longer code length
		- Requires knowledge of regex syntax

**Library Usage**
There is no explicit library usage in this benchmark.

**Special JS Features**
There are no special JavaScript features used in this benchmark (e.g., async/await, promises).

**Other Considerations**

* The benchmark uses a Windows 10 desktop environment with Chrome 129.
* Both test cases use the `toFixed(4)` method to limit precision to 4 decimal places.

**Alternatives**
If you need to optimize similar operations in your code, consider the following alternatives:

1. **Use a dedicated library for string manipulation**, such as `lodash` or `underscore`, which provide optimized implementations of regex patterns and other string operations.
2. **Explore alternative approaches**, like using ` Intl.NumberFormat()` API (supported in modern browsers) to format numbers with limited precision.
3. **Profile your code** using tools like Chrome DevTools, Node.js Inspector, or other JavaScript profilers to identify performance bottlenecks and optimize specific parts of your code.

Keep in mind that the best approach depends on your specific use case, performance requirements, and personal coding style preferences.

Float string optimization: parseFloat() vs regex (version: 0)

To get a cleaned-up float number with a limited number of digits of precision, which is faster: parsefloat() or a regular expression?

Comparing performance of: `parseFloat() vs regex`

Created: 5 years ago by: Guest

Go to the latest result

parseFloat()

regex

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Float string optimization: parseFloat() vs regex (version: 0)

To get a cleaned-up float number with a limited number of digits of precision, which is faster: parsefloat() or a regular expression?

Comparing performance of: parseFloat() vs regex

Created: 5 years ago by: Guest

Go to the latest result

parseFloat()

regex

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 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: `parseFloat() vs regex`