Wie man redundante Informationen aus Gebietsschema-Kennungen entfernt

Verwenden Sie die minimize-Methode, um kompakte Gebietsschema-Kennungen ohne Bedeutungsverlust zu erstellen

Einführung

Locale-Kennungen wie en-Latn-US und zh-Hans-CN enthalten mehrere Komponenten, die Sprache, Schrift und Region angeben. Allerdings sind nicht alle diese Komponenten notwendig, um eine Locale zu identifizieren. Einige Komponenten sind redundant, da sie aus anderen Teilen der Kennung abgeleitet werden können.

Die Methode minimize() entfernt diese redundanten Komponenten, um die kürzeste äquivalente Locale-Kennung zu erstellen. Dies erzeugt kompakte Kennungen, die die Bedeutung beibehalten und gleichzeitig den Speicherplatz reduzieren und die Lesbarkeit verbessern.

Redundanz in Locale-Kennungen verstehen

Eine Locale-Kennung wird redundant, wenn sie Informationen explizit angibt, die bereits durch andere Komponenten impliziert werden. Die Redundanz entsteht, weil jede Sprache wahrscheinliche Standardwerte für Schrift und Region hat.

Betrachten wir die Kennung en-Latn-US. Diese Kennung spezifiziert:

  • Sprache: Englisch (en)
  • Schrift: Lateinisch (Latn)
  • Region: Vereinigte Staaten (US)

Englisch wird nur in lateinischer Schrift geschrieben, und wenn keine Region angegeben ist, ist Englisch standardmäßig auf die Vereinigten Staaten eingestellt. Sowohl die Schrift- als auch die Regionskomponenten sind redundant, da sie den wahrscheinlichen Standardwerten für Englisch entsprechen. Die Kennung en vermittelt die gleichen Informationen.

Das gleiche Prinzip gilt für andere Sprachen. Koreanisch (ko) wird in Hangul-Schrift (Kore) geschrieben und hauptsächlich in Südkorea (KR) gesprochen. Die Kennung ko-Kore-KR enthält redundante Informationen, da ko allein diese Standardwerte impliziert.

Wie die minimize-Methode funktioniert

Die Methode minimize() ist auf Intl.Locale-Instanzen verfügbar. Sie analysiert die Locale-Kennung und entfernt Komponenten, die wahrscheinlichen Standardwerten entsprechen.

const locale = new Intl.Locale("en-Latn-US");
const minimized = locale.minimize();

console.log(minimized.baseName);
// Ausgabe: "en"

Die Methode gibt eine neue Intl.Locale-Instanz mit entfernten redundanten Subtags zurück. Sie modifiziert das ursprüngliche Locale-Objekt nicht.

Der Minimierungsprozess folgt dem Unicode CLDR-Algorithmus "Remove Likely Subtags". Dieser Algorithmus verwendet eine Datenbank wahrscheinlicher Subtag-Assoziationen, um zu bestimmen, welche Komponenten ohne Informationsverlust entfernt werden können.

Von minimize betroffene Komponenten

Die minimize()-Methode wirkt sich nur auf die Kern-Locale-Komponenten aus: Sprache, Schrift und Region. Sie entfernt oder modifiziert keine Unicode-Erweiterungs-Subtags, die Formatierungspräferenzen angeben.

const locale = new Intl.Locale("en-Latn-US-u-ca-gregory-nu-latn");
const minimized = locale.minimize();

console.log(minimized.toString());
// Output: "en-u-ca-gregory-nu-latn"

Die Kalender- (ca-gregory) und Zahlensystem-Erweiterungen (nu-latn) bleiben intakt. Nur die redundanten Schrift- (Latn) und Regions-Komponenten (US) werden entfernt.

Beispiele für Minimierung

Verschiedene Locale-Kennungen minimieren zu unterschiedlichen Längen, abhängig davon, welche Komponenten redundant sind.

Entfernen von Schrift und Region

Wenn sowohl Schrift als auch Region den Standardwerten entsprechen, werden beide entfernt:

