Benchmark: Intl.Collator.compare() lowercase vs sensitivity vs localeCompare

Script Preparation code:

var arr = ['A', 'a', 'B', 'b', 'C', 'c', 'D', 'd'];

var options = {
  sensitivity: 'accent'
};

var collator1 = new Intl.Collator(undefined, options);
var collator2 = new Intl.Collator();

Tests:

lowercase
arr.sort((a,b) => collator2.compare(a.toLowerCase(), b.toLowerCase()))
sensitivity
arr.sort(collator1.compare)
Intl.Collator
arr.sort((a,b) => Intl.Collator().compare(a.toLowerCase(), b.toLowerCase()))
localecompare
arr.sort((a,b) => a.toLowerCase().localeCompare(b.toLowerCase()))
localecompare sensitivity
arr.sort((a,b) => a.localeCompare(b, undefined, options))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lowercase
sensitivity
Intl.Collator
localecompare
localecompare sensitivity

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 129 on Windows

View result in a separate tab

Test name	Executions per second
lowercase	1841596.4 Ops/sec
sensitivity	2894876.0 Ops/sec
Intl.Collator	48563.5 Ops/sec
localecompare	5330860.0 Ops/sec
localecompare sensitivity	50869.3 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested.

**Overview**

The benchmark is designed to compare the performance of different approaches for sorting an array of strings using various collation methods in JavaScript.

**Collator Options**

A Collator is an object that provides a way to sort and compare strings based on their cultural characteristics, such as language, region, and script. The `Intl.Collator` class is used to create a Collator instance.

In the benchmark, three different options are compared:

1. **LocaleCompare**: This option uses the built-in `localeCompare()` method of strings to perform collation. It's a simple and efficient way to compare strings based on their cultural characteristics.
2. **Intl.Collator.compare() with sensitivity='accent'**: This option creates an `Intl.Collator` instance with the `sensitivity` parameter set to `'accent'`. This means that accents and diacritical marks will be taken into account when comparing strings.
3. **Manual comparison using Collator.compare()**: This option creates a new `Intl.Collator` instance without specifying any options, which allows for more control over the collation process.

**Pros and Cons**

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

1. **LocaleCompare**:
	* Pros: Simple, efficient, and widely supported.
	* Cons: May not handle all cultural nuances, especially in complex languages like Arabic or Hebrew.
2. **Intl.Collator.compare() with sensitivity='accent'**:
	* Pros: Takes accents and diacritical marks into account, handles more cultural nuances than LocaleCompare.
	* Cons: Can be slower than LocaleCompare due to the added complexity of handling accented characters.
3. **Manual comparison using Collator.compare()**:
	* Pros: Provides fine-grained control over the collation process, can handle complex languages and cultural nuances.
	* Cons: Requires more code and expertise, can be slower due to the manual implementation.

**Special Considerations**

The benchmark uses some special features in JavaScript:

1. **Arrow functions**: The `Benchmark Definition` strings use arrow functions to define the comparison function for sorting the array of strings.
2. **Null coalescing operator (`??`)**: In one of the benchmark cases, the `compare()` method is called with a default value (e.g., `'en-US'`) when no locale is specified.

**Other Alternatives**

If you want to explore other alternatives, here are some options:

1. **ICU4J**: A Java library for internationalization and localization that provides a similar API to Intl.Collator.
2. **Collation algorithms**: You can implement custom collation algorithms using JavaScript, which would allow for fine-grained control over the sorting process.

In summary, the benchmark compares three different approaches for sorting an array of strings using various collation methods in JavaScript. The results help identify the most efficient and culturally accurate approach for sorting strings based on their cultural characteristics.

Related benchmarks:

Intl.Collator.compare() lowercase vs sensitivity vs localeCompare (version: 0)

Comparing performance of: lowercase vs sensitivity vs Intl.Collator vs localecompare vs localecompare sensitivity

Created: 2 months ago by: Guest

Jump to the latest result

lowercase

sensitivity

Intl.Collator

localecompare

localecompare sensitivity

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