So entfernen Sie redundante Informationen aus Locale-Identifikatoren

Verwenden Sie die minimize-Methode, um kompakte Locale-Identifikatoren zu erstellen, ohne die Bedeutung zu verlieren

Einführung

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

Die minimize()-Methode entfernt diese redundanten Komponenten, um den kürzesten äquivalenten Locale-Identifikator zu erstellen. Dies erzeugt kompakte Identifikatoren, die die Bedeutung bewahren und gleichzeitig die Speichergröße reduzieren und die Lesbarkeit verbessern.

Redundanz in Locale-Identifikatoren verstehen

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

Betrachten Sie den Identifikator en-Latn-US. Dieser Identifikator spezifiziert:

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

Englisch wird ausschließlich in lateinischer Schrift geschrieben, und wenn keine Region angegeben ist, wird für Englisch standardmäßig die Vereinigten Staaten angenommen. Sowohl die Schrift- als auch die Regionskomponente sind redundant, da sie den wahrscheinlichen Standardwerten für Englisch entsprechen. Der Identifikator en vermittelt dieselbe Information.

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

Wie die minimize-Methode funktioniert

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

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

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

Die Methode gibt eine neue Intl.Locale-Instanz zurück, bei der redundante Subtags entfernt wurden. Sie verändert 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 betrifft nur die Kern-Locale-Komponenten: Sprache, Schrift und Region. Sie entfernt oder verändert keine Unicode-Extension-Subtags, die Formatierungspräferenzen spezifizieren.

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-Extensions (nu-latn) bleiben intakt. Nur die redundanten Schrift- (Latn) und Regions-Komponenten (US) werden entfernt.

Beispiele für Minimierung

Verschiedene Locale-Identifier werden auf unterschiedliche Längen minimiert, 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 nicht standardmäßiger Regionen

Wenn die Region vom Standard abweicht, bleibt sie im minimierten Identifier 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 Schrift-Komponente wird entfernt, da sie dem Standard entspricht, aber die Region wird beibehalten, da sie eine nicht standardmäßige Variante der Sprache spezifiziert.

Beibehalten nicht standardmäßiger Schriften

Wenn die Schrift vom Standard abweicht, bleibt sie im minimierten Identifier 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 Schrift-Komponente, um zwischen vereinfachten und traditionellen Varianten zu unterscheiden. Serbisch erfordert die Schrift-Komponente, um zwischen kyrillischen und lateinischen Schriften zu unterscheiden.

Bereits minimale Identifier

Wenn ein Locale-Identifier bereits minimal ist, gibt die Methode eine äquivalente Locale ohne Änderungen zurück:

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

Beziehung zu maximize

Die minimize()-Methode ist die Umkehrung von maximize(). Die maximize()-Methode fügt wahrscheinliche Subtags hinzu, um einen vollständigen Identifier zu erstellen, während minimize() redundante Subtags entfernt, um einen kompakten Identifier 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 Roundtrip von kompakt zu vollständig und zurück zu kompakt erzeugt die ursprüngliche Form.

Allerdings kehren nicht alle Locales nach einem Roundtrip zu ihrer exakten ursprünglichen Form zurück. Die Methode erzeugt eine kanonische Minimalform, 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"

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

Wann minimize verwendet werden sollte

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

Speichern von Locale-Präferenzen

Minimierte Identifikatoren reduzieren den Speicherplatz in Datenbanken, Local Storage oder Konfigurationsdateien:

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

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

saveUserLocale("en-Latn-US");
// Stores "en" instead of "en-Latn-US"

Dies reduziert die Größe der gespeicherten Daten, ohne Informationen zu verlieren.

Erstellen lesbarer URLs

Minimierte Identifikatoren erzeugen sauberere 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-Identifikatoren

Minimierung hilft festzustellen, ob zwei Locale-Identifikatoren dasselbe 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

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

Normalisieren von Benutzereingaben

Wenn Sie Locale-Identifikatoren von Benutzern oder externen Systemen akzeptieren, minimieren Sie diese zu einer Standardform:

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 desselben Locales und gibt eine konsistente Repräsentation zurück.

Kombinieren von minimize mit anderen Locale-Operationen

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

Minimierung nach Änderung von Locale-Eigenschaften

Beim Konstruieren einer Locale aus Komponenten sollte 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 der finale Identifier so kompakt wie möglich ist, soweit es die Eingabekomponenten zulassen.

Beibehaltung von Extensions während der Minimierung

Extensions 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 Stundenzyklus-Extensions bleiben erhalten.