So prüfen Sie, ob eine Locale-Kennung gültig ist

Validieren Sie Locale-Kennungen, bevor Sie sie zum Formatieren von Daten, Zahlen und Währungen verwenden

Einführung

Wenn Ihre Anwendung Locale-Kennungen aus Benutzereingaben, API-Antworten oder Konfigurationsdateien akzeptiert, müssen Sie deren Gültigkeit überprüfen, bevor Sie sie verwenden. Eine ungültige Locale-Kennung führt dazu, dass Formatierungsfunktionen Fehler auslösen oder unerwartete Ergebnisse liefern.

Die Validierung stellt sicher, dass Zeichenfolgen wie en-US strukturell korrekt gemäß internationalen Standards sind. Dies verhindert Laufzeitfehler beim Übergeben von Locale-Kennungen an die Intl-API oder andere Internationalisierungsbibliotheken.

JavaScript bietet zwei integrierte Methoden zur Validierung von Locale-Kennungen. Beide Methoden prüfen die Struktur der Kennung gegen den BCP-47-Standard, der das Format für Sprach-Tags definiert.

Was macht eine Locale-Kennung gültig

Eine Locale-Kennung folgt dem BCP-47-Standard für Sprach-Tags. Dieser Standard definiert die Struktur und Regeln für die Kombination von Sprach-, Schrift-, Regions- und Erweiterungskomponenten.

Gültige Locale-Kennungen verwenden Bindestriche zur Trennung von Komponenten, keine Unterstriche oder andere Zeichen. Der Sprachcode muss ein anerkannter ISO-639-Code sein, und Regionscodes müssen anerkannte ISO-3166-1-Codes sein.

Beispiele für gültige Locale-Kennungen:

  • en (Englisch)
  • en-US (Amerikanisches Englisch)
  • zh-Hans (Vereinfachtes Chinesisch)
  • zh-Hans-CN (Vereinfachtes Chinesisch wie in China verwendet)
  • en-US-u-ca-gregory (Amerikanisches Englisch mit gregorianischem Kalender)

Beispiele für ungültige Locale-Kennungen:

  • en_US (verwendet Unterstrich statt Bindestrich)
  • english (kein anerkannter Sprachcode)
  • en-USA (Regionscode muss zwei Buchstaben haben, nicht drei)
  • EN-us (Sprachcode muss kleingeschrieben sein)
  • abc-XY (Sprachcode existiert nicht)

Die Validierungsmethoden prüfen diese strukturellen Regeln und verifizieren, dass die Codes anerkannten Standards entsprechen.

Verwendung von Intl.getCanonicalLocales zur Validierung

Die Methode Intl.getCanonicalLocales() validiert Locale-Identifikatoren und gibt sie in ihrer kanonischen Form zurück. Diese Methode akzeptiert einen einzelnen Locale-Identifikator oder ein Array von Identifikatoren.

const result = Intl.getCanonicalLocales("en-US");
console.log(result);
// Output: ["en-US"]

Die Methode normalisiert die Eingabe, indem sie diese in das Standardformat konvertiert. Selbst wenn Sie einen Locale-Identifikator mit falscher Groß-/Kleinschreibung übergeben, gibt sie die korrekte kanonische Form zurück:

const result = Intl.getCanonicalLocales("EN-us");
console.log(result);
// Output: ["en-US"]

Wenn Sie einen ungültigen Locale-Identifikator übergeben, wirft die Methode einen RangeError:

try {
  Intl.getCanonicalLocales("en_US");
} catch (error) {
  console.error(error.name);
  // Output: "RangeError"
  console.error(error.message);
  // Output: "en_US is not a structurally valid language tag"
}

Dieser Fehler zeigt an, dass der Identifikator nicht der BCP-47-Struktur folgt. Sie können diesen Fehler abfangen, um ungültige Eingaben elegant zu behandeln.

Validierung mehrerer Locale-Identifikatoren

Die Methode Intl.getCanonicalLocales() akzeptiert ein Array, um mehrere Locale-Identifikatoren gleichzeitig zu validieren. Die Methode gibt ein Array kanonischer Formen für alle gültigen Identifikatoren zurück.

const locales = ["en-US", "fr-FR", "es-MX"];
const result = Intl.getCanonicalLocales(locales);
console.log(result);
// Output: ["en-US", "fr-FR", "es-MX"]

Die Methode entfernt auch doppelte Locale-Identifikatoren aus dem Ergebnis:

const locales = ["en-US", "EN-us", "en-US"];
const result = Intl.getCanonicalLocales(locales);
console.log(result);
// Output: ["en-US"]

Alle drei Eingabewerte repräsentieren dieselbe Locale, daher gibt die Methode nur eine kanonische Form zurück.

Wenn eine Locale im Array ungültig ist, wirft die gesamte Methode einen Fehler:

try {
  Intl.getCanonicalLocales(["en-US", "invalid", "fr-FR"]);
} catch (error) {
  console.error(error.message);
  // Output: "invalid is not a structurally valid language tag"
}

Beim Validieren von benutzerbereitgestellten Listen sollten Sie jede Locale einzeln validieren, um zu identifizieren, welche spezifischen Identifikatoren ungültig sind.

Verwendung des Intl.Locale-Konstruktors zur Validierung

Der Konstruktor Intl.Locale bietet eine weitere Möglichkeit zur Validierung von Locale-Identifikatoren. Wenn Sie ein Locale-Objekt mit einem ungültigen Identifikator erstellen, wirft der Konstruktor einen RangeError.

try {
  const locale = new Intl.Locale("en-US");
  console.log("Valid locale");
} catch (error) {
  console.error("Invalid locale");
}
// Output: "Valid locale"

