Benchmark: Test 1231241123 - MeasureThat.net

Script Preparation code:

var a = "John Doe Is NOT A Really Long Name"
var b = "JOHN DOE IS not A REALLY LONG NAME"


function isEqualToIgnoreCase1(stringA, stringB) {
    if (stringA && stringB) {
        return stringA.toLowerCase() === stringB.toLowerCase()
    }

    return stringA === stringB;
}

var options = {
    sensitivity: 'accent'
};

function isEqualToIgnoreCase2(stringA, stringB) {
    return stringA.localeCompare(stringB, undefined, options) === 0;
}

var collatorBase = Intl.Collator(undefined, { sensitivity: 'base' });

function isEqualToIgnoreCase3(stringA, stringB) {
    return collatorBase.compare(stringA,stringB) === 0;
}

var collatorAccent = Intl.Collator(undefined, { sensitivity: 'accent' });

function isEqualToIgnoreCase4(stringA, stringB) {
    return collatorAccent.compare(stringA,stringB) === 0;
}

Tests:

toLowerCase
isEqualToIgnoreCase1(a,b)
Locale
isEqualToIgnoreCase2(a,b)
Collator
isEqualToIgnoreCase3(a,b)
Collator Accent
isEqualToIgnoreCase4(a,b)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
toLowerCase
Locale
Collator
Collator Accent

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 break down what's being tested on MeasureThat.net.

**Overview**

The benchmark is designed to compare the performance of three different approaches for case-insensitive string comparison:

1. `toLowerCase()` method
2. `localeCompare()` method with locale-specific collation rules
3. `compare()` method from the Internationalization API (Intl) using a base collator and accent-sensitive collator

**Options compared**

The options being compared are:

* Sensitivity of the collation rules:
	+ `'accent'`: compares strings based on accents, ensuring that words with the same letters but different accents are not considered equal.
	+ `'base'`: compares strings based on their base characters (i.e., ignoring accents).
	+ `undefined` or missing: uses the default locale-specific collation rules.

**Pros and Cons**

Here's a brief summary of each approach:

* **toLowerCase() method**:
	+ Pros: simple, widely supported, and fast.
	+ Cons: may not handle accented characters correctly, as it depends on the browser's character encoding settings.
* **localeCompare() method with locale-specific collation rules**:
	+ Pros: handles accents correctly, provides a more accurate comparison, and is locale-aware.
	+ Cons: may be slower than `toLowerCase()` due to the additional processing required by locale-specific rules.
* **compare() method from Intl API using base collator and accent-sensitive collator**:
	+ Pros: highly customizable, precise control over collation rules, and fast.
	+ Cons: requires a good understanding of the Intl API and its configuration options.

**Library and syntax**

The benchmark uses various libraries and syntax features:

* The `localeCompare()` method is part of the ECMAScript Standard, but it's specific to modern browsers that support the Intl API. MeasureThat.net provides a fallback for older browsers using the `toLowerCase()` method.
* The `compare()` method from the Intl API is used in the "Collator" and "Collator Accent" test cases.

**Special JS features**

The benchmark takes advantage of JavaScript's built-in features, such as:

* String interpolation (`var b = \"JOHN DOE IS not A REALLY LONG NAME\"\r\n`)
* Function definitions (`function isEqualToIgnoreCase1(stringA, stringB) { ... }`)

**Other alternatives**

If you need to implement case-insensitive string comparison in your own code, consider the following alternatives:

* Use a library like ICU or UnicodeNormalizer for more precise and customizable collation rules.
* Implement a custom solution using regular expressions or character encoding-specific APIs.

Keep in mind that each approach has its trade-offs, and the best choice depends on your specific requirements, performance needs, and target audience.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 116 on Windows

View result in a separate tab

Test name	Executions per second
toLowerCase	9863926.0 Ops/sec
Locale	281520.7 Ops/sec
Collator	4159207.0 Ops/sec
Collator Accent	3492119.2 Ops/sec

Related benchmarks:

Test 1231241123 (version: 10)

Comparing performance of: toLowerCase vs Locale vs Collator vs Collator Accent

Created: one year ago by: Registered User

Jump to the latest result

toLowerCase

Locale

Collator

Collator Accent

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