const english = new Intl.Locale("en-Latn-US");
console.log(english.minimize().baseName);
// Output: "en"

const korean = new Intl.Locale("ko-Kore-KR");
console.log(korean.minimize().baseName);
// Output: "ko"

const japanese = new Intl.Locale("ja-Jpan-JP");
console.log(japanese.minimize().baseName);
// Output: "ja"

Beibehalten von Nicht-Standard-Regionen

Wenn die Region vom Standard abweicht, bleibt sie in der minimierten Kennung erhalten:

const britishEnglish = new Intl.Locale("en-Latn-GB");
console.log(britishEnglish.minimize().baseName);
// Output: "en-GB"

const canadianFrench = new Intl.Locale("fr-Latn-CA");
console.log(canadianFrench.minimize().baseName);
// Output: "fr-CA"

const mexicanSpanish = new Intl.Locale("es-Latn-MX");
console.log(mexicanSpanish.minimize().baseName);
// Output: "es-MX"

Die Schriftkomponente wird entfernt, da sie dem Standard entspricht, aber die Region wird beibehalten, da sie eine Nicht-Standard-Variante der Sprache spezifiziert.

Beibehalten von Nicht-Standard-Schriften

Wenn die Schrift vom Standard abweicht, bleibt sie in der minimierten Kennung erhalten:

const simplifiedChinese = new Intl.Locale("zh-Hans-CN");
console.log(simplifiedChinese.minimize().baseName);
// Output: "zh-Hans"

const traditionalChinese = new Intl.Locale("zh-Hant-TW");
console.log(traditionalChinese.minimize().baseName);
// Output: "zh-Hant"

const serbianCyrillic = new Intl.Locale("sr-Cyrl-RS");
console.log(serbianCyrillic.minimize().baseName);
// Output: "sr-Cyrl"

Chinesisch erfordert die Schriftkomponente, um zwischen vereinfachten und traditionellen Varianten zu unterscheiden. Serbisch erfordert die Schriftkomponente, um zwischen kyrillischer und lateinischer Schrift zu unterscheiden.

Bereits minimale Kennungen

Wenn eine Gebietsschema-Kennung bereits minimal ist, gibt die Methode ein äquivalentes Gebietsschema ohne Änderungen zurück:

const minimal = new Intl.Locale("fr");
console.log(minimal.minimize().baseName);
// Output: "fr"

Beziehung zu maximize

Die Methode minimize() ist die Umkehrung von maximize(). Die Methode maximize() fügt wahrscheinliche Untertags hinzu, um eine vollständige Kennung zu erstellen, während minimize() redundante Untertags entfernt, um eine kompakte Kennung zu erstellen.

Diese Methoden bilden ein Paar, das eine bidirektionale Konvertierung zwischen vollständigen und kompakten Formen ermöglicht:

const compact = new Intl.Locale("en");
const complete = compact.maximize();
console.log(complete.baseName);
// Output: "en-Latn-US"

const compactAgain = complete.minimize();
console.log(compactAgain.baseName);
// Output: "en"

Der Rundlauf von kompakt zu vollständig und zurück zu kompakt erzeugt die ursprüngliche Form.

Allerdings kehren nicht alle Gebietsschemata nach einem Rundlauf zu ihrer exakten ursprünglichen Form zurück. Die Methode erzeugt eine kanonische minimale Form, anstatt die ursprüngliche Struktur zu bewahren:

const locale = new Intl.Locale("en-US");
const maximized = locale.maximize();
console.log(maximized.baseName);
// Output: "en-Latn-US"

const minimized = maximized.minimize();
console.log(minimized.baseName);
// Output: "en"

Die ursprüngliche Kennung en-US enthielt eine nicht-redundante Region, aber nach Maximierung und Minimierung wird sie zu en. Dies geschieht, weil die Vereinigten Staaten die wahrscheinliche Standardregion für Englisch sind.

Wann minimize verwenden

