0Pricing
TypeScript Academy · Leçon

Types intersection : A et B

Combinez des types avec & pour fusionner leurs propriétés

Types intersection : A et B 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.

Bienvenue

Les types d’intersection combinent plusieurs types en un seul. Une valeur d’un type d’intersection doit satisfaire simultanément à TOUS les types combinés.

Syntaxe de base des intersections

Utilisez l’opérateur `&` pour créer une intersection. Le résultat possède toutes les propriétés des deux types.
type Named = { name: string };
type Aged = { age: number };
type Person = Named & Aged;
const alice: Person = { name: 'Alice', age: 30 };

Toutes les propriétés sont requises

Une intersection exige TOUTES les propriétés de tous les types combinés. L’absence d’une seule propriété constitue une erreur de type.
type A = { x: number };
type B = { y: number };
type AB = A & B;
// const p: AB = { x: 1 }; // Error — missing y

Fusion de types objet

Les intersections servent souvent à fusionner deux types objet qui n’étendent pas l’un l’autre.
type Serializable = { serialize(): string };
type Loggable = { log(): void };
type Service = Serializable & Loggable;

Intersection ou extension

L’extension d’une interface et l’intersection produisent des résultats similaires pour les types objet, mais l’intersection fonctionne avec les alias de type, y compris les unions et les types primitifs.
// Interface extend:
interface C extends A, B {}

// Intersection type:
type D = A & B;
// Both give the same shape for simple objects

Intersection avec des types incompatibles

Si deux types intersectés possèdent la même propriété avec des types incompatibles, le résultat est `never` pour cette propriété.
type X = { id: string };
type Y = { id: number };
type XY = X & Y;
// XY.id is string & number = never — impossible!

Intersection dans les paramètres de fonction

Acceptez un argument qui doit satisfaire à plusieurs contrats d’interface à l’aide d’une intersection.
function process(item: Serializable & Loggable): void {
  item.log();
  console.log(item.serialize());
}

Modèle de composition avec des intersections

Les intersections permettent le modèle de composition : combiner des comportements provenant de plusieurs sources.
type Timestamped<T> = T & { createdAt: Date };
type User = Timestamped<{ name: string; email: string }>;

Les intersections de types primitifs deviennent never

L’intersection de types primitifs qui ne peuvent pas se recouvrir devient `never`.
type T = string & number; // never — a value can't be both

Intersection ou union : la différence essentielle

Une union (`|`) signifie OR : la valeur peut être l’un quelconque des types. Une intersection (`&`) signifie AND : la valeur doit satisfaire à tous les types.

Utilisation des intersections avec les génériques

Combinez un type générique avec des propriétés supplémentaires à l’aide d’une intersection pour obtenir des types flexibles et extensibles.
type WithId<T> = T & { id: number };
const user: WithId<{ name: string }> = { id: 1, name: 'Alice' };

Vérification rapide

À quoi se réduit `type T = string & number` ?

Récapitulatif

Les types d’intersection (`&`) exigent TOUTES les propriétés de tous les types combinés. Utilisez-les pour fusionner des structures d’objets, implémenter des compositions et combiner des types génériques. Les intersections de types primitifs incompatibles deviennent never.

Questions Fréquemment Posées

La leçon « Types intersection : A et B » est-elle gratuite ?

Oui — le texte complet de « Types intersection : A et B » 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 « Types intersection : A et B » ?

Combinez des types avec & pour fusionner leurs propriété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 2 sur 4.

Combien de temps prend la leçon « Types intersection : A et B » ?

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

  1. Types union : A ou B
  2. Types intersection : A et B
  3. Unions discriminées pour un filtrage sûr par motif
  4. Motifs pratiques avec les unions et les intersections
← Retour à TypeScript Academy