So passen Sie Locales mit Unicode-Erweiterungen an

Fügen Sie Kalendersysteme, Zahlenformate und Zeitanzeigeeinstellungen zu Locale-Identifikatoren hinzu

Einführung

Ein Locale-Identifikator wie en-US teilt JavaScript mit, welche Sprache und Region für die Formatierung verwendet werden sollen. Er gibt jedoch nicht an, welches Kalendersystem verwendet werden soll, welches Zahlenformat angezeigt werden soll oder ob die Zeit im 12-Stunden- oder 24-Stunden-Format angezeigt werden soll. Diese Formatierungseinstellungen variieren je nach Benutzerwahl, nicht nur nach Standort.

Unicode-Erweiterungen lösen dieses Problem. Sie ermöglichen es Ihnen, Formatierungseinstellungen direkt zu Locale-Identifikatoren hinzuzufügen. Anstatt separate Konfigurationsoptionen für jeden Formatierer zu verwenden, kodieren Sie die Einstellungen einmal im Locale-String selbst.

Dieser Leitfaden erklärt, wie Unicode-Erweiterungen funktionieren, welche Erweiterungstypen verfügbar sind und wann Sie sie in Ihrem Internationalisierungscode verwenden sollten.

Was sind Unicode-Erweiterungen

Unicode-Erweiterungen sind zusätzliche Tags, die Sie zu Locale-Identifikatoren hinzufügen, um Formatierungseinstellungen anzugeben. Sie folgen einem Standardformat, das in BCP 47 definiert ist, derselben Spezifikation, die Locale-Identifikatoren definiert.

Eine Erweiterung beginnt mit -u-, gefolgt von Schlüssel-Wert-Paaren. Das u steht für Unicode. Jeder Schlüssel besteht aus zwei Buchstaben, und die Werte variieren je nach Schlüsseltyp.

const locale = "en-US-u-ca-gregory-hc-h12";

Dieser Locale-Identifikator gibt amerikanisches Englisch mit dem gregorianischen Kalender und 12-Stunden-Zeitanzeige an.

So fügen Sie Erweiterungen zu Locale-Strings hinzu

Erweiterungen erscheinen am Ende eines Locale-Identifikators, nach den Komponenten für Sprache, Schrift und Region. Der -u--Marker trennt den Kernidentifikator von den Erweiterungen.

Die grundlegende Struktur folgt diesem Muster:

language-region-u-key-value-key-value

Jedes Schlüssel-Wert-Paar gibt eine Formatierungspräferenz an. Sie können mehrere Schlüssel-Wert-Paare in einer einzelnen Locale-Zeichenkette angeben.

const japanese = new Intl.Locale("ja-JP-u-ca-japanese-nu-jpan");
console.log(japanese.calendar); // "japanese"
console.log(japanese.numberingSystem); // "jpan"

Die Reihenfolge der Schlüssel-Wert-Paare spielt keine Rolle. Sowohl "en-u-ca-gregory-nu-latn" als auch "en-u-nu-latn-ca-gregory" sind gültig und gleichwertig.

Kalendererweiterungen

Der Schlüssel ca gibt an, welches Kalendersystem für die Datumsformatierung verwendet werden soll. Verschiedene Kulturen verwenden unterschiedliche Kalendersysteme, und einige Benutzer bevorzugen aus religiösen oder kulturellen Gründen nicht-gregorianische Kalender.

Häufige Kalenderwerte umfassen:

  • gregory für den gregorianischen Kalender
  • buddhist für den buddhistischen Kalender
  • islamic für den islamischen Kalender
  • hebrew für den hebräischen Kalender
  • chinese für den chinesischen Kalender
  • japanese für den japanischen Kaiserkalender
const islamicLocale = new Intl.Locale("ar-SA-u-ca-islamic");
const date = new Date("2025-03-15");
const formatter = new Intl.DateTimeFormat(islamicLocale, {
  year: "numeric",
  month: "long",
  day: "numeric"
});

