Intl.PluralRules

Description

Les langues utilisent différents schémas pour exprimer à la fois les nombres pluriels d'éléments (nombres cardinaux) et pour exprimer l'ordre des éléments (nombres ordinaux). L'anglais a deux formes pour exprimer les nombres cardinaux : une pour le « singulier » (1 heure, 1 chien, 1 poisson) et l'autre pour zéro ou tout autre nombre « d'éléments » (0 heures, 2 lemmings, 100000,5 poissons), tandis que le chinois n'a qu'une seule forme, et l'arabe en a six ! De même, l'anglais a quatre formes pour exprimer les nombres ordinaux : « th », « st », « nd », « rd », donnant la séquence : 0th, 1st, 2nd, 3rd, 4th, 5th, ..., 21st, 22nd, 23rd, 24th, 25th, et ainsi de suite, tandis que le chinois et l'arabe n'ont qu'une seule forme pour les nombres ordinaux.

Étant donné une langue particulière et un ensemble d'options de formatage, les méthodes Intl.PluralRules.prototype.select() et Intl.PluralRules.prototype.selectRange() retournent une balise qui représente la forme plurielle d'un nombre unique ou d'une plage de nombres, cardinal ou ordinal. Le code peut utiliser les balises retournées pour représenter les nombres de manière appropriée pour la langue donnée. L'ensemble complet des balises pouvant être retournées est : zero, one, two, few, many et other (la forme plurielle « générale », également utilisée si la langue n'a qu'une seule forme).

Comme l'anglais n'a que deux formes pour les nombres cardinaux, la méthode select() ne retourne que deux balises : "one" pour le cas singulier, et "other" pour tous les autres nombres cardinaux. Cela permet de construire des phrases qui ont du sens en anglais pour chaque cas, par exemple : « 1 dog is happy; do you want to play with it? » et « 10 dogs are happy; do you want to play with them? ».

Créer des phrases appropriées pour chaque forme dépend de la langue, et même en anglais, cela peut ne pas être aussi simple que d'ajouter « s » à un nom pour former le pluriel. En utilisant l'exemple ci-dessus, nous voyons que la forme peut affecter :

• Noms : 1 chien, 2 chiens (mais pas « poisson » ou « mouton », qui ont la même forme au singulier et au pluriel).
• Verbes : 1 chien est heureux, 2 chiens sont heureux.
• Pronoms (et autres référents) : Voulez-vous jouer avec lui / eux ?

D'autres langues ont plus de formes, et choisir des phrases appropriées peut être encore plus complexe.

select() peut retourner l'une des quatre balises pour les nombres ordinaux en anglais, représentant chacune des formes autorisées : one pour les nombres « st » (1, 21, 31, ...), two pour les nombres « nd » (2, 22, 32, ...), few pour les nombres « rd » (3, 33, 43, ...), et other pour les nombres « th » (0, 4-20, etc.). Encore une fois, les balises retournées permettent de formater correctement les chaînes de caractères décrivant un nombre ordinal.

Pour plus d'informations sur les règles et leur utilisation, voir les règles de pluriel ^(angl.). Pour une liste des règles et de leur application pour différentes langues, voir les règles de pluriel LDML ^(angl.).

Constructeur

Intl.PluralRules()

Crée un nouvel objet Intl.PluralRules.

Méthodes statiques

Intl.PluralRules.supportedLocalesOf()

Retourne un tableau qui contient les locales, parmi celles fournies en arguments, qui sont prises en charge sans avoir à recourir à la locale par défaut de l'environnement d'exécution.

Propriétés d'instance

Ces propriétés sont définies sur Intl.PluralRules.prototype et partagées par toutes les instances de Intl.PluralRules.

Intl.PluralRules.prototype.constructor

La fonction constructeur qui a créé l'objet instance. Pour les instances de Intl.PluralRules, la valeur initiale est le constructeur Intl.PluralRules.

