Cómo eliminar información redundante de los identificadores de configuración regional

Utiliza el método minimize para crear identificadores de configuración regional compactos sin perder significado

Introducción

Los identificadores de configuración regional como en-Latn-US y zh-Hans-CN contienen múltiples componentes que especifican idioma, script y región. Sin embargo, no todos estos componentes son necesarios para identificar una configuración regional. Algunos componentes son redundantes porque pueden inferirse de otras partes del identificador.

El método minimize() elimina estos componentes redundantes para crear el identificador de configuración regional equivalente más corto. Esto produce identificadores compactos que preservan el significado mientras reducen el tamaño de almacenamiento y mejoran la legibilidad.

Comprender la redundancia en los identificadores de configuración regional

Un identificador de configuración regional se vuelve redundante cuando declara explícitamente información que ya está implícita en otros componentes. La redundancia ocurre porque cada idioma tiene valores predeterminados probables para script y región.

Considera el identificador en-Latn-US. Este identificador especifica:

  • Idioma: inglés (en)
  • Script: latino (Latn)
  • Región: Estados Unidos (US)

El inglés solo se escribe en script latino, y cuando no se especifica ninguna región, el inglés tiene como valor predeterminado Estados Unidos. Tanto el componente de script como el de región son redundantes porque coinciden con los valores predeterminados probables para el inglés. El identificador en transmite la misma información.

El mismo principio se aplica a otros idiomas. El coreano (ko) se escribe en script hangul (Kore) y se habla principalmente en Corea del Sur (KR). El identificador ko-Kore-KR contiene información redundante porque ko por sí solo implica estos valores predeterminados.

Cómo funciona el método minimize

El método minimize() está disponible en instancias de Intl.Locale. Analiza el identificador de configuración regional y elimina los componentes que coinciden con valores predeterminados probables.

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

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

El método devuelve una nueva instancia de Intl.Locale con las subetiquetas redundantes eliminadas. No modifica el objeto de configuración regional original.

El proceso de minimización sigue el algoritmo "Remove Likely Subtags" de Unicode CLDR. Este algoritmo utiliza una base de datos de asociaciones de subetiquetas probables para determinar qué componentes se pueden eliminar sin perder información.

Componentes afectados por minimize

El método minimize() solo afecta a los componentes principales de la configuración regional: idioma, escritura y región. No elimina ni modifica las subetiquetas de extensión Unicode que especifican preferencias de formato.

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"

Las extensiones de calendario (ca-gregory) y sistema de numeración (nu-latn) permanecen intactas. Solo se eliminan los componentes redundantes de escritura (Latn) y región (US).

Ejemplos de minimización

Diferentes identificadores de configuración regional se minimizan a diferentes longitudes dependiendo de qué componentes son redundantes.

Eliminación de escritura y región

Cuando tanto la escritura como la región coinciden con los valores predeterminados, ambos se eliminan:

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"

Conservación de regiones no predeterminadas

Cuando la región difiere del valor predeterminado, permanece en el identificador minimizado:

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"

El componente de escritura se elimina porque coincide con el valor predeterminado, pero la región se conserva porque especifica una variante no predeterminada del idioma.

Conservación de escrituras no predeterminadas

Cuando la escritura difiere del valor predeterminado, permanece en el identificador minimizado:

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"

El chino requiere el componente de escritura para distinguir entre variantes simplificadas y tradicionales. El serbio requiere el componente de escritura para distinguir entre escrituras cirílica y latina.

Identificadores ya minimizados

Cuando un identificador de configuración regional ya está minimizado, el método devuelve una configuración regional equivalente sin cambios:

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

Relación con maximize

El método minimize() es el inverso de maximize(). El método maximize() añade subetiquetas probables para crear un identificador completo, mientras que minimize() elimina subetiquetas redundantes para crear un identificador compacto.

Estos métodos forman un par que permite la conversión bidireccional entre formas completas y compactas:

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"

El viaje de ida y vuelta de compacto a completo y de vuelta a compacto produce la forma original.

Sin embargo, no todas las configuraciones regionales vuelven a su forma original exacta después de un viaje de ida y vuelta. El método produce una forma mínima canónica en lugar de preservar la estructura original:

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"

El identificador original en-US contenía una región no redundante, pero después de la maximización y minimización, se convierte en en. Esto ocurre porque Estados Unidos es la región predeterminada probable para el inglés.

Cuándo usar minimize

Usa minimize() cuando necesites identificadores de configuración regional compactos que permanezcan inequívocos. Varios escenarios se benefician de la minimización.

Almacenar preferencias de configuración regional

Los identificadores minimizados reducen el espacio de almacenamiento en bases de datos, almacenamiento local o archivos de configuración:

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"

Esto reduce el tamaño de los datos almacenados sin perder información.

Crear URLs legibles

Los identificadores minimizados producen URLs más limpias para la selección de idioma:

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"

La URL /en/products es más legible que /en-Latn-US/products.

Comparar identificadores de configuración regional

La minimización ayuda a determinar si dos identificadores de configuración regional representan la misma configuración regional:

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

La minimización produce una forma canónica que permite la comparación directa.

Normalizar entrada de usuario

Al aceptar identificadores de configuración regional de usuarios o sistemas externos, minimízalos a una forma estándar:

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"

Esta función acepta varias formas de la misma configuración regional y devuelve una representación consistente.

Combinar minimize con otras operaciones de configuración regional

El método minimize() funciona con otras características de Intl.Locale para crear un manejo flexible de locales.

Minimizar después de modificar propiedades del locale

Al construir un locale a partir de componentes, minimízalo para eliminar partes innecesarias:

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

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

Esto garantiza que el identificador final sea tan compacto como lo permitan los componentes de entrada.

Preservar extensiones al minimizar

Las extensiones permanecen intactas durante la minimización, lo que te permite minimizar los componentes principales mientras mantienes las preferencias de formato:

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"

Los componentes principales se minimizan a en, pero las extensiones de calendario y ciclo horario permanecen.