Padrões práticos com uniões e interseções

Boas-vindas

Padrão de carga útil opcional

type Event =
  | { type: 'click'; x: number; y: number }
  | { type: 'keypress'; key: string }
  | { type: 'blur' };

Construtor/composição com interseção

type Serializable = { serialize(): string };
type Validatable = { validate(): boolean };
type Model = Serializable & Validatable & { id: number };

União para normalização de entradas

function toArray<T>(val: T | T[]): T[] {
  return Array.isArray(val) ? val : [val];
}

Tipos com marca usando interseção

type UserId = number & { __brand: 'UserId' };
type PostId = number & { __brand: 'PostId' };
// Prevents accidentally mixing IDs

Padrão WithOptional

type RequiredFields = { id: number; email: string };
type OptionalFields = Partial<{ name: string; bio: string }>;
type UserUpdate = RequiredFields & OptionalFields;

Propriedades de componentes polimórficos

type ButtonProps =
  | { variant: 'primary'; onClick: () => void }
  | { variant: 'link'; href: string };

Extensão de tipos de terceiros

import type { Request } from 'express';
type AuthRequest = Request & { user: User };

Combinação de união e interseção

type Admin = { role: 'admin' };
type User = { role: 'user' };
type LoggedIn = { sessionId: string };
type AuthUser = (Admin | User) & LoggedIn;

Proteções de tipo para membros de uniões

function isAdmin(u: AuthUser): u is Admin & LoggedIn {
  return u.role === 'admin';
}

Comportamento distributivo em interseções

type Base = { id: number };
type AB = Base & (string | number);
// equivalent to: (Base & string) | (Base & number)

Verificação rápida

Recapitulação