Benchmark: Javascript: Case insensitive string comparison

Script Preparation code:

var a = "soFt"
var b = "Software Development"
var c = "doFt"

Tests:

toLowerCase()
a.toLowerCase() === b.toLowerCase()
Regex
const re = new RegExp(a, "gi") re.test(b)
toLowerCase() FAIL
c.toLowerCase() === b.toLowerCase()
Regex FAIL
const re = new RegExp(c, "gi") re.test(b)

Historical Performance Data aggregated from 26 community runs

Desktop Results:

Chrome 26 runs

toLowerCase() FAIL

13.9M/s

toLowerCase()

13.9M/s

Regex FAIL

5.1M/s

Regex

4.9M/s

Fastest: toLowerCase() FAIL (2.9x faster)

View exact numbers

✓ toLowerCase() FAIL: 13,939,238 ops/sec
• toLowerCase(): 13,929,949 ops/sec
• Regex FAIL: 5,069,254 ops/sec
• Regex: 4,853,806 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36

Browser/OS: Chrome 136 on Linux

View result in a separate tab

toLowerCase() FAIL

69.8M/s

toLowerCase()

67.1M/s

Regex FAIL

4.9M/s

Regex

4.6M/s

View exact numbers

Test name	Executions per second
✓ toLowerCase() FAIL	69,830,112 Ops/sec
toLowerCase()	67,055,236 Ops/sec
Regex FAIL	4,944,880 Ops/sec
Regex	4,595,654 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what is being tested, compared, and the pros and cons of different approaches.

**Benchmark Definition**

The benchmark definition in JSON represents a JavaScript microbenchmark that tests case insensitive string comparison. It consists of three test cases:

1. `toLowerCase()`: Tests if two strings are equal after applying the `toLowerCase()` method.
2. `Regex`: Tests if two strings match using a regular expression (regex) with the `i` flag for case-insensitive matching.
3. `toLowerCase() FAIL` and `Regex FAIL`: These test cases are intentionally incorrect, with the first string not being compared to `b` or `c` after applying `toLowerCase()`.

**Script Preparation Code**

The script preparation code defines three strings:

* `a = "soFt"`
* `b = "Software Development"`
* `c = "doFt"`

These strings will be used as inputs for the benchmark tests.

**Html Preparation Code**

There is no HTML preparation code, which means that the benchmark does not rely on any HTML elements or attributes.

**Library Usage**

In two of the test cases (`Regex` and `Regex FAIL`), a regular expression (regex) object is created using the `new RegExp()` constructor. The regex pattern used is just the first string (`a` or `c`) without any modifications.

The regex library is not explicitly mentioned, but it's implied that the JavaScript engine uses its built-in regex implementation, which is part of the ECMAScript standard.

**Special JS Feature/Syntax**

There are no special JavaScript features or syntax used in this benchmark. The tests only rely on basic JavaScript operations and string manipulation methods (`toLowerCase()`).

**Pros and Cons of Different Approaches**

Here's a brief analysis of each approach:

1. `toLowerCase()`: This approach is straightforward, but it may not be efficient for large datasets or performance-critical applications.
	* Pros: Easy to implement and understand.
	* Cons: May lose case information during comparison.
2. `Regex`: Using regular expressions can be more flexible and powerful than string manipulation methods.
	* Pros: Can handle complex matching patterns, including case-insensitive matching with the `i` flag.
	* Cons: May have performance overhead due to regex compilation and execution.
3. `toLowerCase() FAIL` and `Regex FAIL`: These intentionally incorrect test cases are likely used for debugging or testing purposes, but they may not accurately reflect real-world usage scenarios.

**Other Alternatives**

If you want to explore alternative approaches, here are a few options:

* **Booleans**: Compare the strings as booleans using the `===` operator. This approach is simple and efficient but loses case information.
* **Case-insensitive comparison libraries**: There are several JavaScript libraries available that provide case-insensitive string comparison functions, such as `String.prototype.localeCompare()` or `case-less-string-comparison`.
* **Regular expressions with negative lookahead**: Use regular expressions with negative lookahead (`(?=...)`) to avoid losing case information during matching. For example: `a + "(?i)" + b`.

Keep in mind that the choice of approach depends on the specific requirements and constraints of your project.

Javascript: Case insensitive string comparison (version: 0)

Comparing performance of: `toLowerCase() vs Regex vs toLowerCase() FAIL vs Regex FAIL`

Created: 5 years ago by: Guest

Go to the latest result

toLowerCase()

Regex

toLowerCase() FAIL

Regex FAIL

Historical Performance Data aggregated from 26 community runs

Desktop Results:

Chrome 26 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Javascript: Case insensitive string comparison (version: 0)

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

Created: 5 years ago by: Guest

Go to the latest result

toLowerCase()

Regex

toLowerCase() FAIL

Regex FAIL

Historical Performance Data aggregated from 26 community runs

Desktop Results:

Chrome 26 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `toLowerCase() vs Regex vs toLowerCase() FAIL vs Regex FAIL`