Benchmark: Javascript: Case insensitive string comparison + Collators performance

Script Preparation code:

var a = "John Doe"
var b = "john doe"
var c = "john smith"
var o = {
    sensitivity: 'accent'
}
var r = new Intl.Collator('en-US', o)

Tests:

toLowerCase()
a.toLowerCase() === b.toLowerCase()
localeCompare() undef Culture
a.localeCompare(b,undefined,o)
toLowerCase() FAIL
c.toLowerCase() === b.toLowerCase()
localeCompare() FAIL
c.localeCompare(b,undefined,o)
toUpperCase
a.toUpperCase() === b.toUpperCase()
toUpperCase FAIL
c.toUpperCase() === c.toUpperCase()
Collator compare
r.compare(a, b)
Collator compare: Fail
r.compare(a, c)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
toLowerCase()
localeCompare() undef Culture
toLowerCase() FAIL
localeCompare() FAIL
toUpperCase
toUpperCase FAIL
Collator compare
Collator compare: Fail

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the details of the provided benchmark.

**Benchmark Definition**

The benchmark measures the performance of JavaScript string comparison methods, specifically `toLowerCase()`, `localeCompare()` with undefined culture and language, `toUpperCase()`, and the comparison method provided by the Intl.Collator API.

**Test Cases**

There are 6 test cases:

1. **`toLowerCase()`**: Compares the lowercased versions of two strings.
2. **`localeCompare()` without culture**: Compares two strings using locale-specific collation rules with undefined culture.
3. **`toLowerCase()` failure**: Compares a string that is not case-insensitive to another string.
4. **`localeCompare()` failure**: Compares two strings using locale-specific collation rules with an invalid culture.
5. **`toUpperCase()`**: Compares the uppercased versions of two strings.
6. **`Collator compare` ( Intl.Collator API)**: Compares two strings using the Intl.Collator API's comparison method.

**Library and Features**

The benchmark uses the following JavaScript library:

* `Intl.Collator`: Provides a way to work with locale-specific collation rules.

No special JavaScript features or syntax are used in this benchmark, except for the `Intl` object, which is part of the ECMAScript standard.

**Options Compared**

In each test case, two strings are compared using different methods:

* Case-insensitive comparison: `toLowerCase()` vs. non-case-insensitive comparison (e.g., direct string comparison)
* Locale-specific collation rules with undefined culture: `localeCompare()` without culture vs. unknown/culture-specific behavior
* Uppercasing: `toUpperCase()` vs. direct string comparison

**Pros and Cons of Different Approaches**

1. **`toLowerCase()`**: Pros:
	* Fast and efficient, as it simply converts both strings to lowercase.
	* Robust against case-insensitive variations.
Cons:
	* May not perform well on non-English characters or languages with complex collation rules.
2. **`localeCompare()` without culture**: Pros:
	+ Performs locale-specific collation rules, which can be useful for applications that require language-specific sorting.
	+ Fast and efficient.
Cons:
	+ Can exhibit unexpected behavior when used with unknown/culture-specific data.
3. **`toUpperCase()`**: Similar pros and cons to `toLowerCase()`, but in reverse.

**Other Alternatives**

If you need more control over the collation rules or want to support specific languages, consider using other string comparison methods:

* `String.prototype.localeCompare()`: Similar to `localeCompare()` but with a default culture.
* `DOMStringTokenizer` (for browsers): A built-in API for comparing strings in a way that takes into account locale-specific rules.

In summary, the benchmark compares different JavaScript string comparison methods to evaluate their performance and robustness. It highlights the trade-offs between case-insensitivity, locale-specific collation rules, and uppercasing.

Latest run results:

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

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

Browser/OS: Chrome 120 on Windows

View result in a separate tab

Test name	Executions per second
toLowerCase()	7654464.0 Ops/sec
localeCompare() undef Culture	158225.2 Ops/sec
toLowerCase() FAIL	7100892.5 Ops/sec
localeCompare() FAIL	161184.5 Ops/sec
toUpperCase	6972525.5 Ops/sec
toUpperCase FAIL	6859572.0 Ops/sec
Collator compare	3446555.8 Ops/sec
Collator compare: Fail	3964102.2 Ops/sec

Related benchmarks:

Javascript: Case insensitive string comparison + Collators performance (version: 0)

Comparing performance of: toLowerCase() vs localeCompare() undef Culture vs toLowerCase() FAIL vs localeCompare() FAIL vs toUpperCase vs toUpperCase FAIL vs Collator compare vs Collator compare: Fail

Created: one year ago by: Guest

Jump to the latest result

toLowerCase()

localeCompare() undef Culture

toLowerCase() FAIL

localeCompare() FAIL

toUpperCase

toUpperCase FAIL

Collator compare

Collator compare: Fail

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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