Cómo añadir etiquetas probables a locales incompletos

Usa JavaScript para completar identificadores de locale parciales con el script y la región más probables

Introducción

Cuando trabajas con identificadores de configuración regional, a veces recibes información incompleta. Un usuario podría especificar solo un código de idioma como ja sin indicar el sistema de escritura o la región. Aunque este identificador parcial es válido, carece de la especificidad necesaria para ciertas operaciones como comparar configuraciones regionales o determinar convenciones de formato.

JavaScript proporciona una manera de completar estos identificadores parciales añadiendo los componentes faltantes más probables. Este proceso utiliza datos lingüísticos para inferir el sistema de escritura y la región que los usuarios de ese idioma típicamente utilizan.

Esta guía explica qué son las etiquetas probables, cómo JavaScript las determina y cuándo utilizar esta función en tus aplicaciones.

Qué son las etiquetas probables

Las etiquetas probables son los códigos de sistema de escritura y región que aparecen más comúnmente con un idioma determinado. Estas asociaciones provienen de datos de uso lingüístico real mantenidos por el Consorcio Unicode.

Por ejemplo, el inglés se escribe típicamente en alfabeto latino y se usa más comúnmente en los Estados Unidos. Si solo tienes el código de idioma en, las etiquetas probables son Latn para el sistema de escritura y US para la región, dándote el identificador completo en-Latn-US.

La probabilidad se basa en poblaciones de hablantes y patrones de uso históricos. El algoritmo siempre devuelve la combinación estadísticamente más común.

Por qué añadir etiquetas probables

Los identificadores de configuración regional parciales funcionan para la mayoría de las operaciones de formato. Las APIs Intl.DateTimeFormat e Intl.NumberFormat aceptan en y aplicarán valores predeterminados sensatos. Sin embargo, hay situaciones donde es necesario tener identificadores completos.

Comparación de identificadores de configuración regional

Cuando se comparan dos identificadores de configuración regional para ver si se refieren al mismo idioma y región, los identificadores parciales crean ambigüedad. ¿Significa en lo mismo que en-US, o es diferente porque uno especifica una región y el otro no?

Añadir etiquetas probables elimina esta ambigüedad. Tanto en como en-US se maximizan a en-Latn-US, haciéndolos directamente comparables.

const locale1 = new Intl.Locale("en");
const locale2 = new Intl.Locale("en-US");

console.log(locale1.baseName === locale2.baseName);
// false - parecen diferentes

const maximized1 = locale1.maximize();
const maximized2 = locale2.maximize();

console.log(maximized1.baseName === maximized2.baseName);
// true - ambos son "en-Latn-US"

Almacenamiento de formas canónicas

Cuando se almacenan identificadores de configuración regional en bases de datos o archivos de configuración, el uso de formas completas garantiza la consistencia. Cada configuración regional francesa se convierte en fr-Latn-FR, cada configuración regional japonesa se convierte en ja-Jpan-JP, y así sucesivamente.

Esta consistencia hace que la búsqueda, el filtrado y la agrupación por configuración regional sean más fiables.

Determinación del comportamiento específico del script

Algunos idiomas utilizan múltiples scripts, y el script afecta la renderización del texto, la selección de fuentes y la ordenación. El chino puede escribirse en caracteres simplificados o tradicionales, y el serbio puede usar script cirílico o latino.

Agregar subtags probables hace que el script sea explícito. Si un usuario proporciona zh sin especificar un script, al maximizarlo se produce zh-Hans-CN, lo que indica que se esperan caracteres chinos simplificados.

Cómo funciona el algoritmo

El algoritmo Add Likely Subtags utiliza una base de datos de información de uso del lenguaje para determinar los componentes faltantes. Esta base de datos es mantenida por el Consorcio Unicode como parte del Repositorio Común de Datos de Configuración Regional.

