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!