Exclure des champs d'un type en TypeScript : guide simple

Comment exclure une propriété d'un type en TypeScript : débarrassez votre code du superflu

Avez-vous déjà été confronté à une situation où vous avez une grande interface ou un type, et vous devez créer un nouveau type presque identique, mais sans un ou deux champs ? Dupliquer tout le code ? Copier 15 lignes et en supprimer une ? Il existe une façon plus élégante. Aujourd'hui, nous allons voir comment exclure une propriété d'un type en TypeScript — c'est l'un des utilitaires les plus populaires, qui évite la duplication et rend le code plus propre.

Ce sujet est un véritable succès sur Stack Overflow. La question "Exclure une propriété d'un type" recueille des milliers de vues, car tôt ou tard, chaque développeur doit supprimer un champ d'un type ou exclure une propriété d'une interface. Commençons par le commencement, avec des exemples simples jusqu'aux techniques avancées.

Le problème : pourquoi exclure des champs d'un type ?

Imaginez que vous ayez une interface User :

interface User {\n  id: number;\n  name: string;\n  email: string;\n  password: string;\n  createdAt: Date;\n}

Vous souhaitez créer un formulaire d'inscription où l'utilisateur saisit son nom, son email et son mot de passe. Mais id est généré par le serveur, et createdAt est automatique. Vous avez besoin d'un type NewUser qui contient uniquement name, email et password. Comment faire ?

Une mauvaise solution serait de déclarer une nouvelle interface à partir de zéro :

interface NewUser {\n  name: string;\n  email: string;\n  password: string;\n}

Cela fonctionne, mais viole le principe DRY (Don't Repeat Yourself). Si nous modifions le type de name dans User, il faudra aussi le modifier dans NewUser. C'est là que l'exclusion de propriétés d'un type vient à la rescousse.

Le type utilitaire Omit : l'outil principal

TypeScript fournit un type utilitaire intégré Omit<Type, Keys>. Il crée un nouveau type en excluant les clés spécifiées du type d'origine. La syntaxe est simple :

type NewUser = Omit<User, 'id' | 'createdAt'>;

Maintenant, NewUser contient uniquement name, email et password. Si nous modifions email en Email dans User, NewUser le prendra automatiquement en compte.

Vérifions en pratique :

const newUser: NewUser = {\n  name: 'Anna',\n  email: 'anna@example.com',\n  password: 'secure123'\n}; // ✅ Tout va bien\n\nconst invalidUser: NewUser = {\n  name: 'Anna',\n  email: 'anna@example.com',\n  password: 'secure123',\n  id: 1 // ❌ Erreur : id n'existe pas dans le type NewUser\n};

Notez bien : Omit fonctionne aussi bien avec les interfaces qu'avec les types. C'est un outil universel pour exclure des champs d'un type.

Comment fonctionne Omit sous le capot ?

Pour mieux comprendre comment TypeScript exclut des propriétés d'un type, regardons sous le capot. Omit est une combinaison de deux autres utilitaires : Pick et Exclude.

Voici comment il est défini dans la bibliothèque standard de TypeScript :

type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;

Décomposons étape par étape :

\n
• keyof T — obtient toutes les clés du type T (par exemple, 'id' | 'name' | 'email' | 'password' | 'createdAt')
\n
• Exclude<keyof T, K> — exclut de ces clés celles spécifiées dans K (on obtient 'name' | 'email' | 'password')
\n
• Pick<T, ...> — sélectionne dans T uniquement les clés restantes
\n

Ainsi, l'exclusion d'une propriété d'une interface se résume à un filtrage des clés. Élégant, n'est-ce pas ?

Pick : le revers de Omit

Parfois, il est plus simple de ne pas exclure, mais au contra