console.log(formatter.format(date));
// Output: "٢٠ رمضان ١٤٤٦ هـ"

Dies formatiert das Datum gemäß dem islamischen Kalender. Dasselbe gregorianische Datum erscheint als ein anderes Jahr, Monat und Tag im islamischen Kalendersystem.

Der buddhistische Kalender wird häufig in Thailand verwendet. Er zählt die Jahre ab Buddhas Geburt im Jahr 543 v. Chr., wodurch buddhistische Jahre 543 Jahre vor den gregorianischen Jahren liegen.

const buddhistLocale = new Intl.Locale("th-TH-u-ca-buddhist");
const formatter = new Intl.DateTimeFormat(buddhistLocale, {
  year: "numeric",
  month: "long",
  day: "numeric"
});

console.log(formatter.format(new Date("2025-03-15")));
// Output: "15 มีนาคม 2568"

Das Jahr 2025 im gregorianischen Kalender ist 2568 im buddhistischen Kalender.

Zahlensystemerweiterungen

Der Schlüssel nu gibt an, welches Zahlensystem für die Anzeige von Zahlen verwendet werden soll. Während die meisten Locales westlich-arabische Ziffern (0-9) verwenden, haben viele Regionen ihre eigenen traditionellen Zahlensysteme.

Häufige Zahlensystemwerte umfassen:

  • latn für westlich-arabische Ziffern (0-9)
  • arab für arabisch-indische Ziffern
  • hanidec für chinesische Dezimalziffern
  • deva für Devanagari-Ziffern
  • thai für thailändische Ziffern
const arabicLocale = new Intl.Locale("ar-EG-u-nu-arab");
const number = 123456;
const formatter = new Intl.NumberFormat(arabicLocale);

console.log(formatter.format(number));
// Output: "١٢٣٬٤٥٦"

Arabisch-indische Ziffern sehen anders aus als westliche Ziffern, repräsentieren jedoch dieselben Werte. Die Zahl 123456 erscheint als ١٢٣٬٤٥٦.

Thailändische Ziffern bieten ein weiteres Beispiel:

const thaiLocale = new Intl.Locale("th-TH-u-nu-thai");
const formatter = new Intl.NumberFormat(thaiLocale);

console.log(formatter.format(123456));
// Output: "๑๒๓,๔๕๖"

Viele arabische Gebietsschemata unterstützen sowohl arabisch-indische als auch lateinische Ziffern. Benutzer können ihr bevorzugtes System basierend auf persönlichen Präferenzen oder Kontext wählen.

Stundenzyklus-Erweiterungen

Der hc-Schlüssel gibt an, wie die Uhrzeit angezeigt werden soll. Einige Regionen bevorzugen das 12-Stunden-Format mit AM- und PM-Indikatoren, während andere das 24-Stunden-Format bevorzugen. Der Stundenzyklus bestimmt auch, wie Mitternacht dargestellt wird.

Vier Stundenzyklus-Werte sind verfügbar:

  • h12 verwendet Stunden 1–12 mit Mitternacht um 12:00 AM
  • h11 verwendet Stunden 0–11 mit Mitternacht um 0:00 AM
  • h23 verwendet Stunden 0–23 mit Mitternacht um 0:00
  • h24 verwendet Stunden 1–24 mit Mitternacht um 24:00

Die Werte h12 und h11 repräsentieren das 12-Stunden-Format, während h23 und h24 das 24-Stunden-Format repräsentieren. Der Unterschied liegt darin, ob der Stundenbereich bei 0 oder 1 beginnt.

const us12Hour = new Intl.Locale("en-US-u-hc-h12");
const japan11Hour = new Intl.Locale("ja-JP-u-hc-h11");
const europe23Hour = new Intl.Locale("en-GB-u-hc-h23");

const date = new Date("2025-03-15T00:30:00");

