JavaScript String localeCompare() Method

What You’ll Learn

String.prototype.localeCompare() returns a number that tells you how two strings order in a given language (same API as MDN String.prototype.localeCompare()). Learn negative / positive / 0 results, locales and options, sensitivity, numeric sorting, when to prefer Intl.Collator, five examples, and try-it labs.

Introduction

Sorting names, product titles, or filenames often needs language rules — not raw character codes. In German, "ä" may sort near "a"; in Swedish it can sort after "z". That is what localeCompare() is for.

It returns a number you can use in Array.prototype.sort: negative means “this string comes first,” positive means “comes later,” and 0 means “same for this comparison.” Engines with Intl.Collator support delegate to that API.

This page is part of JavaScript String Methods. Related topics include includes() and indexOf().

Understanding the localeCompare() Method

Call referenceStr.localeCompare(compareString) to ask: “Where does referenceStr sit relative to compareString in sort order?”

• Negative — referenceStr comes before compareString.
• Positive — referenceStr comes after compareString.
• Zero — they are equivalent for the chosen locale / options.
• Optional locales and options customize language rules (same idea as Intl.Collator).

📝 Syntax

General forms of String.prototype.localeCompare:

str.localeCompare(compareString)
str.localeCompare(compareString, locales)
str.localeCompare(compareString, locales, options)

Parameters

• compareString — the string to compare against. Coerced to a string (undefined becomes "undefined").
• locales (optional) — a BCP 47 language tag (e.g. "fr", "de", "sv") or an array of tags. Ignored on rare engines without Intl.Collator.
• options (optional) — an options object (same shape as Intl.Collator), e.g. { sensitivity: "base" }, { numeric: true }, { ignorePunctuation: true }.

Return value

A number. Special cases:

Common patterns

Math.sign("a".localeCompare("c"));      // -1  (before)
Math.sign("check".localeCompare("against")); // 1 (after)
"a".localeCompare("a");                 // 0

// Sort an array (French + ignore punctuation):
const items = ["réservé", "Premier", "café", "Adieu"];
items.sort((a, b) => a.localeCompare(b, "fr", { ignorePunctuation: true }));

// Many comparisons → reuse a collator:
const collator = new Intl.Collator("en", { sensitivity: "base" });
items.sort(collator.compare);

Examples Gallery

Examples follow MDN String.localeCompare() patterns. Use View Output or Try It Yourself for each case. Outputs use Math.sign where engines may differ on exact integers.

Math.sign("a".localeCompare("c"));           // -1  (before)
Math.sign("check".localeCompare("against")); // 1   (after)
"a".localeCompare("a");                      // 0   (equal)

// In sort callbacks, return the number directly:
["c", "a", "b"].sort((x, y) => x.localeCompare(y));
// ["a", "b", "c"]

-1
1
0
a,b,c

const a = "réservé"; // accents, lowercase
const b = "RESERVE"; // no accents, uppercase

Math.sign(a.localeCompare(b));  // 1  (not equal by default)

a.localeCompare(b, "en", { sensitivity: "base" });
// 0  — same base letters

1
0

Math.sign("ä".localeCompare("z", "de")); // -1  (ä before z in German)
Math.sign("ä".localeCompare("z", "sv")); // 1   (ä after z in Swedish)

"ä".localeCompare("a", "de", { sensitivity: "base" }); // 0
Math.sign("ä".localeCompare("a", "sv", { sensitivity: "base" })); // 1

-1
1
0
1

const items = ["réservé", "Premier", "Cliché", "communiqué", "café", "Adieu"];

items.sort((a, b) => a.localeCompare(b, "fr", { ignorePunctuation: true }));
// ['Adieu', 'café', 'Cliché', 'communiqué', 'Premier', 'réservé']

Adieu
café
Cliché
communiqué
Premier
réservé

Math.sign("2".localeCompare("10"));  // 1  ("2" after "10" by default)

Math.sign("2".localeCompare("10", undefined, { numeric: true })); // -1

Math.sign("2".localeCompare("10", "en-u-kn-true")); // -1  (Unicode extension)

["10", "2", "1"].sort((a, b) =>
  a.localeCompare(b, undefined, { numeric: true })
);
// ["1", "2", "10"]

1
-1
-1
1,2,10

🚀 Common Use Cases

• Sorting UI lists — names, titles, countries in the user’s language.
• Case- / accent-insensitive equality — sensitivity: "base" and check for 0.
• Natural number order in strings — numeric: true for "item2" vs "item10".
• Locale-specific rules — pass "de", "sv", "fr", etc.
• Large sorts — prefer a reused Intl.Collator.
• Not for simple contains checks — use includes() / indexOf() instead.

📝 Notes

• Do not rely on exact -1 / 1 — only the sign (or 0) is guaranteed.
• Pass locales when the UI language must control sort order.
• Omitting the compare string (or passing undefined) compares against "undefined".
• For many comparisons with the same rules, reuse Intl.Collator.
• < / > are not locale-aware — prefer localeCompare for human-facing order.
• Results can still differ slightly across engines for edge cases; lock locales + options for consistency.

💡 Best Practices