Typescript: Combinando Tipos (Combining Types)

Introdução

O TypeScript oferece várias formas de combinar tipos para criar estruturas mais expressivas e flexíveis. A seguir algumas dessas combinações:

• Union Types
• Intersection Types
• Type Aliases
• Keyof Operator

Union Types - |

Um valor pode ser um de vários tipos

type ID = string | number;

function buscarUsuario(id: ID) {
  // id pode ser string ou number
}

Intersection Types - &

Combina múltiplos tipos em um só — o valor precisa satisfazer todos. Use o operador &. Muito útil para mixins e composição de contratos.

type Pessoa   = { nome: string; cpf: string };
type Empresa   = { cnpj: string; razao: string };

// Só existe em contextos fiscais especiais 🇧🇷
type PessoaJuridica = Pessoa & Empresa;

const pj: PessoaJuridica = {
  nome:  "João Silva",
  cpf:   "000.000.000-00",
  cnpj:  "00.000.000/0001-00",
  razao: "Silva ME",
};

// Padrão mixin: adicionar propriedades opcionais
type WithTimestamps<T> = T & {
  createdAt: Date;
  updatedAt: Date;
};

type NotaFiscalAuditada = WithTimestamps<Empresa>;

Type Aliases

Type aliases são simplesmente apelidos para um tipo: você define um nome reutilizável para qualquer estrutura de tipo.

type Nome = string;
type Idade = number;
type Ativo = boolean;

Keyof Operator

O keyof extrai as chaves de um tipo como uma union de strings literais.

type NotaFiscal = {
  numero:    string;
  valor:     number;
  emissao:  Date;
  cancelada: boolean;
};

// keyof extrai as chaves
type CamposNF = keyof NotaFiscal;
// = "numero" | "valor" | "emissao" | "cancelada"

// Uso clássico: getter genérico type-safe
function getCampo<T, K extends keyof T>(
  obj: T,
  key: K
): T[K] {               // tipo inferido automaticamente!
  return obj[key];
}

const nf: NotaFiscal = { numero: "NF-001", valor: 1500, emissao: new Date(), cancelada: false };

getCampo(nf, "valor");     // ✅ retorna number
getCampo(nf, "numero");    // ✅ retorna string
getCampo(nf, "xpto");      // ❌ erro de compilação!

Por que isso é útil?

Sem keyof, você escreveria strings soltas e perderia type safety:

// ❌ Sem keyof — TypeScript não consegue validar
function pegar(obj: any, chave: string) {
  return obj[chave];
}

// ✅ Com keyof — totalmente tipado
function pegar<T>(obj: T, chave: keyof T): T[keyof T] {
  return obj[chave];
}