Benchmark: Intl.Collator.compare vs localeCompare 2

Script Preparation code:

const minCodePoint = 'a'.charCodeAt(0);
const maxCodePoint = 'z'.charCodeAt(0);
const randomLetter = () => String.fromCharCode(Math.floor(Math.random() * (maxCodePoint - minCodePoint) + minCodePoint));
const createWord = () => Array.from({length: 15}, randomLetter).join('');

var words = Array.from({length: 50000}, createWord);
var collator = new Intl.Collator();

Tests:

Intl.Collator
words.sort(collator.compare);
localeCompare
words.sort((a, b) => a.localeCompare(b))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Intl.Collator
localeCompare

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36

Browser/OS: Chrome 117 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Intl.Collator	214.4 Ops/sec
localeCompare	521.3 Ops/sec

Autogenerated LLM Summary (model gemma2:9b, generated 2 months ago):

LLMs can make mistakes. Check important info.

This benchmark compares two ways to sort an array of strings alphabetically: using `Intl.Collator.compare` and `localeCompare`.

**Options Compared:**

* **`Intl.Collator.compare`:** This method uses the  `Intl.Collator` object, which provides locale-sensitive string comparison based on the user's system settings. It's generally considered more accurate and reliable for sorting strings in a specific language or region.

* **`localeCompare`:** This built-in JavaScript method also performs locale-sensitive string comparison but is simpler to use.

**Pros and Cons:**

| Method        | Pros                                            | Cons                                          |
|--------------|-------------------------------------------------|-----------------------------------------------|
| `Intl.Collator` | More precise and accurate for complex comparisons, especially with non-Latin alphabets.  | Requires creating a `Intl.Collator` instance, which can be slightly more verbose. |
| `localeCompare`| Simpler to use, directly available on strings.   | Can be less accurate than `Intl.Collator` for very specific or nuanced comparisons. |

**Other Considerations:**

* **Performance:**  The benchmark shows that `localeCompare` is faster in this case, likely because it's a simpler implementation.

* **Locale:** Both methods respect the user's locale settings.

**Alternatives:**

There aren't many direct alternatives to these methods for locale-sensitive string comparison in JavaScript. If you need extreme precision or control over sorting logic, you could implement your own custom comparison function. However, `Intl.Collator` and `localeCompare` provide a convenient and reliable solution for most use cases.

Related benchmarks:

Intl.Collator.compare vs localeCompare 2 (version: 0)

Comparing performance of: Intl.Collator vs localeCompare

Created: one year ago by: Guest

Jump to the latest result

Intl.Collator

localeCompare

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gemma2:9b, generated 2 months ago):