0Pricing
TypeScript Academy · Aula

Modificadores em tipos mapeados: readonly e ?

Adicione ou remova modificadores com +/- em tipos mapeados

Modificadores em tipos mapeados: readonly e ? é uma aula grátis de TypeScript 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 TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 4 aulas no total.

Boas-vindas

Os tipos mapeados podem adicionar ou remover os modificadores `readonly` e opcional (`?`) das propriedades usando os prefixos `+` e `-`.

Adicionando modificadores com +

O prefixo `+` (implícito por padrão) adiciona um modificador a cada propriedade no tipo mapeado.
type Readonly<T> = { +readonly [K in keyof T]: T[K] }; // + is implicit
type Optional<T> = { [K in keyof T]+?: T[K] };

Removendo readonly com -

Use `-readonly` para remover o modificador readonly das propriedades.
type Mutable<T> = { -readonly [K in keyof T]: T[K] };
const mutableUser: Mutable<Readonly<User>> = { id: 1, name: 'Alice' };
mutableUser.id = 2; // OK now

Removendo ? com -

Use `-?` para remover o modificador opcional, tornando todas as propriedades obrigatórias.
type Required<T> = { [K in keyof T]-?: T[K] };
// Now all optional properties become required

Combinando - e -?

Você pode combinar as duas remoções para criar uma versão mutável e obrigatória de um tipo.
type Concrete<T> = { -readonly [K in keyof T]-?: T[K] };

Partial e Required são opostos

Partial adiciona `?` com +?. Required o remove com -?.
// From TypeScript lib:
type Partial<T> = { [K in keyof T]?: T[K] };   // adds ?
type Required<T> = { [K in keyof T]-?: T[K] };  // removes ?

Preservação de modificadores por padrão

Sem um + ou - explícito, os tipos mapeados preservam os modificadores existentes do tipo de origem.
interface User { readonly id: number; name?: string; }
type Copy<T> = { [K in keyof T]: T[K] };
type C = Copy<User>; // readonly id preserved, name? preserved

Uso prático: tipo Patch

Crie um tipo Patch que torne todas as propriedades opcionais e também remova readonly para permitir atualizações.
type Patch<T> = { -readonly [K in keyof T]?: T[K] };

DeepReadonly

Aplique readonly recursivamente usando um tipo condicional dentro do tipo mapeado.
type DeepReadonly<T> = {
  readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K]
};

DeepPartial

Da mesma forma, aplique ? recursivamente para criar um tipo profundamente opcional.
type DeepPartial<T> = {
  [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K]
};

Tabela de combinações de modificadores

+readonly = adicionar readonly. -readonly = remover readonly. +? = adicionar opcional. -? = remover opcional. As quatro opções podem ser combinadas.

Verificação rápida

O que `{ [K in keyof T]-?: T[K] }` produz?

Recapitulação

Use os prefixos +/- antes de readonly e ? em tipos mapeados para adicionar ou remover explicitamente esses modificadores. -? implementa Required, e -readonly implementa Mutable. Combine ambos para controlar completamente a mutabilidade.

Perguntas Frequentes

A aula “Modificadores em tipos mapeados: readonly e ?” é grátis?

Sim — o texto completo de “Modificadores em tipos mapeados: readonly e ?” é 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 “Modificadores em tipos mapeados: readonly e ?”?

Adicione ou remova modificadores com +/- em tipos mapeados 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 2 de 4.

Quanto tempo leva a aula “Modificadores em tipos mapeados: readonly e ?”?

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. Tipos mapeados: transformando tipos de objetos
  2. Modificadores em tipos mapeados: readonly e ?
  3. Tipos literais de modelo: padrões de texto
  4. Remapeamento de chaves com as em tipos mapeados
← Voltar para TypeScript Academy