TypeScript Academy · Leçon

Inférence des types selon la langue

Garantir que toutes les langues partagent la même structure de clés.

Inférence des types selon la langue est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Inférence de types adaptée aux locales

Une application fournit plusieurs locales (en, tr, de...). Nous voulons un type qui signale une erreur lorsqu'une locale ne contient pas les clés présentes dans la base, afin que les traductions ne se désynchronisent jamais silencieusement.

Une locale de référence

Choisissez une locale (généralement en) comme structure de clés canonique. Toutes les autres locales doivent avoir la même forme.

const en = {
  greeting: "Hello",
  cart: { empty: "Empty", checkout: "Checkout" },
} as const;

type Base = typeof en;

Contraindre les autres locales

Donnez à chaque locale supplémentaire la forme de la base. Une clé manquante devient alors une erreur de compilation dans le fichier de cette locale.

const tr: Base = {
  greeting: "Merhaba",
  cart: { empty: "Bo\u015f", checkout: "\u00d6deme" },
};
// Omitting cart.checkout -> Error: property missing

Détecter aussi les clés supplémentaires

Utiliser le type de base comme annotation signale également les clés inconnues présentes dans une locale mais absentes de la base, ce qui permet de détecter les entrées restantes ou mal orthographiées.

const de: Base = {
  greeting: "Hallo",
  cart: { empty: "Leer", checkout: "Kasse" },
  extra: "oops", // Error: not in Base
};

Une fonction auxiliaire pour définir les locales

Une fonction auxiliaire générique impose la structure tout en préservant chaque valeur, offrant un emplacement de définition clair pour chaque locale.

function defineLocale<T extends Base>(loc: T): T {
  return loc;
}

const fr = defineLocale({
  greeting: "Bonjour",
  cart: { empty: "Vide", checkout: "Paiement" },
});

Un registre de toutes les locales

Rassemblez les locales dans un enregistrement. Contraindre chaque valeur à Base garantit une structure uniforme dans toute l'application.

const locales: Record<string, Base> = { en, tr, de: fr };
// every entry must have the full Base key structure

Égalité profonde au niveau des types

Pour obtenir des garanties plus strictes, vous pouvez créer un type SameKeys qui compare en profondeur les structures de clés et se résout en un type d'erreur lorsqu'elles diffèrent, au-delà de ce qu'une simple annotation peut détecter.

type SameKeys<A, B> =
  keyof A extends keyof B
    ? keyof B extends keyof A ? true : false
    : false;

Déduire les clés une seule fois

Comme toutes les locales partagent Base, le type des chemins de clés (provenant de la leçon précédente) est calculé une seule fois à partir de Base et réutilisé pour chaque locale ; le typage de t est donc indépendant de la locale.

type Key = LeafPaths<Base>;
// same valid keys regardless of active locale

Sélection de la locale à l'exécution

À l'exécution, vous indexez le registre avec la locale active ; le système de types a déjà garanti que chaque locale possède les mêmes clés, les recherches sont donc sûres.

function translate(locale: keyof typeof locales, key: Key): string {
  return getPath(locales[locale], key);
}

Détecter les clés manquantes entre les locales

Si vous ne pouvez pas annoter directement chaque fichier (par exemple lors d'importations JSON), une vérification de types lors de la construction compare chaque locale importée à Base et fait apparaître un type de différence répertoriant les clés manquantes.

type Missing<L> = Exclude<keyof Base, keyof L>;
type TrMissing = Missing<typeof tr>; // never if complete

Pourquoi est-ce important

L'internationalisation sans typage dérive : une clé ajoutée à en est oubliée dans de, ce qui entraîne la livraison d'une chaîne vide ou anglaise. Contraindre chaque locale à une base partagée transforme cette omission en erreur de compilation et préserve l'exhaustivité et la cohérence de toutes les locales.

Vérification rapide

Vérifiez votre compréhension de l'inférence adaptée aux locales.

Récapitulatif

Vous avez choisi une locale de référence comme forme canonique et contraint toutes les autres locales à s'y conformer ; les clés manquantes ou supplémentaires empêchent donc la compilation. Une fonction auxiliaire defineLocale et un registre contraint maintiennent une structure identique pour toutes les locales, et les chemins de clés sont déduits une seule fois à partir de la base.

Questions Fréquemment Posées

La leçon « Inférence des types selon la langue » est-elle gratuite ?

Oui — le texte complet de « Inférence des types selon la langue » 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 « Inférence des types selon la langue » ?

Garantir que toutes les langues partagent la même structure de clés. 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 4 sur 4.

Combien de temps prend la leçon « Inférence des types selon la langue » ?

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