console.log(new Intl.DateTimeFormat(us12Hour, { hour: "numeric", minute: "numeric" }).format(date));
// Output: "12:30 AM"

console.log(new Intl.DateTimeFormat(japan11Hour, { hour: "numeric", minute: "numeric" }).format(date));
// Output: "0:30 AM"

console.log(new Intl.DateTimeFormat(europe23Hour, { hour: "numeric", minute: "numeric" }).format(date));
// Output: "00:30"

Das h12-Format zeigt Mitternacht als 12:30 AM an, während h11 sie als 0:30 AM anzeigt. Das h23-Format zeigt sie als 00:30 ohne AM oder PM an.

Die meisten Anwendungen verwenden entweder h12 oder h23. Das h11-Format wird hauptsächlich in Japan verwendet, und h24 wird in der Praxis selten verwendet.

Kollations-Erweiterungen

Der co-Schlüssel gibt Kollationsregeln für die Sortierung von Zeichenketten an. Die Kollation bestimmt die Reihenfolge der Zeichen beim Sortieren von Text. Verschiedene Sprachen und Regionen haben unterschiedliche Sortierkonventionen.

Gängige Sortierungswerte umfassen:

  • standard für standardmäßige Unicode-Sortierung
  • phonebk für Telefonbuch-Sortierung (Deutsch)
  • pinyin für Pinyin-Sortierung (Chinesisch)
  • stroke für Strichzahl-Sortierung (Chinesisch)

Die deutsche Telefonbuch-Sortierung behandelt Umlaute anders als die Standardsortierung. Die Telefonbuch-Reihenfolge erweitert ä zu ae, ö zu oe und ü zu ue für Sortierzwecke.

const names = ["Müller", "Meyer", "Möller", "Mueller"];

const standard = new Intl.Collator("de-DE");
const phonebook = new Intl.Collator("de-DE-u-co-phonebk");

console.log(names.sort((a, b) => standard.compare(a, b)));
// Output: ["Meyer", "Möller", "Mueller", "Müller"]

console.log(names.sort((a, b) => phonebook.compare(a, b)));
// Output: ["Meyer", "Möller", "Mueller", "Müller"]

Die chinesische Sortierung bietet mehrere Ordnungssysteme. Die Pinyin-Sortierung sortiert nach Aussprache, während die Strich-Sortierung nach der Anzahl der Pinselstriche sortiert, die zum Schreiben jedes Zeichens verwendet werden.

const pinyinCollator = new Intl.Collator("zh-CN-u-co-pinyin");
const strokeCollator = new Intl.Collator("zh-CN-u-co-stroke");

Sortierungserweiterungen wirken sich nur auf die Intl.Collator-API und Methoden wie Array.prototype.sort() aus, wenn sie mit Kollatoren verwendet werden.

Groß-/Kleinschreibung-zuerst-Erweiterungen

Der kf-Schlüssel bestimmt, ob Groß- oder Kleinbuchstaben bei der Sortierung zuerst sortiert werden. Diese Präferenz variiert je nach Sprache und Anwendungsfall.

Drei Werte sind verfügbar:

  • upper um Großbuchstaben vor Kleinbuchstaben zu sortieren
  • lower um Kleinbuchstaben vor Großbuchstaben zu sortieren
  • false um die standardmäßige Groß-/Kleinschreibung-Reihenfolge des Gebietsschemas zu verwenden
const words = ["apple", "Apple", "APPLE", "banana"];

const upperFirst = new Intl.Collator("en-US-u-kf-upper");
const lowerFirst = new Intl.Collator("en-US-u-kf-lower");

console.log(words.sort((a, b) => upperFirst.compare(a, b)));
// Output: ["APPLE", "Apple", "apple", "banana"]

console.log(words.sort((a, b) => lowerFirst.compare(a, b)));
// Output: ["apple", "Apple", "APPLE", "banana"]

