Benchmark: Intl.NumberFormat vs toLocalString vs string split & reduce

Script Preparation code:

var nf = new Intl.NumberFormat("en-US")

function pricize (num) {
  const pieces = num.toString().split('')
  const len = pieces.length
  return pieces.reduce((result, chr, index, array) => {
    const pos = len - index
    result += (index !== 0 && pos % 3 === 0) ? ',' + chr : chr
    return result
  }, '')
}

Tests:

toLocalString
var a = (10000).toLocaleString("en-US");
Intl.NumberFormat
var a = nf.format(10000)
string split & reduce
var a = pricize(10000)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
toLocalString
Intl.NumberFormat
string split & reduce

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested, along with the pros and cons of each approach.

**Benchmark Overview**

The benchmark measures the performance of three different methods to format numbers:

1. `Intl.NumberFormat` (International Number Format)
2. `toLocalString` (built-in JavaScript method)
3. Custom implementation using string splitting and reduction (`string split & reduce`)

**Method 1: Intl.NumberFormat**

The `Intl.NumberFormat` API is used to format numbers according to the specified locale. In this case, it's set to English-US (`"en-US"`). The method formats a number as a string, including cultural and formatting elements.

Pros:

* Wide support across browsers and devices
* Easy to use and understand
* Supports multiple locales and formatting options

Cons:

* May not be suitable for all cultures or formatting requirements
* Can be slower than other methods due to locale-specific calculations

**Method 2: toLocalString**

The `toLocalString` method is a built-in JavaScript function that formats a number as a string, similar to `Intl.NumberFormat`. However, it's more lightweight and doesn't require the Intl API.

Pros:

* Lightweight and fast
* Easy to use and understand

Cons:

* Limited support across browsers and devices (older browsers might not have this method)
* Less flexible than `Intl.NumberFormat` for formatting options

**Method 3: string split & reduce**

The custom implementation uses string splitting and reduction to format the number. This approach involves converting the number to a string, splitting it into individual characters, and then reassembling the string with specific patterns.

Pros:

* Highly customizable and flexible
* Can be very fast due to minimal overhead

Cons:

* Complex and harder to understand for beginners
* May not work correctly across all browsers and devices (due to variations in character representation)
* More code is required compared to `Intl.NumberFormat` or `toLocalString`

**Library and Special JS Features**

The benchmark uses the `Intl` API, which is a part of the ECMAScript Internationalization API. The `Intl.NumberFormat` method relies on this library to provide internationalized formatting capabilities.

There are no special JS features or syntax used in this benchmark.

**Other Alternatives**

If you're looking for alternative methods to format numbers, consider the following:

* Using a third-party library like moment.js for date and number formatting
* Implementing custom formatting logic using regular expressions or string manipulation
* Utilizing browser-specific APIs, such as `window.Number` in some older browsers

In conclusion, the benchmark provides valuable insights into the performance of different methods for formatting numbers. When choosing a method, consider factors like support, flexibility, and customization needs to select the best approach for your specific use case.

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.5 Safari/605.1.15

Browser/OS: Safari 15 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
toLocalString	44500.2 Ops/sec
Intl.NumberFormat	3026783.2 Ops/sec
string split & reduce	5945990.5 Ops/sec

Related benchmarks:

Intl.NumberFormat vs toLocalString vs string split & reduce (version: 0)

Comparing performance of: toLocalString vs Intl.NumberFormat vs string split & reduce

Created: 3 years ago by: Guest

Jump to the latest result

toLocalString

Intl.NumberFormat

string split & reduce

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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