Benchmark: Intl.Collator.compare vs String.prototype.localeCompare (v8 ASCII fast path)

Script Preparation code:

function randomStrings(chars, length, stringLength) {
	const randomChar = () => chars[Math.floor(Math.random() * chars.length)];
	const randomString = () => Array.from({length: stringLength}, randomChar).join("");
	return Array.from({length}, randomString);
}

var asciiStrings = randomStrings(["a", "b", "c"], 50000, 9);
var unicodeStrings = randomStrings(["간", "쟁", "뜻"], 50000, 9);

Tests:

Intl.Collator.compare (ASCII-only strings)
const collator = new Intl.Collator(); asciiStrings.sort(collator.compare);
String.prototype.localeCompare (ASCII-only strings)
asciiStrings.sort((a, b) => a.localeCompare(b));
Intl.Collator.compare
const collator = new Intl.Collator(); unicodeStrings.sort(collator.compare);
String.prototype.localeCompare
unicodeStrings.sort((a, b) => a.localeCompare(b));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Intl.Collator.compare (ASCII-only strings)
String.prototype.localeCompare (ASCII-only strings)
Intl.Collator.compare
String.prototype.localeCompare

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Firefox 132 on Linux

View result in a separate tab

Test name	Executions per second
Intl.Collator.compare (ASCII-only strings)	43.0 Ops/sec
String.prototype.localeCompare (ASCII-only strings)	36.5 Ops/sec
Intl.Collator.compare	28.5 Ops/sec
String.prototype.localeCompare	18.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmark test case for comparing the performance of `Intl.Collator.compare` and `String.prototype.localeCompare` functions, specifically designed to measure their execution speed on ASCII-only strings.

**Script Preparation Code**

The script preparation code is used to generate random ASCII and Unicode strings. The `randomStrings` function generates an array of strings by concatenating a set of characters (`"a", "b", "c"` for ASCII and `"간", "쟁", "뜻"` for Unicode) multiple times, creating 50000 strings with lengths between 9 and the specified length.

**Html Preparation Code**

There is no HTML preparation code provided.

**Individual Test Cases**

The benchmark consists of four test cases:

1. `Intl.Collator.compare (ASCII-only strings)`: This test case creates a new `Intl.Collator` object and sorts an array of ASCII strings using the `compare` method.
2. `String.prototype.localeCompare (ASCII-only strings)`: This test case sorts an array of ASCII strings using the `localeCompare` method as a callback function.
3. `Intl.Collator.compare`: This test case creates a new `Intl.Collator` object and sorts an array of Unicode strings using the `compare` method.
4. `String.prototype.localeCompare`: This test case sorts an array of Unicode strings using the `localeCompare` method as a callback function.

**Library: Intl.Collator**

The `Intl.Collator` library is part of the ECMAScript Internationalization API, which provides a way to compare and manipulate text according to the user's language and regional preferences. The `compare` method is used to compare two strings in a locale-specific manner.

**Library: String.prototype.localeCompare**

The `localeCompare` method is a built-in JavaScript method that compares two strings according to the user's language and regional preferences, without requiring the use of an external library.

**Pros and Cons of Each Approach**

1. **Intl.Collator.compare (ASCII-only strings)**
	* Pros: Can be used for locale-agnostic comparisons on ASCII data.
	* Cons: May be slower than `String.prototype.localeCompare` due to the overhead of creating a new `Intl.Collator` object and performing locale-specific normalization.
2. **String.prototype.localeCompare (ASCII-only strings)**
	* Pros: Faster than `Intl.Collator.compare` for ASCII data, as it leverages built-in JavaScript functionality.
	* Cons: May not be suitable for locale-agnostic comparisons or Unicode data due to the limitations of the `localeCompare` method.
3. **Intl.Collator.compare**
	* Pros: Can be used for locale-aware comparisons on Unicode data, leveraging the power of internationalization.
	* Cons: Slower than `String.prototype.localeCompare` due to the overhead of creating a new `Intl.Collator` object and performing locale-specific normalization.
4. **String.prototype.localeCompare**
	* Pros: Faster than `Intl.Collator.compare` for Unicode data, as it leverages built-in JavaScript functionality.
	* Cons: May not be suitable for locale-agnostic comparisons or ASCII data due to the limitations of the `localeCompare` method.

**Special JS Feature/Syntax**

None mentioned in this explanation. However, it's worth noting that the use of `Intl.Collator` and `String.prototype.localeCompare` involves Unicode normalization and collation algorithms, which can be complex and nuanced.

**Alternatives**

Other alternatives for string comparison include:

1. **Array.prototype.sort() with a custom compare function**: This method allows for manual implementation of comparison logic, but may not leverage the power of internationalization or locale-aware comparisons.
2. **Third-party libraries like ICU or CLDR**: These libraries provide additional features and functionality for text processing and comparison, but may introduce additional dependencies and complexity.

In summary, the choice between `Intl.Collator.compare` and `String.prototype.localeCompare` depends on the specific requirements of your application, including locale-awareness, Unicode support, and performance considerations.

Related benchmarks:

Intl.Collator.compare vs String.prototype.localeCompare (v8 ASCII fast path) (version: 0)

Comparing performance of: Intl.Collator.compare (ASCII-only strings) vs String.prototype.localeCompare (ASCII-only strings) vs Intl.Collator.compare vs String.prototype.localeCompare

Created: one year ago by: Guest

Jump to the latest result

Intl.Collator.compare (ASCII-only strings)

String.prototype.localeCompare (ASCII-only strings)

Intl.Collator.compare

String.prototype.localeCompare

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