Die Groß-/Kleinschreibung-zuerst-Sortierung beeinflusst die Sortierung, wenn Wörter ansonsten identisch sind, außer bei der Groß-/Kleinschreibung. Sie bestimmt die sekundäre Sortierreihenfolge nach dem Vergleich der Basiszeichen.

Numerische Sortierungserweiterungen

Der kn-Schlüssel aktiviert die numerische Sortierung, die numerische Sequenzen nach ihrem numerischen Wert anstatt lexikografisch sortiert. Ohne numerische Sortierung wird "10" vor "2" sortiert, weil "1" in der Zeichenreihenfolge vor "2" kommt.

Die numerische Sortierung akzeptiert zwei Werte:

  • true um die numerische Sortierung zu aktivieren
  • false um die numerische Sortierung zu deaktivieren (Standard)
const items = ["item1", "item10", "item2", "item20"];

const standard = new Intl.Collator("en-US");
const numeric = new Intl.Collator("en-US-u-kn-true");

console.log(items.sort((a, b) => standard.compare(a, b)));
// Output: ["item1", "item10", "item2", "item20"]

console.log(items.sort((a, b) => numeric.compare(a, b)));
// Output: ["item1", "item2", "item10", "item20"]

Mit aktivierter numerischer Sortierung wird "item2" korrekt vor "item10" einsortiert, da 2 kleiner als 10 ist. Dies erzeugt die erwartete Sortierreihenfolge für Zeichenketten, die Zahlen enthalten.

Numerische Sortierung ist nützlich für die Sortierung von Dateinamen, Versionsnummern, Straßenadressen und beliebigen Texten mit eingebetteten Zahlen.

Verwendung von Options-Objekten anstelle von Extension-Strings

Anstatt Extensions im Locale-String zu kodieren, können Sie diese als Optionen an den Intl.Locale-Konstruktor übergeben. Dieser Ansatz trennt die Basis-Locale von den Formatierungspräferenzen.

const locale = new Intl.Locale("ja-JP", {
  calendar: "japanese",
  numberingSystem: "jpan",
  hourCycle: "h11"
});

console.log(locale.toString());
// Output: "ja-JP-u-ca-japanese-hc-h11-nu-jpan"

Der Konstruktor konvertiert die Optionen automatisch in Extension-Tags. Beide Ansätze erzeugen identische Locale-Objekte.

Der Options-Objekt-Ansatz bietet mehrere Vorteile. Er macht den Code lesbarer, indem vollständige Property-Namen anstelle von Zwei-Buchstaben-Codes verwendet werden. Außerdem erleichtert er die dynamische Konstruktion von Locales aus Konfigurationsdaten.

const userPreferences = {
  language: "ar",
  region: "SA",
  calendar: "islamic",
  numberingSystem: "arab"
};

const locale = new Intl.Locale(`${userPreferences.language}-${userPreferences.region}`, {
  calendar: userPreferences.calendar,
  numberingSystem: userPreferences.numberingSystem
});

Sie können Optionen auch direkt an Formatter-Konstruktoren übergeben:

const formatter = new Intl.DateTimeFormat("th-TH", {
  calendar: "buddhist",
  numberingSystem: "thai",
  year: "numeric",
  month: "long",
  day: "numeric"
});

Dies kombiniert locale-spezifische Formatierungsoptionen mit Präsentationsoptionen in einem einzigen Konstruktor-Aufruf.

Wann Extensions versus Formatter-Optionen verwendet werden sollten

Extensions und Formatter-Optionen dienen unterschiedlichen Zwecken. Das Verständnis, wann welcher Ansatz zu verwenden ist, hilft Ihnen, saubereren und wartbareren Code zu schreiben.

Verwenden Sie Extensions im Locale-String, wenn die Formatierungspräferenzen der Locale des Benutzers inhärent sind. Wenn ein thailändischer Benutzer immer den buddhistischen Kalender und thailändische Ziffern sehen möchte, kodieren Sie diese Präferenzen in dessen Locale-Identifier.

const userLocale = "th-TH-u-ca-buddhist-nu-thai";

