PricingLoginStart free
TypeScript Academy · Aula

Partial e Required: alternando a opcionalidade

Torne todas as propriedades opcionais ou obrigatórias de uma só vez

Aula 1 de 413 etapas

Partial e Required: alternando a opcionalidade é 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.

Boas-vindas

Partial torna todas as propriedades opcionais. Required torna todas as propriedades obrigatórias. Esses são os tipos utilitários mais usados para a manipulação flexível de dados.

Partial<T>

Partial torna opcional cada propriedade de T. É útil em operações de atualização e aplicação de alterações quando você não tem todos os campos.
interface User { id: number; name: string; email: string; }
type PartialUser = Partial<User>;
// { id?: number; name?: string; email?: string; }

Partial em funções de atualização

Use Partial ao implementar funções de atualização ou mesclagem que aceitam apenas os campos alterados.
function updateUser(id: number, changes: Partial<User>): User {
  const existing = findUser(id)!;
  return { ...existing, ...changes };
}

Required<T>

Required remove todos os modificadores de opcionalidade, tornando obrigatória cada propriedade.
type RequiredUser = Required<User>;
// All properties are now required — including those that were optional

Required para validação de configurações

Use Required depois de mesclar os valores padrão para garantir que todos os valores da configuração estejam presentes.
interface Config { host?: string; port?: number; }
const defaults: Required<Config> = { host: 'localhost', port: 3000 };
function createConfig(opts: Config): Required<Config> {
  return { ...defaults, ...opts };
}

Como Partial é implementado

Partial usa um tipo mapeado com o modificador +?.
type Partial<T> = { [K in keyof T]?: T[K] };
// Equivalent to: { [K in keyof T]+?: T[K] }

Como Required é implementado

Required usa um tipo mapeado com o modificador -?.
type Required<T> = { [K in keyof T]-?: T[K] };

Partial profundo

O Partial integrado é superficial. Para objetos aninhados, você precisa de um DeepPartial recursivo.
type DeepPartial<T> = {
  [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K]
};

Combinando Partial e Required

Exija alguns campos enquanto mantém outros opcionais usando uma interseção.
// id required, everything else optional
type UpsertUser = Required<Pick<User, 'id'>> & Partial<Omit<User, 'id'>>;

Partial versus propriedades opcionais em uma interface

Declarar todas as propriedades de uma interface como opcionais equivale a aplicar Partial, mas apenas a esse tipo específico. Partial pode ser reutilizado com qualquer tipo.

Inferência de tipos com Partial

O TypeScript restringe corretamente as propriedades de Partial — acessá-las pode retornar T[K] | undefined.
function show(u: Partial<User>) {
  if (u.name !== undefined) {
    console.log(u.name.toUpperCase()); // safe
  }
}

Verificação rápida

Qual tipo utilitário torna obrigatórias ALL as propriedades de uma interface, incluindo as que antes eram opcionais?
Responda na aula interativa

Recapitulação

Partial torna todas as propriedades opcionais (útil para alterações e atualizações). Required torna todas as propriedades obrigatórias (útil para validação após a mesclagem). Ambos são superficiais — use versões recursivas para tipos aninhados.
Grátis para começar

Aprenda TypeScript com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
101
Aulas
352
Começar a aprender grátisVer o curso completo

Perguntas Frequentes

A aula “Partial e Required: alternando a opcionalidade” é grátis?

Sim — o texto completo de “Partial e Required: alternando a opcionalidade” é 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 “Partial e Required: alternando a opcionalidade”?

Torne todas as propriedades opcionais ou obrigatórias de uma só vez 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 “Partial e Required: alternando a opcionalidade”?

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. Partial e Required: alternando a opcionalidade
  2. Pick e Omit: selecionando propriedades
  3. Record: mapeando chaves para tipos de valores
  4. Readonly, Exclude, Extract, NonNullable
← Voltar para TypeScript Academy