El algoritmo examina la información que proporcionas y completa los vacíos:

  • Si solo proporcionas un idioma, agrega el script y la región más comunes para ese idioma
  • Si proporcionas un idioma y un script, agrega la región más común para esa combinación
  • Si proporcionas un idioma y una región, agrega el script más común para esa combinación
  • Si proporcionas los tres componentes, permanecen sin cambios

Las decisiones se basan en datos estadísticos sobre el uso del lenguaje a nivel mundial.

Uso del método maximize

El método maximize() está disponible en los objetos Intl.Locale. Devuelve un nuevo objeto de configuración regional con subtags probables añadidos al nombre base.

const locale = new Intl.Locale("ja");
const maximized = locale.maximize();

console.log(locale.baseName);
// "ja"

console.log(maximized.baseName);
// "ja-Jpan-JP"

El método no modifica el objeto de configuración regional original. Crea y devuelve uno nuevo.

Ejemplos con diferentes idiomas

Diferentes idiomas tienen diferentes etiquetas probables basadas en dónde se hablan principalmente y qué escrituras utilizan.

Idiomas europeos

El francés se maximiza a Francia con escritura latina:

const french = new Intl.Locale("fr");
const maximized = french.maximize();

console.log(maximized.baseName);
// "fr-Latn-FR"

El alemán se maximiza a Alemania con escritura latina:

const german = new Intl.Locale("de");
const maximized = german.maximize();

console.log(maximized.baseName);
// "de-Latn-DE"

Idiomas con escrituras no latinas

El japonés se maximiza a Japón con escritura japonesa:

const japanese = new Intl.Locale("ja");
const maximized = japanese.maximize();

console.log(maximized.baseName);
// "ja-Jpan-JP"

El árabe se maximiza a Egipto con escritura árabe:

const arabic = new Intl.Locale("ar");
const maximized = arabic.maximize();

console.log(maximized.baseName);
// "ar-Arab-EG"

El chino sin una escritura se maximiza a caracteres simplificados y China:

const chinese = new Intl.Locale("zh");
const maximized = chinese.maximize();

console.log(maximized.baseName);
// "zh-Hans-CN"

Identificadores parciales con regiones

Cuando proporcionas un idioma y una región pero no una escritura, el algoritmo añade la escritura:

const britishEnglish = new Intl.Locale("en-GB");
const maximized = britishEnglish.maximize();

console.log(maximized.baseName);
// "en-Latn-GB"

La región permanece como se especificó. Solo se añade la escritura faltante.

Identificadores parciales con escrituras

Cuando proporcionas un idioma y una escritura pero no una región, el algoritmo añade la región más común para esa escritura:

const traditionalChinese = new Intl.Locale("zh-Hant");
const maximized = traditionalChinese.maximize();

console.log(maximized.baseName);
// "zh-Hant-TW"

Los caracteres chinos tradicionales se utilizan principalmente en Taiwán, por lo que se añade TW como región.

Las etiquetas de extensión se conservan

Las etiquetas de extensión Unicode especifican preferencias de formato como sistemas de calendario, sistemas de numeración y ciclos horarios. Estas etiquetas aparecen después de -u- en el identificador de configuración regional.

El método maximize() no cambia las etiquetas de extensión. Solo afecta a los componentes de idioma, escritura y región.

const locale = new Intl.Locale("fr", {
  calendar: "gregory",
  numberingSystem: "latn",
  hourCycle: "h23"
});

console.log(locale.toString());
// "fr-u-ca-gregory-hc-h23-nu-latn"

const maximized = locale.maximize();

console.log(maximized.toString());
// "fr-Latn-FR-u-ca-gregory-hc-h23-nu-latn"

El nombre base cambia de fr a fr-Latn-FR, pero las etiquetas de extensión permanecen idénticas.

Cuándo usar maximize

Utiliza el método maximize() cuando necesites identificadores de configuración regional completos para fines de consistencia o comparación.

Normalización de la entrada del usuario

Los usuarios pueden introducir configuraciones regionales en varios formatos. Algunos pueden escribir en, otros en-US, y otros en-Latn-US. Maximizar todas las entradas crea un formato consistente:

