Benchmark: Javascript: Case insensitive string comparison performance with indexOf

Script Preparation code:

var a = "John Doe"
var b = "john doe"
var c = "john smith"
var o = {
    sensitivity: 'base'
}

Tests:

toLowerCase()
a.toLowerCase().indexOf(b.toLowerCase()) !== -1
localeCompare()
a.localeCompare(b,undefined,o)
toLowerCase() FAIL
c.toLowerCase().indexOf(b.toLowerCase()) !== -1
localeCompare() FAIL
c.localeCompare(b,undefined,o)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
toLowerCase()
localeCompare()
toLowerCase() FAIL
localeCompare() FAIL

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36

Browser/OS: Chrome 118 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
toLowerCase()	10482137.0 Ops/sec
localeCompare()	186206.7 Ops/sec
toLowerCase() FAIL	10391943.0 Ops/sec
localeCompare() FAIL	188214.7 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Overview**

The benchmark is designed to measure the performance of two string comparison methods in JavaScript: `toLowerCase()` and `localeCompare()`. The test case uses three strings: "John Doe", "john doe", and "John Smith". The objective is to compare these strings in a case-insensitive manner.

**Options Compared**

Two options are compared:

1. **`toLowerCase()`**: This method converts the input string to lowercase using the `toLowerCase()` method.
2. **`localeCompare()`**: This method compares two strings, taking into account the locale and case of the characters being compared. The option is set to `'base'`, which means that only the base case comparison will be performed.

**Pros and Cons**

* **`toLowerCase()`**:
	+ Pros: Fast and widely supported.
	+ Cons: Loses case information and may not produce accurate results for non-English strings.
* **`localeCompare()`**:
	+ Pros: Provides a more accurate comparison by taking into account the locale and case of the characters being compared. Suitable for multi-language applications.
	+ Cons: May be slower than `toLowerCase()` due to the additional complexity of the locale comparison.

**Library**

The test case uses the `locale` API, which is part of the ECMAScript standard. The `localeCompare()` method uses the locale's collation rules to perform a case-insensitive comparison.

**Special JS Feature/Syntax**

This benchmark does not use any special JavaScript features or syntax beyond what is commonly available in modern browsers.

**Benchmark Results**

The latest benchmark results show that:

* `toLowerCase()` performs relatively well, with average executions per second (EPS) of 10482137.0 and 10391943.0 for the two test cases.
* `localeCompare()` performs slightly worse, with EPS of 188214.65625 and 186206.6875 for the two test cases.

**Alternatives**

If you're interested in exploring alternative string comparison methods or libraries, some options include:

1. **`String.prototype.localeCompare()`**: This method is similar to `localeCompare()`, but it returns a number indicating the result of the comparison (-1 if the first argument comes before the second, 0 if they are equal, and 1 if the first argument comes after the second).
2. **`Intl.Collator` API**: This API provides more advanced features for locale-based string comparison, such as support for multiple languages and custom collation rules.
3. **`DOMStringTokenizer`**: A library that provides a more efficient and customizable way to perform case-insensitive string comparisons.

Keep in mind that the choice of string comparison method or library depends on your specific use case and performance requirements.

Related benchmarks:

Javascript: Case insensitive string comparison performance with indexOf (version: 0)

Comparing performance of: toLowerCase() vs localeCompare() vs toLowerCase() FAIL vs localeCompare() FAIL

Created: 3 years ago by: Guest

Jump to the latest result

toLowerCase()

localeCompare()

toLowerCase() FAIL

localeCompare() FAIL

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