Formations — 1 037 leçons en français

Accueil › TypeScript › Importer et exporter des types

Importer et exporter des types

Modules et déclarationsintermediaire

Un module TypeScript exporte deux sortes de choses : des valeurs, qui existent à l'exécution, et des types, qui disparaissent à la compilation. La même syntaxe d'import sert aux deux, et c'est la source de la confusion.

// client.ts
export interface Client { id: string; nom: string }   // type seul
export function creerClient(nom: string): Client {    // valeur
  return { id: crypto.randomUUID(), nom };
}
// facturation.ts
import type { Client } from "./client";       // effacé, toujours
import { creerClient } from "./client";       // conservé

export function facturer(c: Client): number { return 0; }

Ce que import type garantit

Une ligne import type est une déclaration de type. Le compilateur la retire sans exception. Un import ordinaire, lui, n'est retiré que si le compilateur constate qu'aucune de ses liaisons n'est utilisée comme valeur — une analyse qui dépend du reste du fichier.

import { Client } from "./client";

export function facturer(c: Client): number { return 0; }
// `Client` n'est utilisé qu'en position de type.
// La ligne d'import entière disparaît du JavaScript produit.

Le piège de l'effet de bord

Si ./client enregistrait un greffon au moment d'être évalué, cet enregistrement n'a plus lieu : la ligne a disparu. Le symptôme — un registre vide — apparaît ailleurs, longtemps après.

import "./client";                          // chargé pour son effet de bord
import type { Client } from "./client";     // le type, explicitement

Côté export

export type { Client };            // un type
export { creerClient };            // une valeur

export type est obligatoire dès qu'on réexporte un type avec isolatedModules ou verbatimModuleSyntax : un compilateur qui traite les fichiers un par un ne peut pas deviner si Client est un type ou une classe.

Les termes à connaître

`import type`

Une forme d'import qui ne peut amener que des types. Elle est garantie effacée à la compilation : il n'en reste aucune trace dans le JavaScript produit.

`export type`

La symétrique à l'export. export type { Client } annonce que Client n'est qu'un type et ne doit pas être réexporté comme valeur.

Effacement des imports

Le compilateur supprime du fichier produit les imports dont plus aucune liaison n'est utilisée comme valeur. C'est cet effacement qui crée des surprises quand le module avait un effet de bord.

Effet de bord d'un module

Tout ce qu'un module fait au moment d'être évalué : enregistrer un greffon, poser un écouteur, remplir un registre. Cela survient à l'import, indépendamment de ce qu'on en lit.

`verbatimModuleSyntax`

Option de compilation qui interdit au compilateur de deviner : un import écrit sans type est conservé tel quel dans la sortie, et tout ce qui doit disparaître doit porter le mot type.

`isolatedModules`

Option qui refuse tout ce qu'un compilateur fichier par fichier ne peut pas traduire sans connaître les autres fichiers — notamment la réexportation d'un type sans le mot type.

Lire l'explication détaillée et faire le quiz →

Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.