function normalizeLocale(input) {
  try {
    const locale = new Intl.Locale(input);
    const maximized = locale.maximize();
    return maximized.baseName;
  } catch (error) {
    return null;
  }
}

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

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

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

Las tres entradas producen la misma forma normalizada.

Construcción de cadenas de respaldo de configuración regional

Cuando una configuración regional específica no está disponible, las aplicaciones recurren a configuraciones regionales más generales. Maximizar ayuda a construir estas cadenas correctamente:

function buildFallbackChain(localeString) {
  const locale = new Intl.Locale(localeString);
  const maximized = locale.maximize();

  const chain = [maximized.toString()];

  if (maximized.script && maximized.region) {
    const withoutRegion = new Intl.Locale(
      `${maximized.language}-${maximized.script}`
    );
    chain.push(withoutRegion.toString());
  }

  if (maximized.region) {
    chain.push(maximized.language);
  }

  chain.push("en");

  return chain;
}

console.log(buildFallbackChain("zh-TW"));
// ["zh-Hant-TW", "zh-Hant", "zh", "en"]

Esto crea un respaldo adecuado desde la configuración regional más específica hasta la más general.

Coincidencia de preferencias de usuario con configuraciones regionales disponibles

Cuando tienes un conjunto de traducciones disponibles y necesitas encontrar la mejor coincidencia para la preferencia de un usuario, maximizar ambos lados permite una comparación precisa:

function findBestMatch(userPreference, availableLocales) {
  const userMaximized = new Intl.Locale(userPreference).maximize();

  const matches = availableLocales.map(available => {
    const availableMaximized = new Intl.Locale(available).maximize();

    let score = 0;
    if (userMaximized.language === availableMaximized.language) score += 1;
    if (userMaximized.script === availableMaximized.script) score += 1;
    if (userMaximized.region === availableMaximized.region) score += 1;

    return { locale: available, score };
  });

  matches.sort((a, b) => b.score - a.score);

  return matches[0].locale;
}

const available = ["en-US", "en-GB", "fr-FR", "de-DE"];
console.log(findBestMatch("en", available));
// "en-US"

La función expande la preferencia del usuario en a en-Latn-US y encuentra la coincidencia más cercana.

Cuándo no usar maximize

No necesitas maximizar los locales antes de pasarlos a las APIs de formateo. Los constructores Intl.DateTimeFormat, Intl.NumberFormat y otros constructores de formateo manejan correctamente los identificadores parciales.

const date = new Date("2025-03-15");

const partial = new Intl.DateTimeFormat("fr").format(date);
const maximized = new Intl.DateTimeFormat("fr-Latn-FR").format(date);

console.log(partial);
// "15/03/2025"

console.log(maximized);
// "15/03/2025"

Ambos producen resultados idénticos. La especificidad adicional no cambia el comportamiento de formateo en este caso.

Utiliza maximize() cuando necesites la información explícita para tu propia lógica, no cuando pases locales a los formateadores incorporados.

Compatibilidad con navegadores

El método maximize() está disponible en todos los navegadores modernos. Chrome, Firefox, Safari y Edge lo soportan como parte de la API Intl.Locale.

Node.js soporta maximize() a partir de la versión 12, con soporte completo en la versión 14 y posteriores.

Resumen

Las etiquetas probables completan los identificadores de locale parciales añadiendo el script y la región más comunes para un idioma determinado. El método Intl.Locale.maximize() implementa el algoritmo Add Likely Subtags de Unicode para realizar esta expansión.

Puntos clave:

  • Las etiquetas probables se basan en datos de uso real del lenguaje
  • El método maximize() añade códigos de script y región faltantes
  • Las etiquetas de extensión para calendarios y sistemas de numeración permanecen sin cambios
  • Utiliza la maximización para normalizar la entrada del usuario y comparar locales
  • Las APIs de formateo no requieren locales maximizados

El método maximize() proporciona una forma estandarizada de trabajar con identificadores de locale completos cuando la lógica de tu aplicación requiere información explícita de script y región.