Dominando os Tipos Utilitários do TypeScript: Partial, Pick, Omit, Record e mais

Explore como Partial, Pick, Omit, Record, Readonly e outros tipos utilitários do TypeScript podem te ajudar a escrever código mais limpo, reutilizável e seguro. Incluímos exemplos reais para cada caso.

Introdução

Você já se pegou duplicando tipos ou criando variações manuais de interfaces no TypeScript?

Exemplo clássico: você tem um tipo User, mas quer criar um formulário de atualização onde nem todos os campos são obrigatórios. Em vez de sair criando um novo tipo à mão, você pode usar Partial<User> — simples, direto e escalável.

O TypeScript vem com uma poderosa coleção de tipos utilitários prontos, que nos ajudam a:

• Reaproveitar tipos existentes
• Transformar tipos de forma segura
• Escrever menos código e evitar bugs

Neste artigo, vamos explorar os principais tipos utilitários do TypeScript:

• Partial
• Pick
• Omit
• Record
• Readonly
• … e outros bônus!

Partial<T>

O que faz

Torna todas as propriedades de um tipo opcionais.

Exemplo

type User = {
  id: number;
  name: string;
  email: string;
};

type UpdateUser = Partial<User>;

Quando usar

• Em formulários de edição
• Ao construir objetos por etapas
• Em operações de PATCH em APIs REST

Pick<T, K>

O que faz

Seleciona apenas certas propriedades de um tipo.

Exemplo

type User = {
  id: number;
  name: string;
  email: string;
  role: string;
};

type PublicUser = Pick<User, 'name' | 'email'>;

Quando usar

• Para expor apenas os campos necessários em componentes
• Para criar views simplificadas de dados (ex: usuários públicos)

Omit<T, K>

O que faz

Remove uma ou mais propriedades de um tipo.

Exemplo

type User = {
  id: number;
  name: string;
  email: string;
};

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

Quando usar

• Ao criar tipos de entrada (DTOs) onde certos campos não são fornecidos
• Para restringir o acesso a dados sensíveis

Record<K, T>

O que faz

Cria um objeto cujas chaves são de um tipo específico e os valores de outro tipo.

Exemplo

type Roles = 'admin' | 'user' | 'guest';

type RolePermissions = Record<Roles, string[]>;

const permissions: RolePermissions = {
  admin: ['create', 'delete', 'update'],
  user: ['read', 'update'],
  guest: ['read']
};

Quando usar

• Para mapear enumerações
• Para criar objetos dinâmicos e tipados
• Para internacionalização (i18n)

Readonly<T>

O que faz

Torna todas as propriedades de um tipo imutáveis (apenas leitura).

Exemplo

type Config = {
  apiUrl: string;
  retries: number;
};

const config: Readonly<Config> = {
  apiUrl: 'https://api.example.com',
  retries: 3
};

// config.apiUrl = 'x'; // ❌ Erro!

Quando usar

• Para proteger configurações que não devem ser alteradas
• Em contextos onde a imutabilidade traz segurança (ex: reducers)

Extras: Outros utilitários

Dica prática: Combine utilitários

Você pode combinar tipos utilitários para construir variações poderosas.

Exemplo

type User = {
  id: number;
  name: string;
  email: string;
  password: string;
};

type SafeUser = Readonly<Omit<User, 'password'>>;

Boas práticas

• Prefira tipos utilitários antes de criar novos tipos manualmente
• Use Pick e Omit para isolar responsabilidades
• Use Readonly para proteger estados imutáveis
• Documente bem tipos gerados dinamicamente para facilitar a manutenção
• Use Record com enums para garantir consistência

Conclusão

Tipos utilitários são verdadeiras super ferramentas do TypeScript.
Eles aumentam sua produtividade, reduzem repetição e elevam a qualidade do seu código.

Agora que você conhece os principais (Partial, Pick, Omit, Record, Readonly…), que tal refatorar aquele tipo repetido no seu projeto e aplicar uma solução mais elegante?

📢 Curtiu esse guia?
Me siga no LinkedIn para mais conteúdos práticos sobre TypeScript, padrões de desenvolvimento frontend.

Referências

• TypeScript Docs: Utility Types