Docs executáveis de TypeScript: Omit

Q: O que Omit faz no TypeScript?

Omit monta um novo tipo de objeto com todas as propriedades de T, exceto aquelas cujas chaves estão em K. Omit é User sem password. Ele só muda o tipo; não remove nada de um objeto em tempo de execução.

Q: Como omitir várias propriedades no TypeScript?

Passe uma union de chaves como segundo argumento: Omit . Toda chave da union é removida.

Q: Qual a diferença entre Omit e Exclude?

Omit remove propriedades de um tipo de objeto: Omit é { b: 2 }. Exclude remove membros de um union type: Exclude é "b". Omit é implementado com Exclude: Pick >.

Q: Por que Omit não dá erro para uma chave que não existe?

O parâmetro de chave dele é restrito a keyof any (qualquer string, number ou symbol), não a keyof T, então um erro de digitação como Omit compila e não remove nada. Defina type StrictOmit = Omit para ter um erro com chaves desconhecidas.

Q: Como remover uma propriedade de um objeto em tempo de execução no TypeScript?

Use desestruturação com um elemento rest: const { password, ...rest } = user;. O TypeScript tipa rest como o objeto sem password, o mesmo formato de Omit , e a propriedade realmente some do novo objeto.

Omit<T, K> é um utility type embutido que cria um tipo de objeto com todas as propriedades de T, exceto as chaves listadas em K. O uso clássico: um tipo User que tem um password, e uma versão pública que não tem.

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 fica sincronizado com User: adicione um campo a User e ele aparece em PublicUser também, enquanto password continua de fora. Omit funciona só com tipos; é a desestruturação em toPublic que remove a propriedade do objeto de verdade.

Omitindo várias chaves

O segundo argumento é uma union, então liste quantas chaves precisar com |:

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'.

"O tipo sem os campos gerados pelo servidor" é o Omit mais comum em código real: um único tipo de modelo, com Omit derivando o formato de entrada para formulários de criação e requisições de API.

Como Omit é definido

Omit é montado a partir de dois outros utility types:

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

Leia de dentro para fora: keyof T é a union de todas as chaves, Exclude<keyof T, K> remove dessa union as indesejadas, e Pick mantém as chaves restantes. Então Omit<User, "password"> é Pick<User, "id" | "name" | "email">. Como Pick mapeia sobre as chaves de T, os modificadores readonly e ? das propriedades restantes são mantidos.

Repare na restrição: K extends keyof any, não K extends keyof T. Esse detalhe é o assunto da próxima seção.

Omit não verifica se a chave existe

keyof any é string | number | symbol, então Omit aceita qualquer chave, inclusive uma que T não tem. Um erro de digitação compila e não remove nada:

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"}

Nenhum erro em lugar nenhum, e a senha vai embora no JSON. A restrição frouxa foi escolhida de propósito quando Omit foi adicionado no TypeScript 3.5. Os motivos do time: em código genérico, as chaves omitidas muitas vezes não vêm de T (uma função que mescla dois objetos pode tipar o argumento rest como Omit<T1, keyof T2>), Exclude também não restringe o segundo parâmetro, e uma versão restrita teria quebrado muitos dos tipos Omit escritos à mão que os projetos já tinham. No código do dia a dia, uma versão mais estrita pega o erro de digitação:

// 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'.

O primeiro erro é o que importa: a chave é verificada contra keyof User. O segundo decorre dele, já que nada foi omitido e PublicUser ainda exige password. Corrija a grafia para "password" e compila. Muitos projetos definem esse tipo uma vez em um arquivo de tipos compartilhado e o usam no lugar de Omit.

Sobrescrevendo o tipo de uma propriedade

Uma interface não pode estender outra e mudar uma propriedade para um tipo incompatível: interface ApiUser extends User { id: string } falha com error TS2430: Interface 'ApiUser' incorrectly extends interface 'User'. Omita a propriedade primeiro e depois declare-a de novo:

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' }