Verwenden Sie minimize(), wenn Sie kompakte Gebietsschema-Kennungen benötigen, die eindeutig bleiben. Mehrere Szenarien profitieren von der Minimierung.

Speichern von Gebietsschema-Präferenzen

Minimierte Kennungen reduzieren den Speicherplatz in Datenbanken, lokalem Speicher oder Konfigurationsdateien:

function saveUserLocale(localeString) {
  const locale = new Intl.Locale(localeString);
  const minimized = locale.minimize().toString();

  localStorage.setItem("userLocale", minimized);
}

saveUserLocale("en-Latn-US");
// Speichert "en" anstelle von "en-Latn-US"

Dies reduziert die gespeicherte Datengröße ohne Informationsverlust.

Lesbare URLs erstellen

Minimierte Kennungen erzeugen übersichtlichere URLs für die Sprachauswahl:

function createLocalizedURL(path, localeString) {
  const locale = new Intl.Locale(localeString);
  const minimized = locale.minimize().baseName;

  return `/${minimized}${path}`;
}

const url = createLocalizedURL("/products", "en-Latn-US");
console.log(url);
// Output: "/en/products"

Die URL /en/products ist lesbarer als /en-Latn-US/products.

Vergleichen von Locale-Kennungen

Die Minimierung hilft festzustellen, ob zwei Locale-Kennungen dieselbe Locale repräsentieren:

function areLocalesEquivalent(locale1String, locale2String) {
  const locale1 = new Intl.Locale(locale1String).minimize();
  const locale2 = new Intl.Locale(locale2String).minimize();

  return locale1.toString() === locale2.toString();
}

console.log(areLocalesEquivalent("en", "en-Latn-US"));
// Output: true

console.log(areLocalesEquivalent("en-US", "en-Latn-US"));
// Output: true

console.log(areLocalesEquivalent("en-US", "en-GB"));
// Output: false

Die Minimierung erzeugt eine kanonische Form, die einen direkten Vergleich ermöglicht.

Normalisierung von Benutzereingaben

Bei der Annahme von Locale-Kennungen von Benutzern oder externen Systemen können diese auf eine Standardform minimiert werden:

function normalizeLocale(localeString) {
  try {
    const locale = new Intl.Locale(localeString);
    return locale.minimize().toString();
  } catch (error) {
    return null;
  }
}

console.log(normalizeLocale("en-US"));
// Output: "en"

console.log(normalizeLocale("en-Latn-US"));
// Output: "en"

console.log(normalizeLocale("en-GB"));
// Output: "en-GB"

Diese Funktion akzeptiert verschiedene Formen derselben Locale und gibt eine konsistente Darstellung zurück.

Kombination von minimize mit anderen Locale-Operationen

Die minimize()-Methode funktioniert mit anderen Intl.Locale-Funktionen, um eine flexible Locale-Handhabung zu ermöglichen.

Minimierung nach Änderung von Locale-Eigenschaften

Bei der Konstruktion einer Locale aus Komponenten kann diese minimiert werden, um unnötige Teile zu entfernen:

const locale = new Intl.Locale("en", {
  region: "US",
  script: "Latn"
});

const minimized = locale.minimize();
console.log(minimized.baseName);
// Output: "en"

Dies stellt sicher, dass die endgültige Kennung so kompakt ist, wie es die Eingabekomponenten zulassen.

Erweiterungen beim Minimieren beibehalten

Erweiterungen bleiben während der Minimierung intakt, sodass Sie Kernkomponenten minimieren können, während Formatierungspräferenzen erhalten bleiben:

function createCompactLocaleWithPreferences(language, region, preferences) {
  const locale = new Intl.Locale(language, {
    region: region,
    ...preferences
  });

  return locale.minimize().toString();
}

const localeString = createCompactLocaleWithPreferences("en", "US", {
  hourCycle: "h23",
  calendar: "gregory"
});

console.log(localeString);
// Output: "en-u-ca-gregory-hc-h23"

Die Kernkomponenten werden zu en minimiert, aber die Kalender- und Stundenzykluserweiterungen bleiben erhalten.