Dies ermöglicht es Ihnen, die Locale an jeden Formatter zu übergeben, ohne die Präferenzen zu wiederholen:

const dateFormatter = new Intl.DateTimeFormat(userLocale);
const numberFormatter = new Intl.NumberFormat(userLocale);

Beide Formatter verwenden automatisch den buddhistischen Kalender und thailändische Ziffern.

Verwenden Sie Formatter-Optionen, wenn die Formatierungspräferenzen spezifisch für einen Anwendungsfall sind. Wenn Sie den islamischen Kalender in einem Teil Ihrer Anwendung anzeigen möchten, aber den gregorianischen Kalender an anderer Stelle, übergeben Sie die Kalenderoption an den spezifischen Formatter.

const islamicFormatter = new Intl.DateTimeFormat("ar-SA", {
  calendar: "islamic"
});

const gregorianFormatter = new Intl.DateTimeFormat("ar-SA", {
  calendar: "gregory"
});

Derselbe Locale-Identifier erzeugt unterschiedliche Formatierungen basierend auf der Kalenderoption.

Erweiterungen im Locale-String fungieren als Standardwerte. Formatter-Optionen überschreiben diese Standardwerte, wenn sie angegeben werden. Dies ermöglicht es Ihnen, Benutzerpräferenzen als Basis zu verwenden und gleichzeitig spezifische Formatter anzupassen.

const locale = "en-US-u-hc-h23";
const formatter12Hour = new Intl.DateTimeFormat(locale, {
  hourCycle: "h12"
});

Der Benutzer bevorzugt das 24-Stunden-Format, aber dieser spezifische Formatter überschreibt diese Präferenz, um das 12-Stunden-Format anzuzeigen.

Lesen von Erweiterungswerten aus Locales

Das Intl.Locale-Objekt stellt Erweiterungswerte als Properties bereit. Sie können diese Properties lesen, um die Formatierungspräferenzen einer Locale zu inspizieren oder zu validieren.

const locale = new Intl.Locale("ar-SA-u-ca-islamic-nu-arab-hc-h12");

console.log(locale.calendar); // "islamic"
console.log(locale.numberingSystem); // "arab"
console.log(locale.hourCycle); // "h12"

Diese Properties geben die Erweiterungswerte zurück, falls vorhanden, oder undefined, wenn die Erweiterung nicht angegeben ist.

Sie können diese Properties verwenden, um Konfigurationsoberflächen zu erstellen oder Benutzerpräferenzen zu validieren:

function describeLocalePreferences(localeString) {
  const locale = new Intl.Locale(localeString);

  return {
    language: locale.language,
    region: locale.region,
    calendar: locale.calendar || "default",
    numberingSystem: locale.numberingSystem || "default",
    hourCycle: locale.hourCycle || "default"
  };
}

console.log(describeLocalePreferences("th-TH-u-ca-buddhist-nu-thai"));
// Output: { language: "th", region: "TH", calendar: "buddhist", numberingSystem: "thai", hourCycle: "default" }

Die Properties collation, caseFirst und numeric entsprechen den co-, kf- und kn-Erweiterungsschlüsseln:

const locale = new Intl.Locale("de-DE-u-co-phonebk-kf-upper-kn-true");

console.log(locale.collation); // "phonebk"
console.log(locale.caseFirst); // "upper"
console.log(locale.numeric); // true

Beachten Sie, dass die numeric-Property einen Boolean zurückgibt, keinen String. Der Wert true zeigt an, dass die numerische Sortierung aktiviert ist.

Kombinieren mehrerer Erweiterungen

Sie können mehrere Erweiterungen in einem einzigen Locale-Identifier kombinieren. Dies ermöglicht es Ihnen, alle Formatierungspräferenzen auf einmal anzugeben.

const locale = new Intl.Locale("ar-SA-u-ca-islamic-nu-arab-hc-h12-co-standard");