Com um type alias, a mesma coisa é uma interseção: type ApiUser = Omit<User, "id"> & { id: string }. Sem o Omit, a interseção User & { id: string } daria a id o tipo number & string, que é never.

Omit em union types

Omit não é distributivo. Em uma union, ele parte do keyof da union inteira, que contém só as chaves que todos os membros compartilham, então as propriedades próprias de cada membro desaparecem:

// 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 virou { kind: "circle" | "square" }. Para omitir de cada membro separadamente, aplique Omit dentro de um conditional type distributivo:

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 é sempre verdadeiro; ele está ali só para fazer o conditional type se distribuir sobre a union. A página de conditional types explica por que isso funciona. Use DistributiveOmit sempre que o tipo de onde você omite for uma discriminated union.

Omitindo uma propriedade aninhada

Omit só olha para as chaves do primeiro nível, então Omit<Settings, "editor.wordWrap"> não remove nada (e, como mostrado acima, não reclama). Para tirar uma propriedade um nível abaixo, omita o pai e adicione-o de volta com o seu próprio 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"] é um indexed access type: ele dá nome ao tipo do objeto aninhado para que Omit possa trabalhar com ele.

Removendo propriedades em tempo de execução

Omit muda só o tipo. Para produzir um objeto sem as propriedades, tire-as com desestruturação, ou escreva um pequeno helper genérico cujo tipo de retorno seja 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 ...

O helper restringe K a keyof T, então uma chave com erro de digitação é erro no ponto da chamada. A cópia é rasa: objetos aninhados são compartilhados com o original.

Omit vs Pick vs Exclude

	Funciona com	Mantém	Exemplo	Resultado
`Omit<T, K>`	tipos de objeto	toda propriedade exceto `K`	`Omit<User, "password">`	`{ id; name; email }`
`Pick<T, K>`	tipos de objeto	só as propriedades em `K`	`Pick<User, "id" \| "name">`	`{ id; name }`
`Exclude<U, M>`	union types	membros da union não atribuíveis a `M`	`Exclude<"a" \| "b" \| "c", "a">`	`"b" \| "c"`

Escolha entre Omit e Pick pelo que deve acontecer quando o tipo de origem crescer. Omit inclui as propriedades novas automaticamente, o que combina com "tudo exceto o segredo". Pick nunca as inclui, o que combina com "exatamente estes campos" e é mais seguro para qualquer coisa que sai do seu servidor. Pick verifica as chaves contra keyof T; Omit não.

Perguntas frequentes

O que Omit faz no TypeScript?

Omit<T, K> monta um novo tipo de objeto com todas as propriedades de T, exceto aquelas cujas chaves estão em K. Omit<User, "password"> é User sem password. Ele só muda o tipo; não remove nada de um objeto em tempo de execução.

Como omitir várias propriedades no TypeScript?

Passe uma union de chaves como segundo argumento: Omit<User, "password" | "createdAt" | "updatedAt">. Toda chave da union é removida.

Qual a diferença entre Omit e Exclude?

Omit remove propriedades de um tipo de objeto: Omit<{ a: 1; b: 2 }, "a"> é { b: 2 }. Exclude remove membros de um union type: Exclude<"a" | "b", "a"> é "b". Omit é implementado com Exclude: Pick<T, Exclude<keyof T, K>>.

Por que Omit não dá erro para uma chave que não existe?

O parâmetro de chave dele é restrito a keyof any (qualquer string, number ou symbol), não a keyof T, então um erro de digitação como Omit<User, "pasword"> compila e não remove nada. Defina type StrictOmit<T, K extends keyof T> = Omit<T, K> para ter um erro com chaves desconhecidas.

Como remover uma propriedade de um objeto em tempo de execução no TypeScript?

Use desestruturação com um elemento rest: const { password, ...rest } = user;. O TypeScript tipa rest como o objeto sem password, o mesmo formato de Omit<User, "password">, e a propriedade realmente some do novo objeto.

Conceitos relacionados