TypeScript Academy · Leçon

Les types comme langage de calcul

Comprendre le système de types comme un langage fonctionnel pur.

Les types comme langage de calcul est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Les types forment un langage

TypeScript contient deux langages qui coexistent. L'un est le JavaScript au niveau des valeurs que vous connaissez déjà. L'autre est le niveau des types, qui s'exécute entièrement à la compilation. Dans ce cours, vous apprenez à programmer dans ce second langage.

Le système de types est un petit langage fonctionnel et pur. Vous lui fournissez des types en entrée, et il calcule des types en sortie. Rien de tout cela ne subsiste à l'exécution.

type Greeting = "hello";
type Loud = Uppercase<Greeting>;
// Loud is "HELLO" - computed by the type system

Des types en entrée, des types en sortie

Un type générique est essentiellement une fonction qui transforme des types en types. Le paramètre de type est l'argument, et le corps est la valeur de retour.

Ci-dessous, Boxed prend un type T et produit un type d'objet qui l'enveloppe. Considérez T comme un paramètre que vous fournissez.

type Boxed<T> = { value: T };

type A = Boxed<number>; // { value: number }
type B = Boxed<string>; // { value: string }

Les types génériques sont des fonctions

Comparez une fonction au niveau des valeurs avec une fonction au niveau des types. Les structures sont presque identiques : des paramètres en entrée et un seul résultat en sortie.

Valeur : const id = (x) => x
Type : type Id<T> = T

Le Id au niveau des types renvoie simplement tout ce que vous lui fournissez.

type Id<T> = T;

type X = Id<boolean>; // boolean
type Y = Id<"abc">;  // "abc"

Aucun coût à l'exécution

Tout ce qui relève du niveau des types est effacé avant l'exécution de votre code. La sortie JavaScript ne contient aucune trace de vos calculs de types. Le programme en cours d'exécution n'a aucun coût de performance supplémentaire, aussi complexes que soient vos types.

C'est pourquoi la programmation au niveau des types est parfois qualifiée de gratuite : elle n'affecte que le compilateur, jamais le paquet final.

type Pair<T> = [T, T];
const p: Pair<number> = [1, 2];
// Compiled JS is just: const p = [1, 2];
console.log(p);

Plusieurs paramètres

Les fonctions au niveau des types peuvent prendre plusieurs paramètres, tout comme les fonctions ordinaires. Ici, Merge prend deux types d'objets et les combine.

Lisez-le ainsi : étant donnés A et B, renvoyer un objet qui possède toutes les propriétés des deux.

type Merge<A, B> = A & B;

type User = { id: number };
type Named = { name: string };
type NamedUser = Merge<User, Named>;
// { id: number; name: string }

Valeurs par défaut des paramètres

Les paramètres de type peuvent avoir des valeurs par défaut, exactement comme les arguments de fonction par défaut. Si l’appelant omet l’argument, la valeur par défaut est utilisée.

type List<T = string> = T[];

type A = List;        // string[]
type B = List<number>; // number[]

Les contraintes servent de garde-fous

Une contrainte avec extends limite les types qui peuvent être transmis. C’est l’équivalent au niveau des types de la validation d’un argument de fonction avant son utilisation.

HasId n’accepte que les types qui possèdent déjà une propriété id, de sorte que le corps peut la lire en toute sécurité.

type GetId<T extends { id: number }> = T["id"];

type A = GetId<{ id: number; name: string }>; // number
// GetId<{ name: string }> would be a compile error

Calcul, pas simple annotation

Les débutants utilisent les types uniquement pour étiqueter les valeurs. La programmation au niveau des types utilise les types pour calculer des résultats. L’utilitaire intégré ReturnType, par exemple, examine un type de fonction et en extrait le type de résultat.

type Fn = (a: number) => string;
type R = ReturnType<Fn>; // string

type Fn2 = () => boolean;
type R2 = ReturnType<Fn2>; // boolean

Parcourir les propriétés

Les types mappés permettent de transformer chaque propriété d’un type objet. C’est une boucle dans le langage des types. Stringify transforme chaque type de valeur en string.

type Stringify<T> = { [K in keyof T]: string };

type Input = { a: number; b: boolean };
type Out = Stringify<Input>; // { a: string; b: string }

Pur et déterministe

Le langage des types est pur : les mêmes entrées produisent toujours le même type de sortie, sans effets secondaires. Il n’y a ni mutation, ni IO, ni temps. C’est cette pureté qui rend les programmes au niveau des types prévisibles et combinables.

Grâce à cette pureté, vous raisonnez sur les types comme en mathématiques : par substitution.

type Square<T extends { area: number }> = T["area"];
// Always the same result for the same input shape

Pourquoi c’est important

Maîtriser ce second langage vous permet d’encoder des règles que le compilateur applique gratuitement : des routes valides, des instructions de sélection exhaustives, une manipulation sûre des chaînes et des API impossibles à mal utiliser. Le reste de ce cours construit la boîte à outils.

Idée clé : un type est une valeur dans le langage des types, et un générique est une fonction.

type NonEmpty<T extends unknown[]> =
  T extends [unknown, ...unknown[]] ? T : never;
// Encodes a rule: the tuple must have at least one element

Vérification rapide

Vérifiez votre compréhension des types en tant que langage de calcul.

Récapitulatif

Vous avez appris que les types de TypeScript forment un langage fonctionnel pur exécuté à la compilation.

Les génériques sont des fonctions : des types en entrée, des types en sortie.
Les paramètres prennent en charge les valeurs par défaut et les contraintes extends.
Les types mappés parcourent les propriétés.
Tout est supprimé, ce qui signifie qu’il n’y a aucun coût à l’exécution.

Ensuite, vous allez donner à ce langage une instruction conditionnelle : les types conditionnels.

Questions Fréquemment Posées

La leçon « Les types comme langage de calcul » est-elle gratuite ?

Oui — le texte complet de « Les types comme langage de calcul » 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 « Les types comme langage de calcul » ?

Comprendre le système de types comme un langage fonctionnel pur. 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 1 sur 4.

Combien de temps prend la leçon « Les types comme langage de calcul » ?

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