Benchmark: What's faster? cached Intl.NumberFormat vs new Intl.NumberFormat vs toLocaleString currency

Script Preparation code:

window.cachedFormatter = new Intl.NumberFormat('pt-BR', { style: 'currency', currency: 'BRL' });

Tests:

cached Intl.NumberFormat instance
window.cachedFormatter.format(3_950_219.56);
new Intl.NumberFormat
new Intl.NumberFormat('pt-BR', { style: 'currency', currency: 'BRL' }).format(3_950_219.56);
Number.prototype.toLocaleString
(3_950_219.56).toLocaleString('pt-BR', { style: 'currency', currency: 'BRL' });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
cached Intl.NumberFormat instance
new Intl.NumberFormat
Number.prototype.toLocaleString

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 130 on Windows

View result in a separate tab

Test name	Executions per second
cached Intl.NumberFormat instance	1148843.9 Ops/sec
new Intl.NumberFormat	28192.9 Ops/sec
Number.prototype.toLocaleString	29502.8 Ops/sec

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

LLMs can make mistakes. Check important info.

**What is being tested?**

MeasureThat.net is testing the performance of three different approaches to format currency values:

1. **Cached `Intl.NumberFormat` instance**: This approach creates an instance of `Intl.NumberFormat` with a specific locale and options, caches it in the `window.cachedFormatter` variable, and then uses this cached instance to format a currency value.
2. **Newly created `Intl.NumberFormat` instance**: This approach creates a new instance of `Intl.NumberFormat` with the same locale and options as the first approach, but without caching it.
3. **`Number.prototype.toLocaleString` method**: This approach uses the `toLocaleString` method on the `Number` prototype to format the currency value.

**Options compared**

The three approaches differ in how they create and use the formatting instance:

* The cached instance is created only once, when the script preparation code runs, and then reused for all subsequent tests.
* The newly created instance is created every time the benchmark definition runs, without caching it.
* The `Number.prototype.toLocaleString` method is a built-in method that formats numbers in a specific locale, but its performance may vary depending on the browser implementation.

**Pros and Cons**

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

* **Cached instance**: Pros:
	+ Can be faster since it reuses an already created instance.
	+ Reduces overhead from creating a new instance for every test.
* Cons:
	+ Requires additional code to cache the instance, which can add overhead.
	+ May not work if the cached instance is not found or is invalid.
* **Newly created instance**: Pros:
	+ Does not require caching, so no additional code is needed.
	+ Can be simpler to implement.
* Cons:
	+ Creates a new instance for every test, which can increase overhead and slow down the benchmark.
* **`Number.prototype.toLocaleString` method**: Pros:
	+ Does not require creating an instance or caching it.
	+ Can be faster since it's a built-in method that formats numbers in a specific locale.
* Cons:
	+ Performance may vary depending on the browser implementation.
	+ May not work if the locale or formatting options are not supported.

**Libraries and features**

None of the approaches rely on external libraries, but they do use some JavaScript features:

* `Intl.NumberFormat` is used in both cached and newly created instance approaches. It's a part of the ECMAScript Internationalization API (ES6) and provides a way to format numbers with locale-specific options.
* The `toLocaleString` method on `Number.prototype` is also part of the ES6 API, but its implementation may vary depending on the browser.

**Special JS features**

None of the approaches use special JavaScript features that are not widely supported. However, they do rely on some built-in methods and properties, such as `Intl.NumberFormat` and `Number.prototype.toLocaleString`.

I hope this explanation helps!

Related benchmarks:

What's faster? cached Intl.NumberFormat vs new Intl.NumberFormat vs toLocaleString currency (version: 0)

Comparing performance of: cached Intl.NumberFormat instance vs new Intl.NumberFormat vs Number.prototype.toLocaleString

Created: one year ago by: Guest

Jump to the latest result

cached Intl.NumberFormat instance

new Intl.NumberFormat

Number.prototype.toLocaleString

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