Benchmark: Number & toLocaleString vs + & toLocaleString vs custom thousands seperator

Script Preparation code:

var number = '1234567';

var addThousandsSeperators = (value) => {
  if (value.length <= 3) return value;
  return Array.from(value).reduce((acc, x, i, a) => (
    (a.length - i) % 3 === 0 && i ? `${acc},${x}` : `${acc}${x}`
  ), '');
};

Tests:

toLocaleString
Number(number).toLocaleString();
custom thousands seperator
addThousandsSeperators(number);
toLocaleString +
(+number).toLocaleString();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
toLocaleString
custom thousands seperator
toLocaleString +

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:121.0) Gecko/20100101 Firefox/121.0

Browser/OS: Firefox 121 on Linux

View result in a separate tab

Test name	Executions per second
toLocaleString	3144722.0 Ops/sec
custom thousands seperator	4399667.0 Ops/sec
toLocaleString +	3034322.0 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 is being tested.

**Overview**

The benchmark compares three different approaches for formatting numbers with thousands separators:

1. Using the `toLocaleString()` method directly on a number (`Number(number).toLocaleString();`).
2. Creating a custom function to add thousands separators (`addThousandsSeperators(number);`).
3. Using the unary plus operator (`+`) followed by `toLocaleString()` (`(+number).toLocaleString();`).

**Options Compared**

The benchmark tests each of these approaches against each other, comparing their performance on the same input data.

* **Pros and Cons:**
	+ **Direct `toLocaleString()`**: Easy to use, but may involve additional processing or parsing overhead.
	+ **Custom function (`addThousandsSeperators()`)**: Provides more control over formatting, but requires manual implementation and potential errors. It's likely optimized for performance.
	+ **Unary plus operator (`+`)**: Lightweight and easy to use, but might not be as efficient as other methods or require additional parsing.
* Other considerations:
	+ The custom function uses `Array.from()` and `reduce()`, which may impact performance depending on the input data size and browser optimization.

**Library Used**

The benchmark does not use a specific JavaScript library for formatting numbers. However, it assumes that the `toLocaleString()` method is available, which is part of the ECMAScript standard (JavaScript language specification).

**Special JS Feature or Syntax**

This benchmark does not explicitly mention any special features or syntax beyond using the `toLocaleString()` method and the unary plus operator.

**Benchmark Preparation Code Analysis**

The custom function (`addThousandsSeperators()`) uses a simple implementation to add thousands separators. It works by:

1. Checking if the input value has fewer than 4 characters (i.e., it's already in thousands format).
2. If so, returning the original value.
3. Otherwise, using `Array.from()` and `reduce()` to create a string with commas separating groups of three digits.

This implementation should be efficient for most cases but may not handle edge cases or larger input values well.

**Alternatives**

If you're interested in alternatives or variations on this benchmark, here are some ideas:

1. **Use a different formatting library**: Instead of using `toLocaleString()`, try using a dedicated formatting library like Moment.js or Intl.NumberFormat.
2. **Compare with decimal separators**: Add a test case that compares the performance of different decimal separator formats (e.g., `.`, `,`, or `;`).
3. **Test on different platforms**: Run the benchmark on mobile devices or other platforms to evaluate performance differences across browsers and operating systems.

These variations can provide more comprehensive insights into JavaScript's built-in formatting methods and help developers make informed decisions about choosing alternative libraries or approaches for their specific use cases.

Related benchmarks:

Number & toLocaleString vs + & toLocaleString vs custom thousands seperator (version: 0)

Comparing performance of: toLocaleString vs custom thousands seperator vs toLocaleString +

Created: 5 years ago by: Guest

Jump to the latest result

toLocaleString

custom thousands seperator

toLocaleString +

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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