Définir des constructeurs de types
Encoder des constructeurs de types sous forme de recherches dans des interfaces.
Définir des constructeurs de types est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.
Nommer les constructeurs de types
L'encodage commence par attribuer à chaque constructeur de type un identifiant textuel unique appelé URI. L'URI est une étiquette qui représente le constructeur partout où nous ne pouvons pas transmettre le constructeur lui-même.
type ArrayURI = "Array";
type OptionURI = "Option";
// Each container gets a unique string tagUne interface de registre
Nous conservons une interface unique qui associe chaque URI au type concret qu'il produit pour un argument donné A. Cette interface est le registre. Chaque clé est un URI ; chaque valeur est le type résolu.
interface URItoKind<A> {
Array: Array<A>;
Option: A | null;
}
// URItoKind<number>["Array"] is number[]Rechercher un constructeur
Comme le registre est indexé par URI, l'application d'un constructeur devient un accès indexé. Pour obtenir « tableau appliqué au type nombre », vous indexez le registre.
type ArrayOfNumber = URItoKind<number>["Array"]; // number[]
type OptionOfString = URItoKind<string>["Option"]; // string | nullL'union URIS
L'ensemble des étiquettes de constructeurs valides correspond simplement aux clés du registre. keyof URItoKind<unknown> fournit l'union de tous les URI enregistrés, que nous appelons URIS.
type URIS = keyof URItoKind<unknown>; // "Array" | "Option"La fusion des déclarations étend le registre
Une fonctionnalité puissante de TypeScript : les interfaces portant le même nom fusionnent. Les bibliothèques l'utilisent afin que chaque module puisse ajouter son propre conteneur à URItoKind sans modifier la définition d'origine.
interface URItoKind<A> {
Tree: { value: A; children: Array<A> };
}
// Now URIS also includes "Tree"Des conteneurs modulaires
Grâce à cette fusion, un conteneur défini dans un fichier s'enregistre lui-même à l'échelle globale. Toute personne qui l'importe peut utiliser son URI dans des abstractions génériques. C'est exactement ainsi que fp-ts ajoute l'option, l'alternative, la tâche et bien d'autres conteneurs.
// file a.ts
interface URItoKind<A> { Either: { left: A } | { right: A } }
// file b.ts can now reference the "Either" URIUn porteur fantôme
Pour faire circuler « quel constructeur » comme un type au niveau des valeurs, les instances stockent leur URI dans une propriété, souvent un champ fantôme. Le champ ne contient jamais de valeur réelle ; il enregistre uniquement l'étiquette pour le système de types.
interface HasURI<F extends URIS> {
readonly _URI: F;
}
// _URI records which constructor an instance is forAssocier l'URI à l'argument
L'application d'un constructeur nécessite deux éléments : l'URI F et le type argument A. Nous les combinerons au moyen d'une recherche afin que (F, A) soit résolu en type concret par l'intermédiaire du registre.
type Apply<F extends URIS, A> = URItoKind<A>[F];
type A = Apply<"Array", number>; // number[]
type B = Apply<"Option", string>; // string | nullPourquoi des chaînes plutôt que des constructeurs
Nous utilisons des chaînes, car TypeScript peut les stocker et les comparer en tant que types littéraux, puis indexer un registre avec elles. Nous ne pouvons pas stocker le constructeur Array comme paramètre de type, mais nous pouvons stocker le littéral "Array" et le rechercher.
type Tag = "Array";
type Resolved = URItoKind<boolean>[Tag]; // boolean[]La recherche est l'étape clé
Cet accès indexé, URItoKind<A>[F], est au cœur de l'encodage. Il transforme l'application de type impossible F<A> en une recherche légale dans le registre. La prochaine leçon la formalise sous la forme de Kind<F, A>.
type Kind<F extends URIS, A> = URItoKind<A>[F];
type X = Kind<"Array", number>; // number[]Récapitulatif de la mise en place
Vous disposez maintenant de tous les éléments : les URI comme étiquettes, un registre URItoKind associant une étiquette et un argument à un type concret, URIS comme union des étiquettes, et la fusion des déclarations pour l'étendre. L'indexation du registre simule l'application de type.
// URItoKind = registry, URIS = valid tags,
// URItoKind<A>[F] = "apply constructor F to A"Vérification rapide
Vérifiez votre compréhension de l'encodage par registre.
Récapitulatif
Vous avez appris à encoder des constructeurs de types avec des chaînes.
- Chaque constructeur reçoit une étiquette URI unique.
URItoKind<A>associe les étiquettes aux types concrets.URISest l'union de toutes les étiquettes obtenue aveckeyof.- La fusion des déclarations permet aux modules d'enregistrer de nouveaux conteneurs.
Ensuite : encapsuler la recherche dans le modèle léger Kind.
Questions Fréquemment Posées
La leçon « Définir des constructeurs de types » est-elle gratuite ?
Oui — le texte complet de « Définir des constructeurs de 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 « Définir des constructeurs de types » ?
Encoder des constructeurs de types sous forme de recherches dans des interfaces. 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 2 sur 4.
Combien de temps prend la leçon « Définir des constructeurs de 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
- Le problème des HKT dans TypeScript
- Définir des constructeurs de types
- Le modèle HKT léger
- Foncteurs et mappeurs génériques