Intl.PluralRules.prototype[Symbol.toStringTag]

La valeur initiale de la propriété [Symbol.toStringTag] est la chaîne de caractères "Intl.PluralRules". Cette propriété est utilisée dans Object.prototype.toString().

Méthodes d'instance

Intl.PluralRules.prototype.resolvedOptions()

Retourne un nouvel objet dont les propriétés reflètent les options de locale et de collation calculées à l'initialisation de l'objet.

Intl.PluralRules.prototype.select()

Retourne une chaîne de caractères indiquant la règle de nombre qui s'applique pour le formatage en fonction de la locale.

Intl.PluralRules.prototype.selectRange()

Cette méthode prend deux valeurs en arguments et renvoie une chaîne de caractères indiquant la règle de nombre à utiliser pour le formatage en fonction de la locale.

Exemples

Utiliser les locales

Cet exemple montre certaines des variations dans les règles de pluriel localisées pour les nombres cardinaux.

Pour obtenir le format pour la langue utilisée dans l'interface utilisateur de votre application, assurez-vous de définir cette langue (et éventuellement certaines langues de secours) en utilisant l'argument locales du constructeur :

// Anglais (États-Unis)
const enCardinalRules = new Intl.PluralRules("en-US");
console.log(enCardinalRules.select(0)); // "other"
console.log(enCardinalRules.select(1)); // "one"
console.log(enCardinalRules.select(2)); // "other"
console.log(enCardinalRules.select(3)); // "other"

// Arabe
const arCardinalRules = new Intl.PluralRules("ar-EG");
console.log(arCardinalRules.select(0)); // "zero"
console.log(arCardinalRules.select(1)); // "one"
console.log(arCardinalRules.select(2)); // "two"
console.log(arCardinalRules.select(6)); // "few"
console.log(arCardinalRules.select(18)); // "many"

Utiliser les options

La forme plurielle du nombre défini peut également dépendre des options du constructeur, telles que la manière dont le nombre est arrondi et s'il s'agit d'un nombre cardinal ou ordinal.

Cet exemple montre comment vous pouvez définir le type de règles sur "ordinal", et comment cela affecte la forme pour certains nombres en anglais américain.

// Anglais (États-Unis) - ordinal
const enOrdinalRules = new Intl.PluralRules("en-US", { type: "ordinal" });
console.log(enOrdinalRules.select(0)); // "other" (0th)
console.log(enOrdinalRules.select(1)); // "one"   (1st)
console.log(enOrdinalRules.select(2)); // "two"   (2nd)
console.log(enOrdinalRules.select(3)); // "few"   (3rd)
console.log(enOrdinalRules.select(4)); // "other" (4th)
console.log(enOrdinalRules.select(21)); // "one"  (21st)

Formater du texte en utilisant la balise retournée

Le code ci-dessous étend l'exemple précédent, montrant comment vous pouvez utiliser la balise retournée pour un nombre ordinal afin de formater du texte en anglais.

const enOrdinalRules = new Intl.PluralRules("en-US", { type: "ordinal" });

const suffixes = new Map([
  ["one", "st"],
  ["two", "nd"],
  ["few", "rd"],
  ["other", "th"],
]);
const formatOrdinals = (n) => {
  const rule = enOrdinalRules.select(n);
  const suffix = suffixes.get(rule);
  return `${n}${suffix}`;
};

formatOrdinals(0); // '0th'
formatOrdinals(1); // '1st'
formatOrdinals(2); // '2nd'
formatOrdinals(3); // '3rd'
formatOrdinals(4); // '4th'
formatOrdinals(11); // '11th'
formatOrdinals(21); // '21st'
formatOrdinals(42); // '42nd'
formatOrdinals(103); // '103rd'

Spécifications

Compatibilité des navigateurs

Voir aussi

• Une prothèse d'émulation pour Intl.ListFormat dans FormatJS ^(angl.)
• L'objet Intl