0Pricing
TypeScript Academy · Aula

DeepPartial e DeepReadonly

Construa versões recursivas de Partial e Readonly

DeepPartial e DeepReadonly é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 1 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 TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 4 aulas no total.

Por que tipos utilitários profundos

Os tipos integrados Partial e Readonly aplicam-se somente a um nível de profundidade. Para objetos aninhados, você precisa de versões recursivas.

interface Config {
  db: { host: string; port: number };
  app: { name: string };
}
type Shallow = Partial<Config>;
// Shallow.db is still required — only top level is optional

Implementando DeepPartial

Percorra recursivamente as propriedades do objeto, tornando cada uma opcional e aplicando recursivamente DeepPartial se o valor da propriedade for um objeto.

type DeepPartial<T> = T extends object
  ? { [K in keyof T]?: DeepPartial<T[K]> }
  : T;

DeepPartial em ação

Aplique DeepPartial a um tipo de configuração aninhado e veja todos os níveis se tornarem opcionais.

type PartialConfig = DeepPartial<Config>;
// PartialConfig.db?: { host?: string; port?: number }

const c: PartialConfig = { db: { host: "localhost" } };
// No error — all other fields are optional

Implementando DeepReadonly

Torne cada propriedade, em todos os níveis, readonly ao recursar nos tipos de objeto aninhados.

type DeepReadonly<T> = T extends object
  ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
  : T;

DeepReadonly em ação

Uma configuração profundamente congelada não pode ser alterada em nenhum nível.

type ReadonlyConfig = DeepReadonly<Config>;
const cfg: ReadonlyConfig = { db: { host: "localhost", port: 5432 }, app: { name: "my-app" } };
// cfg.db.port = 3000; // Error: readonly

Tratando vetores em tipos profundos

Os vetores precisam de um tratamento especial — mapeie recursivamente os tipos dos elementos em vez de tratar os vetores como objetos simples.

type DeepPartial<T> =
  T extends (infer U)[]
    ? DeepPartial<U>[]
    : T extends object
      ? { [K in keyof T]?: DeepPartial<T[K]> }
      : T;

Tratando tipos primitivos

O caso base da recursão deve retornar os tipos primitivos sem alterações, e não envoltos em um tipo mapeado de objeto.

type DeepReadonly<T> =
  T extends string | number | boolean | null | undefined ? T
  : T extends (infer U)[] ? ReadonlyArray<DeepReadonly<U>>
  : { readonly [K in keyof T]: DeepReadonly<T[K]> };

Combinando DeepPartial e DeepReadonly

Você pode combiná-los para criar um tipo profundamente parcial e somente leitura, destinado à aplicação segura de alterações parciais na configuração.

type SafePatch<T> = DeepReadonly<DeepPartial<T>>;

Considerações de desempenho

Tipos recursivos em objetos muito grandes podem tornar mais lenta a verificação de tipos do TypeScript. Considere limites de profundidade ou avaliação tardia para código crítico em termos de desempenho.

// For very deep schemas, consider using Zod or io-ts
// which provide runtime + compile-time deep typing

Uso no mundo real: alterações parciais de estado do React

DeepPartial é perfeito para funções de alteração parcial de estado que aceitam somente o subconjunto alterado de um objeto de estado grande.

function patch<T>(state: T, changes: DeepPartial<T>): T {
  return { ...state, ...changes } as T;
}

Recapitulação: tipos utilitários profundos

DeepPartial e DeepReadonly são tipos mapeados recursivos que aplicam seus modificadores a cada nível de um objeto aninhado. Trate os vetores separadamente e use casos base para os tipos primitivos.

Verificação rápida

Qual é o caso base recursivo correto para DeepPartial?

O que você aprendeu

Você implementou DeepPartial e DeepReadonly usando tipos mapeados recursivos. Trate os vetores como um caso especial e sempre retorne os tipos primitivos sem alterações no caso base.

Perguntas Frequentes

A aula “DeepPartial e DeepReadonly” é grátis?

Sim — o texto completo de “DeepPartial e DeepReadonly” é 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 TypeScript Academy, atualize para CoddyKit PRO. O curso de TypeScript Academy inclui 4 aulas no total.

O que vou aprender em “DeepPartial e DeepReadonly”?

Construa versões recursivas de Partial e Readonly Você pratica TypeScript 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 TypeScript Academy?

Nenhuma experiência prévia é necessária. TypeScript 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 1 de 4.

Quanto tempo leva a aula “DeepPartial e DeepReadonly”?

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 TypeScript Academy?

Sim. Cada aula de TypeScript 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. DeepPartial e DeepReadonly
  2. Utilitários Flatten e UnwrapPromise
  3. TupleToUnion e UnionToIntersection
  4. Publicando uma biblioteca de utilitários de tipos
← Voltar para TypeScript Academy