const dateFormatter = new Intl.DateTimeFormat(locale, {
  year: "numeric",
  month: "long",
  day: "numeric",
  hour: "numeric",
  minute: "numeric"
});

const date = new Date("2025-03-15T14:30:00");
console.log(dateFormatter.format(date));
// Output uses Islamic calendar, Arabic-Indic numerals, and 12-hour time

Jeder Erweiterungsschlüssel kann nur einmal in einem Locale-String vorkommen. Wenn Sie denselben Schlüssel mehrmals angeben, hat der letzte Wert Vorrang.

const locale = new Intl.Locale("en-US-u-hc-h23-hc-h12");
console.log(locale.hourCycle); // "h12"

Stellen Sie beim programmatischen Erstellen von Locales sicher, dass jeder Erweiterungsschlüssel nur einmal vorkommt, um Mehrdeutigkeiten zu vermeiden.

Praktische Anwendungsfälle

Unicode-Erweiterungen lösen reale Probleme in internationalisierten Anwendungen. Das Verständnis gängiger Anwendungsfälle hilft Ihnen, Erweiterungen effektiv einzusetzen.

Speicherung von Benutzerpräferenzen

Speichern Sie Formatierungspräferenzen der Benutzer in einem einzigen Locale-String anstelle mehrerer Konfigurationsfelder:

function saveUserPreferences(userId, localeString) {
  const locale = new Intl.Locale(localeString);

  return {
    userId,
    language: locale.language,
    region: locale.region,
    localeString: locale.toString(),
    preferences: {
      calendar: locale.calendar,
      numberingSystem: locale.numberingSystem,
      hourCycle: locale.hourCycle
    }
  };
}

const preferences = saveUserPreferences(123, "ar-SA-u-ca-islamic-nu-arab-hc-h12");

Dieser Ansatz speichert Formatierungspräferenzen als einzelnen String und bietet gleichzeitig strukturierten Zugriff auf einzelne Komponenten.

Erstellen von Locale-Selektoren

Ermöglichen Sie Benutzern die Auswahl von Formatierungspräferenzen über eine Benutzeroberfläche, indem Sie Locale-Strings mit Erweiterungen erstellen:

function buildLocaleFromUserInput(language, region, preferences) {
  const options = {};

  if (preferences.calendar) {
    options.calendar = preferences.calendar;
  }

  if (preferences.numberingSystem) {
    options.numberingSystem = preferences.numberingSystem;
  }

  if (preferences.hourCycle) {
    options.hourCycle = preferences.hourCycle;
  }

  const locale = new Intl.Locale(`${language}-${region}`, options);
  return locale.toString();
}

const userLocale = buildLocaleFromUserInput("th", "TH", {
  calendar: "buddhist",
  numberingSystem: "thai",
  hourCycle: "h23"
});

console.log(userLocale);
// Output: "th-TH-u-ca-buddhist-hc-h23-nu-thai"

Berücksichtigung religiöser Kalender

Anwendungen, die religiöse Gemeinschaften bedienen, sollten deren Kalendersysteme unterstützen:

function createReligiousCalendarFormatter(religion, baseLocale) {
  const calendars = {
    jewish: "hebrew",
    muslim: "islamic",
    buddhist: "buddhist"
  };

  const calendar = calendars[religion];
  if (!calendar) {
    return new Intl.DateTimeFormat(baseLocale);
  }

  const locale = new Intl.Locale(baseLocale, { calendar });
  return new Intl.DateTimeFormat(locale, {
    year: "numeric",
    month: "long",
    day: "numeric"
  });
}

const jewishFormatter = createReligiousCalendarFormatter("jewish", "en-US");
console.log(jewishFormatter.format(new Date("2025-03-15")));
// Output: "15 Adar II 5785"

Sortierung mit benutzerdefinierten Regeln

Verwenden Sie Collation-Erweiterungen, um locale-spezifische Sortierung zu implementieren:

