0Pricing
Frontend Academy · Aula

Tipos utilitários: Partial Required Pick Omit

Transforme tipos existentes com tipos utilitários integrados para criar variações sem duplicação.

Tipos utilitários: Partial Required Pick Omit é uma aula grátis de Frontend Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Frontend Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Frontend Academy inclui 4 aulas no total.

Tipos utilitários integrados

O TypeScript vem com um conjunto de tipos utilitários genéricos que transformam outros tipos. Eles eliminam a necessidade de reescrever manualmente variações semelhantes de interfaces.

Partial<T>

Torna todas as propriedades de T opcionais. É perfeito para dados enviados em atualizações ou correções, quando nem todos os campos precisam ser fornecidos.

interface User { name: string; email: string; age: number; }

function updateUser(id: string, changes: Partial<User>) {
  // changes.name is string | undefined
  // changes.email is string | undefined
}

updateUser('1', { name: 'Bob' }); // only update name

Required<T>

O oposto de Partial — torna todas as propriedades obrigatórias, removendo os modificadores opcionais (?).

interface Config {
  host?: string;
  port?: number;
  debug?: boolean;
}

function validate(config: Required<Config>) {
  // All three are now required
  console.log(config.host, config.port, config.debug);
}

Pick<T, K>

Cria um tipo com apenas as propriedades especificadas de T. É útil para reduzir objetos grandes aos campos necessários.

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

type PublicUser = Pick<User, 'id' | 'name' | 'email'>;
// { id: number; name: string; email: string }
// password is excluded — safe to send to client

Omit<T, K>

Cria um tipo com as propriedades especificadas removidas. É o inverso de Pick.

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

type CreateUserDto = Omit<User, 'id'>; // new users don't have an id yet

Readonly<T>

Torna todas as propriedades somente leitura — impede a reatribuição. É útil para objetos de configuração e dados imutáveis.

const config: Readonly<Config> = {
  host: 'localhost',
  port: 3000,
};
config.port = 8080; // Error: cannot assign to 'port' because it is read-only

Record<K, V>

Cria um tipo de objeto com chaves do tipo K e valores do tipo V. É mais limpo que uma assinatura de índice bruta quando as chaves são uma união conhecida.

type Role = 'admin' | 'editor' | 'viewer';
type Permissions = Record<Role, { canEdit: boolean; canDelete: boolean }>;

const perms: Permissions = {
  admin:  { canEdit: true,  canDelete: true  },
  editor: { canEdit: true,  canDelete: false },
  viewer: { canEdit: false, canDelete: false },
};

ReturnType<T> e Parameters<T>

Extraem o tipo de retorno e os tipos de parâmetros de um tipo de função. São úteis quando você não pode importar um tipo, mas precisa corresponder à assinatura de uma função.

function fetchUser(id: number) {
  return { id, name: 'Alice' };
}

type UserResult = ReturnType<typeof fetchUser>; // { id: number; name: string }
type FetchParams = Parameters<typeof fetchUser>; // [id: number]

Awaited<T>

Desempacota um tipo Promise para obter o tipo do valor resolvido. É útil ao trabalhar com funções assíncronas.

type UserResponse = Awaited<ReturnType<typeof fetchUser>>;
// Resolves both the function return and the Promise

async function load() { return { user: { name: 'Alice' } }; }
type Loaded = Awaited<ReturnType<typeof load>>; // { user: { name: string } }

Extract<T, U> e Exclude<T, U>

Extract<T, U> mantém apenas os tipos de T que podem ser atribuídos a U. Exclude<T, U> os remove.

type A = 'a' | 'b' | 'c' | 'd';
type BC = Extract<A, 'b' | 'c' | 'e'>; // 'b' | 'c'
type AD = Exclude<A, 'b' | 'c'>;       // 'a' | 'd'

// NonNullable removes null and undefined:
type T = string | null | undefined;
type NonNull = NonNullable<T>; // string

Compondo tipos utilitários

Os tipos utilitários podem ser compostos para criar tipos precisos.

type UpdatePayload<T> = Partial<Omit<T, 'id' | 'createdAt'>>;
// Use for PATCH endpoints — omit immutable fields, make rest optional

function patch(id: string, data: UpdatePayload<User>) {
  // data can have any subset of mutable user fields
}

Verificação rápida

Qual tipo utilitário remove chaves especificadas de uma interface?

Recapitulação: tipos utilitários

Partial torna todos os campos opcionais. Required remove os modificadores opcionais. Pick mantém as chaves selecionadas. Omit remove as chaves selecionadas. Readonly impede a mutação. Record associa chaves de uma união a tipos de valores. ReturnType e Parameters extraem tipos de funções. Combine utilitários para criar tipos DTO precisos.

Perguntas Frequentes

A aula “Tipos utilitários: Partial Required Pick Omit” é grátis?

Sim — o texto completo de “Tipos utilitários: Partial Required Pick Omit” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Frontend Academy, atualize para CoddyKit PRO. O curso de Frontend Academy inclui 4 aulas no total.

O que vou aprender em “Tipos utilitários: Partial Required Pick Omit”?

Transforme tipos existentes com tipos utilitários integrados para criar variações sem duplicação. Você pratica Frontend Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Frontend Academy?

Nenhuma experiência prévia é necessária. Frontend Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Tipos utilitários: Partial Required Pick Omit”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Frontend Academy?

Sim. Cada aula de Frontend Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Genéricos: T extends e restrições
  2. Tipos utilitários: Partial Required Pick Omit
  3. Tipos mapeados e tipos condicionais
  4. Restrição de tipos: typeof instanceof uniões discriminadas
← Voltar para Frontend Academy