How to Compare Two Strings in JavaScript Case Insensitive

Comparing strings is a fundamental operation in any programming language, and JavaScript offers several ways to perform case-insensitive string comparisons. This article explores various methods, ranging from simple built-in functions to more specialized techniques for handling Unicode characters.

Case-Insensitive Comparison Methods in JavaScript

1. Using toLowerCase() or toUpperCase()

The simplest approach is to convert both strings to the same case (either lower or upper) before comparison:

const comStr = (s1, s2) => s1.toLowerCase() === s2.toLowerCase();

const s1 = "Hello";
const s2 = "hello";
console.log(comStr(s1, s2)); // Output: true

This method ensures consistent comparisons by eliminating case differences.

2. Using localeCompare()

The localeCompare() method offers a built-in solution for case-insensitive comparisons, also handling language-specific sorting rules:

const comStr = (s1, s2) => s1.localeCompare(s2, undefined, { sensitivity: 'accent' }) === 0;

const s1 = "Hello";
const s2 = "hello";
console.log(comStr(s1, s2)); // Output: true

The sensitivity: 'accent' option ignores case but considers accents for comparison.

3. Using Regular Expressions

Regular expressions with the i flag (case-insensitive) provide a flexible way to match strings:

const comStr = (s1, s2) => new RegExp(`^${s1}$`, "i").test(s2);

const s1 = "Hello";
const s2 = "hello";
console.log(comStr(s1, s2)); // Output: true

This approach is suitable for pattern matching but might be less efficient for simple equality checks.

4. Using normalize() for Unicode Strings

For strings with special characters or accents, normalize() combined with toLowerCase() ensures accurate comparison:

const comStr = (s1, s2) =>
  s1.normalize("NFD").toLowerCase() === s2.normalize("NFD").toLowerCase();

const s1 = "héllo";
const s2 = "HÉLLO";
console.log(comStr(s1, s2)); // Output: true

normalize() handles Unicode normalization before case conversion.

5. Using Array.every() for Character-by-Character Comparison

This method compares individual characters after converting them to lowercase:

const comStr = (s1, s2) =>
  s1.length === s2.length &&
  [...s1].every((char, index) => char.toLowerCase() === s2[index].toLowerCase());

const s1 = "Hello";
const s2 = "hello";
console.log(comStr(s1, s2)); // Output: true

This approach is less efficient but allows custom character-level processing.

Choosing the Right Approach

Approach	When to Use
toLowerCase()	Simplicity and efficiency in most cases.
localeCompare()	Multilingual applications or locale-sensitive needs.
Regular Expressions	Pattern-based or dynamic matching.
normalize()	Strings with accents or Unicode characters.
Character-by-Character	Custom logic or character-level processing.

For most common scenarios, toLowerCase() and localeCompare() offer the best balance of simplicity and performance. toLowerCase() is generally preferred for its straightforward implementation, while localeCompare() excels in internationalized applications. If performance is critical, benchmarking different methods with your specific use case is recommended.