function sortNames(names, locale, collationType) {
  const localeWithCollation = new Intl.Locale(locale, {
    collation: collationType
  });

  const collator = new Intl.Collator(localeWithCollation);
  return names.sort((a, b) => collator.compare(a, b));
}

const germanNames = ["Müller", "Meyer", "Möller", "Mueller"];
const sorted = sortNames(germanNames, "de-DE", "phonebk");
console.log(sorted);

Anzeige traditioneller Ziffern

Zeigen Sie Zahlen in traditionellen Zahlensystemen für eine kulturell angemessene Darstellung an:

function formatTraditionalNumber(number, locale, numberingSystem) {
  const localeWithNumbering = new Intl.Locale(locale, {
    numberingSystem
  });

  return new Intl.NumberFormat(localeWithNumbering).format(number);
}

console.log(formatTraditionalNumber(123456, "ar-EG", "arab"));
// Output: "١٢٣٬٤٥٦"

console.log(formatTraditionalNumber(123456, "th-TH", "thai"));
// Output: "๑๒๓,๔๕๖"

Browser-Unterstützung

Unicode-Erweiterungen funktionieren in allen modernen Browsern. Chrome, Firefox, Safari und Edge unterstützen die Erweiterungssyntax in Locale-Identifikatoren und die entsprechenden Eigenschaften von Intl.Locale-Objekten.

Die Verfügbarkeit spezifischer Erweiterungswerte hängt von der Browser-Implementierung ab. Alle Browser unterstützen gängige Werte wie gregory für Kalender, latn für Zahlensysteme und h12 oder h23 für Stundenzyklus. Weniger gebräuchliche Werte wie traditionelle chinesische Kalender oder Zahlensysteme von Minderheitensprachen funktionieren möglicherweise nicht in allen Browsern.

Testen Sie Ihre Locale-Identifikatoren in den Zielbrowsern, wenn Sie weniger gebräuchliche Erweiterungswerte verwenden. Verwenden Sie die Intl.Locale-Eigenschaften, um zu überprüfen, ob der Browser Ihre Erweiterungswerte erkannt hat:

const locale = new Intl.Locale("zh-CN-u-ca-chinese");
console.log(locale.calendar);
// If browser supports Chinese calendar: "chinese"
// If browser does not support it: undefined

Node.js unterstützt Unicode-Erweiterungen ab Version 12, mit vollständiger Unterstützung für alle Eigenschaften in Version 18 und später.

Zusammenfassung

Unicode-Erweiterungen ermöglichen es Ihnen, Formatierungspräferenzen zu Locale-Identifikatoren hinzuzufügen. Anstatt jeden Formatierer separat zu konfigurieren, kodieren Sie die Präferenzen einmalig in der Locale-Zeichenkette.

Wichtige Konzepte:

  • Erweiterungen beginnen mit -u-, gefolgt von Schlüssel-Wert-Paaren
  • Der Schlüssel ca gibt das Kalendersystem an
  • Der Schlüssel nu gibt das Zahlensystem an
  • Der Schlüssel hc gibt das Stundenzyklusformat an
  • Der Schlüssel co gibt die Sortierregeln an
  • Der Schlüssel kf gibt die Groß-/Kleinschreibungsreihenfolge an
  • Der Schlüssel kn aktiviert die numerische Sortierung
  • Sie können Erweiterungszeichenketten oder Optionsobjekte verwenden
  • Erweiterungen fungieren als Standardwerte, die von Formatiereroptionen überschrieben werden können
  • Das Objekt Intl.Locale stellt Erweiterungen als Eigenschaften bereit

Verwenden Sie Unicode-Erweiterungen, um Benutzerpräferenzen zu speichern, kulturelle Kalender zu berücksichtigen, traditionelle Ziffern anzuzeigen und locale-spezifische Sortierung zu implementieren. Sie bieten eine standardisierte Möglichkeit, das Formatierungsverhalten in JavaScript-Internationalisierungscode anzupassen.