Cómo eliminar información redundante de los identificadores de localización

Utiliza el método minimize para crear identificadores de localización 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, escritura 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.

Entendiendo la redundancia en los identificadores de configuración regional

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

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

  • Idioma: Inglés (en)
  • Escritura: Latina (Latn)
  • Región: Estados Unidos (US)

El inglés solo se escribe en escritura latina, y cuando no se especifica una región, el inglés por defecto corresponde a Estados Unidos. Tanto los componentes de escritura como 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 escritura 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 los valores predeterminados probables.

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

console.log(minimized.baseName);
// Salida: "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 probables de subetiquetas para determinar qué componentes pueden eliminarse sin perder información.

Componentes afectados por minimize

El método minimize() solo afecta a los componentes principales del locale: idioma, script y región. No elimina ni modifica los subtags 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 script (Latn) y región (US).

Ejemplos de minimización

Diferentes identificadores de locale se minimizan a diferentes longitudes dependiendo de qué componentes son redundantes.

Eliminación de script y región

Cuando tanto el script 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"

Mantenimiento de regiones no predeterminadas

Cuando la región difiere de la predeterminada, 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 script se elimina porque coincide con el predeterminado, pero la región se conserva porque especifica una variante no predeterminada del idioma.

Mantenimiento de scripts no predeterminados

Cuando el script difiere del 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 script para distinguir entre las variantes simplificada y tradicional. El serbio requiere el componente de script para distinguir entre los scripts cirílico y latino.

Identificadores ya mínimos

Cuando un identificador de configuración regional ya es mínimo, el método devuelve una configuración regional equivalente sin cambios:

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

Relación con maximize

El método minimize() es el inverso de maximize(). El método maximize() añade etiquetas probables para crear un identificador completo, mientras que minimize() elimina etiquetas 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);
// Resultado: "en-Latn-US"

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

El recorrido de ida y vuelta desde la forma compacta a la completa y de vuelta a la compacta produce la forma original.

Sin embargo, no todas las configuraciones regionales vuelven exactamente a su forma original después de un recorrido completo. 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);
// Resultado: "en-Latn-US"

const minimized = maximized.minimize();
console.log(minimized.baseName);
// Resultado: "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

Utiliza minimize() cuando necesites identificadores de configuración regional compactos que permanezcan sin ambigüedades. Varios escenarios se benefician de la minimización.

Almacenamiento de 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");
// Almacena "en" en lugar de "en-Latn-US"

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

Creación de 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.

Comparación de identificadores de localización

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

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.

Normalización de la entrada del usuario

Al aceptar identificadores de localización 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 localización y devuelve una representación consistente.

Combinación de minimize con otras operaciones de localización

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

Minimización después de modificar propiedades de localización

Al construir una localización a partir de componentes, minimízala 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 asegura que el identificador final sea tan compacto como permitan los componentes de entrada.

Preservación de extensiones durante la minimización

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.