Docs TypeScript exécutables : Omit

Q: À quoi sert Omit en TypeScript ?

Omit construit un nouveau type objet avec toutes les propriétés de T, sauf celles dont les clés sont dans K. Omit est User sans password. Il ne change que le type ; il ne retire rien d'un objet à l'exécution.

Q: Comment omettre plusieurs propriétés en TypeScript ?

Passez une union de clés en second argument : Omit . Chaque clé de l'union est retirée.

Q: Quelle est la différence entre Omit et Exclude ?

Omit retire des propriétés d'un type objet : Omit vaut { b: 2 }. Exclude retire des membres d'un type union : Exclude vaut "b". Omit est implémenté avec Exclude : Pick >.

Q: Pourquoi Omit ne signale-t-il pas d'erreur pour une clé qui n'existe pas ?

Son paramètre de clés est contraint à keyof any (n'importe quel string, number ou symbol), et non à keyof T, donc une faute de frappe comme Omit compile et ne retire rien. Définissez type StrictOmit = Omit pour obtenir une erreur sur les clés inconnues.

Q: Comment supprimer une propriété d'un objet à l'exécution en TypeScript ?

Utilisez la déstructuration avec un élément rest : const { password, ...rest } = user;. TypeScript type rest comme l'objet sans password, la même forme que Omit , et la propriété a réellement disparu du nouvel objet.

Omit<T, K> est un utility type intégré qui crée un type objet avec toutes les propriétés de T sauf les clés listées dans K. L'usage classique : un type User qui a un password, et une version publique qui n'en a pas.

interface User {
  id: number;
  name: string;
  email: string;
  password: string;
}

type PublicUser = Omit<User, "password">;
// { id: number; name: string; email: string }

function toPublic(user: User): PublicUser {
  const { password, ...rest } = user; // really remove it from the object
  return rest;
}

const ada: User = { id: 1, name: "Ada", email: "ada@example.com", password: "s3cret" };
console.log(toPublic(ada)); // { id: 1, name: 'Ada', email: 'ada@example.com' }

PublicUser reste synchronisé avec User : ajoutez un champ à User et il apparaît aussi dans PublicUser, tandis que password reste exclu. Omit ne fonctionne que sur les types ; c'est la déstructuration dans toPublic qui retire la propriété de l'objet réel.

Omettre plusieurs clés

Le second argument est une union : listez autant de clés que nécessaire avec | :

interface Post {
  id: number;
  title: string;
  body: string;
  createdAt: string;
  updatedAt: string;
}

// What a client sends to create a post: the server fills in the rest
type NewPost = Omit<Post, "id" | "createdAt" | "updatedAt">;

function createPost(input: NewPost, id: number): Post {
  const now = "2024-03-15T10:30:00.000Z";
  return { ...input, id, createdAt: now, updatedAt: now };
}

const post = createPost({ title: "Hello", body: "First post" }, 7);
console.log(post.id, post.title, post.createdAt); // 7 Hello 2024-03-15T10:30:00.000Z
// createPost({ title: "x", body: "y", id: 1 }, 7) would be error TS2353:
// Object literal may only specify known properties, and 'id' does not exist in type 'NewPost'.

« Le type sans les champs générés par le serveur » est le Omit le plus courant dans du vrai code : un seul type modèle, et Omit en dérive la forme d'entrée pour les formulaires de création et les requêtes d'API.

Comment Omit est défini

Omit est construit à partir de deux autres utility types :

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

Lisez-le de l'intérieur : keyof T est l'union de toutes les clés, Exclude<keyof T, K> retire de cette union les clés indésirables, et Pick garde les clés restantes. Ainsi, Omit<User, "password"> vaut Pick<User, "id" | "name" | "email">. Comme Pick parcourt les clés de T, les modificateurs readonly et ? des propriétés restantes sont conservés.

Remarquez la contrainte : K extends keyof any, et non K extends keyof T. Ce détail fait l'objet de la section suivante.

Omit ne vérifie pas que la clé existe

keyof any vaut string | number | symbol, donc Omit accepte absolument n'importe quelle clé, y compris une que T ne possède pas. Une faute de frappe compile et ne retire rien :

interface User {
  id: number;
  name: string;
  password: string;
}

type PublicUser = Omit<User, "pasword">; // typo: nothing is omitted

function toPublic(user: User): PublicUser {
  return user; // compiles, because PublicUser still has password
}

console.log(JSON.stringify(toPublic({ id: 1, name: "Ada", password: "s3cret" })));
// {"id":1,"name":"Ada","password":"s3cret"}

Aucune erreur nulle part, et le mot de passe part dans le JSON. Cette contrainte lâche a été choisie volontairement quand Omit a été ajouté dans TypeScript 3.5. Les raisons de l'équipe : dans du code générique, les clés omises ne viennent souvent pas de T (une fonction qui fusionne deux objets peut typer son argument rest comme Omit<T1, keyof T2>), Exclude ne contraint pas non plus son second paramètre, et une version contrainte aurait cassé beaucoup des types Omit écrits à la main que les projets avaient déjà. Pour le code de tous les jours, une version plus stricte attrape la faute de frappe :

// This does not compile: StrictOmit only accepts real keys of User
type StrictOmit<T, K extends keyof T> = Omit<T, K>;

interface User {
  id: number;
  name: string;
  password: string;
}

type PublicUser = StrictOmit<User, "pasword">;
const u: PublicUser = { id: 1, name: "Ada" };
console.log(u);

index.ts(10,36): error TS2344: Type '"pasword"' does not satisfy the constraint 'keyof User'.
index.ts(11,7): error TS2741: Property 'password' is missing in type '{ id: number; name: string; }' but required in type 'PublicUser'.

La première erreur est celle qui compte : la clé est vérifiée par rapport à keyof User. La seconde en découle, puisque rien n'a été omis et que PublicUser exige toujours password. Corrigez l'orthographe en "password" et le code compile. Beaucoup de projets la définissent une fois dans un fichier de types partagé et l'utilisent à la place de Omit.

Redéfinir le type d'une propriété

Une interface ne peut pas en étendre une autre en changeant une propriété vers un type incompatible : interface ApiUser extends User { id: string } échoue avec error TS2430: Interface 'ApiUser' incorrectly extends interface 'User'. Omettez d'abord la propriété, puis redéclarez-la :

interface User {
  id: number;
  name: string;
  createdAt: Date;
}

// The JSON version: id is a string and dates are ISO strings
interface ApiUser extends Omit<User, "id" | "createdAt"> {
  id: string;
  createdAt: string;
}

function toApi(user: User): ApiUser {
  return { ...user, id: String(user.id), createdAt: user.createdAt.toISOString() };
}

const u: User = { id: 7, name: "Ada", createdAt: new Date("2024-03-15T10:30:00Z") };
console.log(toApi(u)); // { id: '7', name: 'Ada', createdAt: '2024-03-15T10:30:00.000Z' }

Avec un alias de type, la même chose s'écrit avec une intersection : type ApiUser = Omit<User, "id"> & { id: string }. Sans le Omit, l'intersection User & { id: string } donnerait à id le type number & string, c'est-à-dire never.

Omit sur les types union

Omit n'est pas distributif. Sur une union, il part du keyof de l'union entière, qui ne contient que les clés communes à tous les membres, donc les propriétés propres à chaque membre disparaissent :

// This does not compile: Omit collapsed the union into its shared keys
type Shape =
  | { kind: "circle"; radius: number; id: string }
  | { kind: "square"; size: number; id: string };

type NewShape = Omit<Shape, "id">;

const c: NewShape = { kind: "circle", radius: 2 };
console.log(c);

index.ts(8,39): error TS2353: Object literal may only specify known properties, and 'radius' does not exist in type 'NewShape'.

NewShape est devenu { kind: "circle" | "square" }. Pour omettre dans chaque membre séparément, appliquez Omit dans un type conditionnel distributif :

type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;

type Shape =
  | { kind: "circle"; radius: number; id: string }
  | { kind: "square"; size: number; id: string };

type NewShape = DistributiveOmit<Shape, "id">;
// Omit<circle, "id"> | Omit<square, "id">

function area(s: NewShape): number {
  return s.kind === "circle" ? Math.PI * s.radius ** 2 : s.size ** 2; // narrowing works
}

console.log(area({ kind: "square", size: 3 }));            // 9
console.log(area({ kind: "circle", radius: 1 }).toFixed(2)); // 3.14

T extends unknown ? ... : never est toujours vrai ; il n'est là que pour faire distribuer le type conditionnel sur l'union. La page sur les types conditionnels explique pourquoi cela fonctionne. Utilisez DistributiveOmit chaque fois que le type d'origine est une union discriminée.

Omettre une propriété imbriquée

Omit ne regarde que les clés de premier niveau, donc Omit<Settings, "editor.wordWrap"> ne retire rien (et, comme on l'a vu plus haut, ne se plaint pas). Pour retirer une propriété un niveau plus bas, omettez le parent et rajoutez-le avec son propre Omit :

interface Settings {
  theme: string;
  editor: { fontSize: number; tabSize: number; wordWrap: boolean };
}

type SettingsDraft = Omit<Settings, "editor"> & {
  editor: Omit<Settings["editor"], "wordWrap">;
};

const draft: SettingsDraft = { theme: "dark", editor: { fontSize: 14, tabSize: 2 } };
console.log(draft.editor); // { fontSize: 14, tabSize: 2 }
// Adding wordWrap: true to editor would be error TS2353

Settings["editor"] est un indexed access type : il nomme le type de l'objet imbriqué pour que Omit puisse agir dessus.

Retirer des propriétés à l'exécution

Omit ne change que le type. Pour produire un objet sans les propriétés, retirez-les par déstructuration, ou écrivez un petit helper générique dont le type de retour est Omit :

function omit<T extends object, K extends keyof T>(obj: T, ...keys: K[]): Omit<T, K> {
  const copy = { ...obj };
  for (const key of keys) delete copy[key];
  return copy;
}

const order = { id: 42, total: 99.5, cardNumber: "4111 1111", cvv: "123" };

const safe = omit(order, "cardNumber", "cvv"); // { id: number; total: number }
console.log(safe);        // { id: 42, total: 99.5 }
console.log(order.cvv);   // 123 (the original is untouched)
// safe.cvv would be error TS2339: Property 'cvv' does not exist on type ...

Le helper contraint K à keyof T, donc une clé mal orthographiée est une erreur à l'appel. La copie est superficielle : les objets imbriqués sont partagés avec l'original.

Omit vs Pick vs Exclude

	Agit sur	Garde	Exemple	Résultat
`Omit<T, K>`	types objets	toutes les propriétés sauf `K`	`Omit<User, "password">`	`{ id; name; email }`
`Pick<T, K>`	types objets	seulement les propriétés de `K`	`Pick<User, "id" \| "name">`	`{ id; name }`
`Exclude<U, M>`	types union	les membres de l'union non affectables à `M`	`Exclude<"a" \| "b" \| "c", "a">`	`"b" \| "c"`

Choisissez entre Omit et Pick selon ce qui doit se passer quand le type source grandit. Omit inclut automatiquement les nouvelles propriétés, ce qui convient à « tout sauf le secret ». Pick ne les inclut jamais, ce qui convient à « exactement ces champs » et reste plus sûr pour tout ce qui quitte votre serveur. Pick vérifie ses clés par rapport à keyof T ; Omit ne le fait pas.

Questions fréquentes

À quoi sert Omit en TypeScript ?

Omit<T, K> construit un nouveau type objet avec toutes les propriétés de T, sauf celles dont les clés sont dans K. Omit<User, "password"> est User sans password. Il ne change que le type ; il ne retire rien d'un objet à l'exécution.

Comment omettre plusieurs propriétés en TypeScript ?

Passez une union de clés en second argument : Omit<User, "password" | "createdAt" | "updatedAt">. Chaque clé de l'union est retirée.

Quelle est la différence entre Omit et Exclude ?

Omit retire des propriétés d'un type objet : Omit<{ a: 1; b: 2 }, "a"> vaut { b: 2 }. Exclude retire des membres d'un type union : Exclude<"a" | "b", "a"> vaut "b". Omit est implémenté avec Exclude : Pick<T, Exclude<keyof T, K>>.

Pourquoi Omit ne signale-t-il pas d'erreur pour une clé qui n'existe pas ?

Son paramètre de clés est contraint à keyof any (n'importe quel string, number ou symbol), et non à keyof T, donc une faute de frappe comme Omit<User, "pasword"> compile et ne retire rien. Définissez type StrictOmit<T, K extends keyof T> = Omit<T, K> pour obtenir une erreur sur les clés inconnues.

Comment supprimer une propriété d'un objet à l'exécution en TypeScript ?

Utilisez la déstructuration avec un élément rest : const { password, ...rest } = user;. TypeScript type rest comme l'objet sans password, la même forme que Omit<User, "password">, et la propriété a réellement disparu du nouvel objet.

Concepts liés