Der Konstruktor löst einen Fehler für ungültige Identifikatoren aus:

try {
  const locale = new Intl.Locale("en_US");
  console.log("Valid locale");
} catch (error) {
  console.error("Invalid locale");
  console.error(error.message);
}
// Output: "Invalid locale"
// Output: "invalid language subtag: en_US"

Im Gegensatz zu Intl.getCanonicalLocales() normalisiert der Intl.Locale-Konstruktor die Groß- und Kleinschreibung nicht. Er erfordert, dass der Identifikator die korrekte Schreibweise verwendet:

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

const locale2 = new Intl.Locale("EN-US");
console.log(locale2.baseName);
// Output: "en-US"

Sowohl Sprachcodes in Groß- als auch in Kleinschreibung werden akzeptiert, und der Konstruktor normalisiert sie in die kanonische Form.

Auswahl einer Validierungsmethode

Beide Validierungsmethoden dienen unterschiedlichen Zwecken und bieten unterschiedliche Funktionen.

Verwenden Sie Intl.getCanonicalLocales(), wenn Sie Folgendes benötigen:

  • Normalisierung von Locale-Identifikatoren in ihre kanonische Form
  • Validierung und Deduplizierung einer Liste von Locale-Identifikatoren
  • Konvertierung inkonsistenter Schreibweisen in das Standardformat
  • Validierung von Locale-Identifikatoren ohne Erstellung von Objekten

Verwenden Sie den Intl.Locale-Konstruktor, wenn Sie Folgendes benötigen:

  • Validierung eines Locale-Identifikators und sofortiges Arbeiten mit seinen Eigenschaften
  • Extraktion von Komponenten wie Sprache, Region oder Schrift aus dem Identifikator
  • Erstellung eines Locale-Objekts zur Verwendung mit anderen Intl-APIs
  • Validierung und Manipulation von Locale-Identifikatoren zusammen

Der Intl.Locale-Konstruktor ist leistungsfähiger, da er ein Objekt erstellt, das Sie abfragen und ändern können. Wenn Sie jedoch nur Validierung und Normalisierung benötigen, ist Intl.getCanonicalLocales() einfacher.

Validierung von Benutzereingaben

Wenn Sie Locale-Identifikatoren aus Benutzereingaben akzeptieren, validieren Sie diese, bevor Sie sie in Ihrer Anwendung verwenden. Dies verhindert Fehler und bietet klares Feedback, wenn Benutzer ungültige Werte eingeben.

function validateUserLocale(input) {
  try {
    const canonicalLocales = Intl.getCanonicalLocales(input);
    return {
      valid: true,
      locale: canonicalLocales[0]
    };
  } catch (error) {
    return {
      valid: false,
      error: "Please enter a valid locale identifier like en-US or fr-FR"
    };
  }
}

const result1 = validateUserLocale("en-US");
console.log(result1);
// Output: { valid: true, locale: "en-US" }

const result2 = validateUserLocale("english");
console.log(result2);
// Output: { valid: false, error: "Please enter a valid locale..." }

Diese Funktion validiert die Eingabe und gibt entweder die kanonische Locale oder eine benutzerfreundliche Fehlermeldung zurück.

Validierung von Konfigurationsdaten

Anwendungen laden häufig Locale-Identifikatoren aus Konfigurationsdateien oder Umgebungsvariablen. Validieren Sie diese Werte beim Start Ihrer Anwendung, um Konfigurationsfehler frühzeitig zu erkennen.

function loadLocaleConfig(configLocales) {
  const validLocales = [];
  const invalidLocales = [];

  for (const locale of configLocales) {
    try {
      const canonical = Intl.getCanonicalLocales(locale);
      validLocales.push(canonical[0]);
    } catch (error) {
      invalidLocales.push(locale);
    }
  }

  if (invalidLocales.length > 0) {
    console.warn("Invalid locale identifiers found:", invalidLocales);
  }

  return validLocales;
}

const config = ["en-US", "fr-FR", "invalid", "es_MX", "de-DE"];
const locales = loadLocaleConfig(config);
console.log(locales);
// Output: ["en-US", "fr-FR", "de-DE"]
// Warning: Invalid locale identifiers found: ["invalid", "es_MX"]

Diese Funktion filtert ungültige Locale-Identifikatoren heraus und protokolliert eine Warnung, sodass die Anwendung mit den gültigen Locales fortfahren kann.

Validierung von API-Antworten

Wenn Sie Locale-Identifikatoren von externen APIs erhalten, validieren Sie diese, bevor Sie sie in Ihrer Anwendung verwenden. APIs können Locale-Identifikatoren in nicht standardisierten Formaten oder mit Fehlern zurückgeben.

function processApiLocale(apiResponse) {
  const locale = apiResponse.preferredLocale;

  try {
    const validated = new Intl.Locale(locale);
    return {
      success: true,
      language: validated.language,
      region: validated.region,
      baseName: validated.baseName
    };
  } catch (error) {
    console.error("API returned invalid locale:", locale);
    return {
      success: false,
      fallback: "en-US"
    };
  }
}

const response1 = { preferredLocale: "fr-CA" };
console.log(processApiLocale(response1));
// Output: { success: true, language: "fr", region: "CA", baseName: "fr-CA" }

const response2 = { preferredLocale: "invalid_locale" };
console.log(processApiLocale(response2));
// Output: { success: false, fallback: "en-US" }

Diese Funktion validiert die API-Antwort und extrahiert strukturierte Informationen über die Locale oder stellt einen Fallback-Wert bereit, falls die Locale ungültig ist.