TypeScript Academy · Leçon

Pluralisation avec les types

Modéliser les formes plurielles avec la sécurité du typage.

Pluralisation avec les types est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 4 leçons au total.

Pluralisation sûre au niveau des types

Les langues ont besoin de formes plurielles : « 1 élément » contre « 2 éléments ». L'internationalisation sûre au niveau des types modélise les catégories plurielles (comme one / other) et exige un argument count afin que vous ne l'oubliiez jamais.

Catégories de pluriel

Les règles internationales de pluriel définissent des catégories telles que zero, one, two, few, many, other. L'anglais utilise uniquement one et other ; d'autres locales en utilisent davantage.

type PluralCategory = "zero" | "one" | "two" | "few" | "many" | "other";

Structure d'un message pluriel

Représentez un message pluriel sous forme d'objet indexé par catégorie. other constitue la valeur de secours obligatoire.

type PluralMessage = {
  other: string;
} & Partial<Record<Exclude<PluralCategory, "other">, string>>;

const items: PluralMessage = {
  one: "{count} item",
  other: "{count} items",
};

Distinguer les messages pluriels des messages simples

Un catalogue mélange des chaînes simples et des objets pluriels. Les exigences concernant les arguments diffèrent, nous détectons donc la structure au niveau des types.

type IsPlural<M> = M extends { other: string } ? true : false;

Exiger le décompte

Lorsqu'un message est pluriel, les arguments de traduction doivent inclure un count numérique. Nous calculons le type des arguments de manière conditionnelle.

type PluralArgs<M> = IsPlural<M> extends true
  ? { count: number }
  : {};

type A = PluralArgs<typeof items>; // { count: number }

Un t typé pour les pluriels

Combinez la recherche dans le catalogue avec les arguments conditionnels afin que les messages pluriels exigent count, contrairement aux messages simples.

declare const cat: {
  items: { one: string; other: string };
  hello: string;
};

declare function t<K extends keyof typeof cat>(
  key: K,
  args: PluralArgs<(typeof cat)[K]>
): string;

t("items", { count: 3 }); // ok
t("items", {});           // Error: count required
t("hello", {});           // ok

Sélectionner la forme à l'exécution

À l'exécution, Intl.PluralRules choisit la catégorie à partir du décompte, puis vous lisez la chaîne correspondante (en revenant à other si nécessaire).

function plural(msg: { other: string; [k: string]: string }, count: number, locale: string) {
  const cat = new Intl.PluralRules(locale).select(count);
  return (msg[cat] ?? msg.other);
}

Combiner avec l'interpolation

Les chaînes plurielles contiennent généralement aussi {count}. Le type des arguments peut combiner les exigences plurielles avec les variables d'interpolation extraites de la forme choisie.

type FullArgs<M> = PluralArgs<M> & ExtractVars<M>;
// count plus any {placeholders} in the message

Des locales aux formes plus riches

Certaines locales (par exemple le polonais et le russe) utilisent few et many. Comme PluralCategory les inclut déjà, un catalogue peut fournir ces clés et le même mécanisme les prend en charge.

const ruItems = {
  one: "{count} товар",
  few: "{count} товара",
  many: "{count} товаров",
  other: "{count} товара",
};

Imposer la valeur de secours « autre »

Comme other est obligatoire dans PluralMessage, le système de types garantit qu'une valeur de secours existe, ce qui évite une situation à l'exécution où aucune forme plurielle ne correspond.

Pourquoi est-ce important

Les erreurs de pluriel (« 1 articles ») et les décomptes oubliés sont fréquents dans l'internationalisation sans typage. Modéliser les catégories comme des types et exiger count fait de la pluralisation correcte le comportement par défaut et transforme l'absence de décompte en erreur de compilation.

Vérification rapide

Vérifiez votre compréhension de la pluralisation sûre au niveau des types.

Récapitulatif

Vous avez modélisé les pluriels comme des objets indexés par des catégories de pluriel, avec une valeur de secours other obligatoire, détecté les messages pluriels au niveau des types et exigé un argument count numérique au moyen de types conditionnels. Intl.PluralRules sélectionne la forme à l'exécution, et le même mécanisme s'adapte aux locales plus riches.

Questions Fréquemment Posées

La leçon « Pluralisation avec les types » est-elle gratuite ?

Oui — le texte complet de « Pluralisation avec les types » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Pluralisation avec les types » ?

Modéliser les formes plurielles avec la sécurité du typage. Tu pratiques TypeScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer TypeScript Academy ?

Aucune expérience préalable n'est requise. TypeScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Pluralisation avec les types » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon TypeScript Academy ?

Oui. Chaque leçon TypeScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à TypeScript Academy