Optimum way to compare strings in JavaScript?

Detailed discussion: Other string comparison techniques

Mimicking strcmp function

To simulate the strcmp() function from your favourite C-like languages in JavaScript, you could define a function like:

// "I'll be back", but with strings instead of robots.
function strcmp(a, b) {
  return a < b ? -1 : a > b ? 1 : 0;
}


This function compares two strings a and b, and returns -1 if a is less than b, 1 if a is greater than b, and 0 if they are identical.

Binary search optimization

In a collection of strings, binary search can minimize the number of necessary string comparisons:

// "The fewer, the better" - every collection of strings, probably.
function binarySearch(arr, x) {
  let start= 0, end= arr.length - 1;

  while (start <= end) {
    let mid= Math.floor((start + end) / 2);

    let res = x.localeCompare(arr[mid]);

    if (res == 0) return mid; 

    if (res > 0) start = mid + 1; 

    else end = mid - 1; 
  }
  return false; 
}


One comparison per iteration, just like good ol' grandma's recipes.

Ternary operator for efficiency

Given you love one-liners and brevity, the ternary operator can provide a concise syntax without sacrificing efficiency:

// Same working hours, less code. Efficiency at its best!
const compare = (a, b) => (a < b ? -1 : a > b ? 1 : 0);


ASCII vs Unicode surprise

Remember that JavaScript uses the Unicode values of characters for comparison by default, therefore case-sensitivity is a thing. Be sure to convert both strings to the same case (toLowerCase() or toUpperCase()) before comparing, if case doesn't matter in your use case.

Loop and early exit strategy

What if you're comparing War and Peace to Moby-Dick? To boost performance with large strings, compare them character by character and exit at the very moment you find a difference:

// "Hit the gym early, hit the bed early." - every large string, maybe.
function strcmp(a, b) {
  const len = Math.min(a.length, b.length);
  for (let i = 0; i < len; i++) {
    if (a[i] !== b[i]) {
      return a[i] < b[i] ? -1 : 1;
    }
  }
  return a.length - b.length;
}


This strcmp() is an upgraded version that favors an early exit whenever a difference pops up.

Living in a Unicode world

When the strings harmoniously exist under international/Unicode characters gloom, localeCompare() and normalization are your trusty companions.

Unicode normalization

By calling the normalize() method, ensure both strings are in the same Unicode normalization form:

// Equilibrium restored!
'aé'.normalize() === 'aé'.normalize()   // true


Locale-aware comparison

To perform a locale-dependent comparison, you could use localeCompare() with options:

// No more accent-prejudice in English
'a'.localeCompare('ä', 'en', { sensitivity: 'base' }) // 0, assumed being same


Meet the Collator

For an all-inclusive collation support, consider using Intl.Collator. As the name suggests, it's designed for comparing strings according to the rules of the specific language:

// Who knows all the "a" characters in German? This collator buddy.
const collator = new Intl.Collator('de');
collator.compare('a', 'ä') // a specific value depending on the locale


Stay on guard: Common pitfalls and alternatives

Case sensitivity

JavaScript string comparison is case-sensitive by default. Consider converting strings to the same case for a case-insensitive comparison:

// "We scream, we shout, we're all the same."
'a'.toLowerCase() === 'A'.toLowerCase() // true


Performance caveat

Methods like localeCompare() might be slower than simple operators (>, <, and ==) in handling large-scale operations. So, performance profiling is highly recommended:

// Ready, set, track!
console.time('Comparison');
// (The string comparison operation that needs to be timed goes here)
console.timeEnd('Comparison');


Memory consumption

Memory usage could go high if temporary strings are created for case conversion or normalization. When working in a memory-constrained environment, methods avoiding new string creation might be preferred.