Benchmark: String compares (sensitive & insensitive)

Script Preparation code:

var a = 'aBcD eFgH iJkLmN'
var b = 'AbCd eFgH iJkLmN'
var c = 'aBcD eFgH iJkLmNx'
var d = 'aBcD eFgH iJkLmn'

var enCollator = new Intl.Collator('en', { sensitivity: 'accent' });

Tests:

LowerCase compare a&b
a.toLowerCase() === b.toLowerCase()
Collator compare
enCollator.compare(a, b) === 0
UpperCase compare
a.toUpperCase() === b.toUpperCase()
Sensitive compare
a === b
Lower a & c
a.toLowerCase() === c.toLowerCase()
Lower a & d
a.toLowerCase() === d.toLowerCase()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
LowerCase compare a&b
Collator compare
UpperCase compare
Sensitive compare
Lower a & c
Lower a & d

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what is being tested, compared, and the pros/cons of each approach.

**Benchmark Definition**

The benchmark definition is represented by the `Script Preparation Code` section, which includes:
```javascript
var a = 'aBcD eFgH iJkLmN'
var b = 'AbCd eFgH iKlLmn'
var c = 'aBcD eFgH iKlLn'
var d = 'aBcD eFgH iJkLmn'

var enCollator = new Intl.Collator('en', { sensitivity: 'accent' });
```
This script prepares four strings, `a`, `b`, `c`, and `d`, which are variations of the same string with different characters (e.g., "i" vs. "I", "l" vs. "L"). The `enCollator` object is used to perform case-insensitive comparisons.

**Individual Test Cases**

The test cases are represented by an array of objects, each containing a `Benchmark Definition` and a `Test Name`. There are six test cases:

1. `LowerCase compare a&b`: Compares the lowercase versions of strings `a` and `b`.
2. `Collator compare`: Uses the `enCollator` object to compare strings `a` and `b`.
3. `UpperCase compare`: Compares the uppercase versions of strings `a` and `b`.
4. `Sensitive compare`: Performs a case-sensitive comparison between strings `a` and `b`.
5. `Lower a & c`
6. `Lower a & d`

**Options Compared**

The following options are compared:

1. Case-insensitive vs. case-sensitive comparisons
2. Use of the `Intl.Collator` object vs. simple string comparisons

**Pros/Cons**

Here's a brief analysis of each option:

1. **Case-insensitive (e.g., `toLowerCase()` or `enCollator`)**
	* Pros:
		+ Handles accent marks and non-ASCII characters
		+ Reduces false positives in case-sensitive comparisons
	* Cons:
		+ May introduce additional overhead due to the need for locale-specific data
		+ Requires careful consideration of cultural nuances and character encoding
2. **Case-sensitive (e.g., `===` without modifying strings)**
	* Pros:
		+ Simple and straightforward implementation
		+ Fast execution, as no modifications are required
	* Cons:
		+ May produce false positives with non-ASCII characters or accent marks

**Library: Intl.Collator**

The `Intl.Collator` object is a part of the Internationalization API in JavaScript. It provides a way to compare strings in a culturally sensitive manner, taking into account factors such as language, script, and locale.

In this benchmark, `enCollator` is used to perform case-insensitive comparisons between strings. The `sensitivity` option is set to `'accent'`, which means the collator will consider accent marks when comparing strings.

**Special JS Feature or Syntax**

None of the test cases use any special JavaScript features or syntax beyond standard JavaScript string comparison operators and the `Intl.Collator` object.

**Alternatives**

If you don't want to use the `Intl.Collator` object, you can implement your own case-insensitive comparison function using a combination of techniques such as:

1. Unicode normalization
2. Character mapping (e.g., using a `Map` or an object)
3. Regular expressions

However, these alternatives may be more complex and error-prone than using the built-in `Intl.Collator` object.

Keep in mind that this is just a brief explanation of the benchmark. If you have any specific questions or need further clarification on any aspect of the benchmark, feel free to ask!

Latest run results:

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

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

Browser/OS: Chrome 105 on Windows

View result in a separate tab

Test name	Executions per second
LowerCase compare a&b	8176681.5 Ops/sec
Collator compare	3301654.8 Ops/sec
UpperCase compare	7484132.0 Ops/sec
Sensitive compare	9348849.0 Ops/sec
Lower a & c	8079426.0 Ops/sec
Lower a & d	8091027.5 Ops/sec

Related benchmarks:

String compares (sensitive & insensitive) (version: 0)

Comparing performance of: LowerCase compare a&b vs Collator compare vs UpperCase compare vs Sensitive compare vs Lower a & c vs Lower a & d

Created: 2 years ago by: Guest

Jump to the latest result

LowerCase compare a&b

Collator compare

UpperCase compare

Sensitive compare

Lower a & c

Lower a & d

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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