JavaScript String normalize() Method

What You’ll Learn

String.prototype.normalize() returns the Unicode Normalization Form of a string (same API as MDN String.prototype.normalize()). Learn why lookalike strings can fail ===, the four forms (NFC, NFD, NFKC, NFKD), composed vs decomposed accents, compatibility ligatures, five examples, and try-it labs.

Introduction

Unicode sometimes has more than one way to store the same character. The letter "é" can be one code point, or "e" plus a combining accent. Both look like Amélie — but === says they are different, and even length can differ.

normalize() converts a string into a shared form so equivalent sequences compare equal. Pick a form once (usually "NFC") and use it before comparing, sorting keys, or storing text.

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

Understanding the normalize() Method

Calling str.normalize(form) returns a new string in the chosen Unicode Normalization Form. It does not edit str in place.

• NFC / NFD — canonical equivalence (same abstract character, same appearance).
• NFKC / NFKD — compatibility equivalence (treat ligatures / fancy symbols alike for some apps).
• C forms are composed; D forms are decomposed.
• Invalid form — throws RangeError.

📝 Syntax

General forms of String.prototype.normalize:

str.normalize()
str.normalize(form)

Parameters

• form (optional) — "NFC", "NFD", "NFKC", or "NFKD". If omitted or undefined, "NFC" is used.

Return value

A string in the requested normalization form:

Common patterns

const a = "\u00e9";           // é as one code point
const b = "e\u0301";          // e + combining acute

a === b;                      // false
a.normalize() === b.normalize(); // true  (both NFC)

// Stable compare helper:
function sameText(x, y) {
  return x.normalize("NFC") === y.normalize("NFC");
}

Examples Gallery

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

const name1 = "\u0041\u006d\u00e9\u006c\u0069\u0065"; // Amélie (composed é)
const name2 = "\u0041\u006d\u0065\u0301\u006c\u0069\u0065"; // Amélie (e + accent)

name1 === name2;           // false
name1.length === name2.length; // false (6 vs 7)

const name1NFC = name1.normalize("NFC");
const name2NFC = name2.normalize("NFC");

name1NFC === name2NFC;     // true
name1NFC.length === name2NFC.length; // true

false
false
true
true

const string1 = "\u00F1";       // ñ
const string2 = "\u006E\u0303"; // n + combining tilde

string1 === string2;  // false
string1.length;       // 1
string2.length;       // 2

string1.normalize("NFD") === string2.normalize("NFD"); // true (both length 2)
string1.normalize("NFC") === string2.normalize("NFC"); // true (both length 1)

string2.normalize("NFC").codePointAt(0).toString(16); // "f1"

false
1
2
true
true
f1

let string1 = "\uFB00";         // ff ligature
let string2 = "\u0066\u0066";   // ff

string1 === string2;            // false
string1.length;                 // 1
string2.length;                 // 2

string1 = string1.normalize("NFKD");
string2 = string2.normalize("NFKD");

string1;                        // "ff"  (appearance changed)
string1 === string2;            // true
string1.length;                 // 2

false
1
2
ff
true
2

// U+1E9B LATIN SMALL LETTER LONG S WITH DOT ABOVE
// U+0323 COMBINING DOT BELOW
const str = "\u1E9B\u0323";

str.normalize("NFC");   // same as str.normalize()
str.normalize("NFD");   // long s + dot below + dot above
str.normalize("NFKC");  // single compatibility character U+1E69
str.normalize("NFKD");  // plain s + combining dots

// Inspect code points (hex):
[...str.normalize("NFD")].map((c) => c.codePointAt(0).toString(16));
// ["17f", "323", "307"]

str.normalize("NFKC").codePointAt(0).toString(16); // "1e69"

NFD: 17f 323 307
NFKC: 1e69
NFKD: 73 323 307

"hello".normalize();        // "hello" (NFC)
"hello".normalize("NFC");   // "hello"

try {
  "hello".normalize("XYZ");
} catch (e) {
  console.log(e.name);      // RangeError
}

hello
hello
RangeError

🚀 Common Use Cases

• Equality checks — normalize both strings before ===.
• Database / cache keys — store NFC so the same word always hashes the same.
• Search indexing — NFKC/NFKD to fold ligatures and fancy symbols.
• Form input cleanup — normalize user text on save.
• Not a substitute for locale sort — still use localeCompare for language order.
• Not the same as isWellFormed — that checks lone surrogates, not accents.

📝 Notes

• Default form is "NFC" when you omit the argument.
• Normalize both sides before equality checks.
• NFC/NFD preserve visual identity for canonical pairs; NFKC/NFKD may change appearance.
• Invalid form throws RangeError.
• This is unrelated to isWellFormed() / lone surrogates.
• For human sort order across languages, still prefer localeCompare.

💡 Best Practices