JavaScript String toLocaleUpperCase() Method

What You’ll Learn

String.prototype.toLocaleUpperCase() returns a new uppercased string using locale-specific case rules (same API as MDN String.prototype.toLocaleUpperCase()). Learn the optional locales argument, why Turkish istanbul becomes İSTANBUL, Lithuanian combining-dot rules, how it compares to toUpperCase(), five examples, and try-it labs.

Introduction

Need uppercase text that respects a language’s alphabet rules — not only English Unicode defaults? toLocaleUpperCase() applies locale-specific case mappings.

For everyday English or ASCII, the result usually matches toUpperCase(). For languages like Turkish, the dotted/dotless i family differs, so passing the right locales tag matters for display and comparisons.

This page is part of JavaScript String Methods. Related topics include toLocaleLowerCase() and localeCompare().

Understanding the toLocaleUpperCase() Method

str.toLocaleUpperCase(locales?) builds a new string where each character is uppercased according to the chosen locale’s rules (or the host default when you omit locales).

• Returns a new string — the original is unchanged.
• Optional locales: one BCP 47 tag or an array of tags.
• Unlike Intl.Collator, there is no locale matching — the first tag wins.
• Length may change (one character can become two or more when uppercased).
• Most locales match toUpperCase(); Turkish is the classic exception.

📝 Syntax

General form of String.prototype.toLocaleUpperCase:

str.toLocaleUpperCase()
str.toLocaleUpperCase(locales)

Parameters

• locales (optional) — a BCP 47 language tag (e.g. "en-US", "TR") or an array of tags. After validation, only the first locale is used (or the default locale if the list is empty). There is no fallback matching like other Intl APIs.

Return value

A new string representing the calling string converted to upper case according to locale-specific case mappings.

Exceptions

RangeError if a locale identifier is structurally invalid (same family of checks as other Intl locale arguments).

Common patterns

"alphabet".toLocaleUpperCase();           // "ALPHABET"
"istanbul".toLocaleUpperCase("en-US");    // "ISTANBUL"
"istanbul".toLocaleUpperCase("TR");       // "İSTANBUL"
"Gesäß".toLocaleUpperCase();              // "GESÄSS"
"hello".toLocaleUpperCase() === "hello".toUpperCase(); // usually true

Examples Gallery

Examples follow MDN String.toLocaleUpperCase() patterns. Use View Output or Try It Yourself for each case.

"alphabet".toLocaleUpperCase();
// "ALPHABET"

ALPHABET

const city = "istanbul";

console.log(city.toLocaleUpperCase("en-US"));
// Expected output: "ISTANBUL"

console.log(city.toLocaleUpperCase("TR"));
// Expected output: "İSTANBUL"

ISTANBUL
İSTANBUL

"Gesäß".toLocaleUpperCase();
// "GESÄSS"

console.log("Gesäß".length);                 // 5
console.log("Gesäß".toLocaleUpperCase().length); // 6

GESÄSS
5
6

"i\u0307".toLocaleUpperCase("lt-LT");
// "I"

const locales = ["lt", "LT", "lt-LT", "lt-u-co-phonebk", "lt-x-lietuva"];
"i\u0307".toLocaleUpperCase(locales);
// "I"

I
I

function displayTitle(text, locale) {
  return text.toLocaleUpperCase(locale);
}

const city = "istanbul guide";
const en = displayTitle(city, "en-US");
const tr = displayTitle(city, "TR");

console.log(en === tr);              // false — İ vs I
console.log(tr.startsWith("İ"));     // true
console.log("mixed".toLocaleUpperCase() === "mixed".toUpperCase()); // true

false
true
true

🎯 Common Use Cases

• Localized UI titles — ALL CAPS headings in the user’s language.
• Search / filter prep — normalize case before comparing Turkish (or similar) text.
• Multilingual apps — pair with toLocaleLowerCase and the same locale tag.
• Not always needed — for ASCII-only codes and IDs, toUpperCase() is fine.
• Not for sorting — use localeCompare / Intl.Collator for order.

📝 Notes

• In most cases the result equals toUpperCase() — locale differences show up for specific languages.
• Locale arrays do not fall back: the first tag is always chosen after validation.
• Case conversion can change string length (e.g. ß → SS).
• Round-trips are not always stable: x.toLocaleLowerCase() === x.toLocaleUpperCase().toLocaleLowerCase() can be false.
• Pair with toLocaleLowerCase() when you need the matching lowercase path.

💡 Best Practices