Benchmark: Intl.Collator.compare vs localeCompare with numbers

Script Preparation code:

const minCodePoint = 'a'.charCodeAt(0);
const maxCodePoint = 'z'.charCodeAt(0);
const randomTextNumber = () => 'tst-' + Math.floor(Math.random() * (1000 - 1) + 1);

var words = Array.from({length: 50000}, randomTextNumber);

Tests:

Intl.Collator
const collator = new Intl.Collator(undefined, {numeric: true, sensitivity: 'base'}); words.sort(collator.compare);
localeCompare
words.sort((a, b) => a.localeCompare(b, undefined, {numeric: true, sensitivity: 'base'}))

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: 8 months ago)

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

Browser/OS: Safari 17 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Intl.Collator	16.6 Ops/sec
localeCompare	0.6 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 provided benchmark definition and test cases to understand what is being tested.

**Overview**

The benchmark measures the performance difference between two approaches: `Intl.Collator.compare` and `localeCompare` with numbers, when sorting an array of random text numbers. The goal is to determine which approach is faster and more efficient.

**Benchmark Definition JSON**

The benchmark definition consists of a single JSON object that contains:

*   **Name**: The name of the benchmark, which is "Intl.Collator compare vs localeCompare with numbers".
*   **Description**: An empty string indicating no description for this benchmark.
*   **Script Preparation Code**: A code snippet that generates an array of 50,000 random text numbers using the `randomTextNumber` function. This code is executed before running each test case.
*   **Html Preparation Code**: An empty string indicating no HTML preparation code needed.

**Individual Test Cases**

There are two test cases defined:

1.  **Intl.Collator**

*   **Benchmark Definition**: The test creates a new `Intl.Collator` object with the `numeric: true` and `sensitivity: 'base'` options, and then sorts the generated array using the `compare()` method.
2.  **localeCompare**

*   **Benchmark Definition**: The test uses the `sort()` method with a custom comparison function that utilizes `localeCompare()`, sorting the same array of random text numbers.

**Library and Purpose**

In this benchmark, the following libraries are used:

*   **Intl.Collator**: This is a built-in JavaScript library that provides support for comparing strings according to locale-specific rules. It's designed to handle complex string comparisons, such as those involving non-ASCII characters.
    *   The `numeric: true` option tells `Intl.Collator` to compare numbers based on their Unicode code points rather than their numeric value.
    *   The `sensitivity: 'base'` option specifies that the comparison should be performed based on the base letter or digit (i.e., not considering case).
*   **localeCompare**: This is another built-in JavaScript method for comparing strings according to locale-specific rules. It's designed to handle simple string comparisons, such as comparing two numbers.

**Pros and Cons**

The choice between `Intl.Collator.compare` and `localeCompare` depends on the specific requirements of your application:

*   **Intl.Collator.compare**:
    *   Pros:
        *   More accurate when dealing with complex string comparisons involving non-ASCII characters.
        *   Can handle cases where numbers need to be compared based on their Unicode code points.
    *   Cons:
        *   May be slower due to the additional complexity and overhead of locale-specific rules.
*   **localeCompare**:
    *   Pros:
        *   Generally faster and more lightweight, making it suitable for use in high-performance applications.
        *   Suitable for simple string comparisons involving numbers.
    *   Cons:
        *   May not be accurate when dealing with complex string comparisons or non-ASCII characters.

**Other Considerations**

When deciding between these two approaches, consider the following factors:

*   **Accuracy vs. Performance**: If accuracy is crucial and you're willing to sacrifice some performance, use `Intl.Collator.compare`. For high-performance applications where speed is paramount, `localeCompare` might be a better choice.
*   **Complexity of String Comparisons**: If your application involves complex string comparisons involving non-ASCII characters or Unicode code points, `Intl.Collator.compare` is likely the better option.

**Alternatives**

If you're not satisfied with the performance of either approach, consider alternative methods:

*   **Custom Comparison Functions**: You can create a custom comparison function using regular expressions or other techniques to achieve more precise control over the sorting process.
*   **Third-Party Libraries**: There are third-party libraries available that provide optimized and customizable string comparison functions, such as [fast-string-compare](https://github.com/kamalkumar fast-string-compare).
*   **Alternative Sorting Algorithms**: Depending on your specific requirements, you might consider using alternative sorting algorithms like QuickSort or Merge Sort, which can be more efficient than the built-in `sort()` method.

Related benchmarks:

Intl.Collator.compare vs localeCompare with numbers (version: 0)

Comparing performance of: Intl.Collator vs localeCompare

Created: 8 months 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 llama3.2:3b, generated 2 months ago):