TypeScript Academy · Aula

Exigindo Etapas Obrigatórias

Impeça build() até que todos os campos obrigatórios estejam definidos.

Exigindo Etapas Obrigatórias é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 3 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.

Impedindo build() prematuro

Agora usamos o estado acumulado para impedir a chamada de build() até que os campos obrigatórios sejam definidos. O sistema de tipos, e não uma verificação em tempo de execução, bloqueia uma construção incompleta.

Defina a estrutura final

Comece declarando o objeto completo e quais chaves são obrigatórias. O construtor permitirá build() somente quando o estado contiver todas elas.

interface Config {
  url: string;   // required
  method: string; // required
  timeout?: number; // optional
}
type Required = { url: string; method: string };

Assinatura condicional de build

Tornamos build disponível somente quando o estado acumulado S se estende pelas chaves obrigatórias. Um tipo condicional devolve o método real ou um método inutilizável.

class Builder<S> {
  build(this: Builder<Required>): Config {
    return this.d as Config;
  }
  private d: Record<string, unknown> = {};
}

Usando o parâmetro this

O parâmetro this: Builder<Required> restringe quais instâncias do construtor podem chamar build. Se S não satisfizer Required, a chamada gerará um erro de tipo.

// Only a Builder whose S includes url and method
// can legally invoke build().

Vinculando os métodos definidores ao estado

Cada método definidor amplia S como antes. Depois que ambos os métodos definidores obrigatórios forem executados, S finalmente se estende por Required e build pode ser chamado.

class Builder<S> {
  private d: Record<string, unknown> = {};
  url(u: string): Builder<S & { url: string }> { this.d.url = u; return this as any; }
  method(m: string): Builder<S & { method: string }> { this.d.method = m; return this as any; }
  build(this: Builder<{ url: string; method: string }>): Config { return this.d as Config; }
}

O fluxo esperado compila

Quando as duas etapas obrigatórias estão presentes, a cadeia passa pela verificação de tipos e é executada. O compilador confirma que S inclui todas as chaves obrigatórias.

const cfg = new Builder<{}>().url("/x").method("GET").build();
console.log(cfg.url, cfg.method);

O fluxo inválido falha

Se uma etapa obrigatória for omitida, build() deixará de passar pela verificação de tipos, pois o S do construtor não se estende por Required. O erro é detectado em tempo de compilação.

// const bad = new Builder<{}>().url("/x").build();
// Error: 'build' can only be called when method is set too.

Por que isso é melhor que proteções em tempo de execução

Um if (!this.url) throw em tempo de execução só falha quando o código é executado. A abordagem do parâmetro this falha durante a verificação de tipos, portanto construções incompletas nunca são entregues.

Os campos opcionais continuam opcionais

Etapas opcionais, como timeout, nunca fazem parte de Required, portanto não condicionam build(). É possível incluí-las ou ignorá-las livremente.

const ok = new Builder<{}>().method("PUT").url("/y").build();
console.log("order of required steps does not matter");

Expandindo para muitos requisitos

Adicione mais chaves obrigatórias à estrutura Required e ao parâmetro this, e o compilador exigirá todas elas. O padrão se adapta a qualquer quantidade de etapas obrigatórias.

Limitações

A garantia depende de transportar S corretamente em cada método definidor e de usar a tipagem do parâmetro this. As conversões devem ficar restritas aos métodos definidores para que quem chama permaneça totalmente protegido pelo sistema de tipos.

Verificação rápida

Verificação rápida desta lição.

Recapitulação

Para exigir etapas obrigatórias, tipa-se build com um parâmetro this: Builder<Required>. O método só passa pela verificação de tipos quando o estado acumulado S inclui todas as chaves obrigatórias, transformando uma construção incompleta em um erro de compilação.

Perguntas Frequentes

A aula “Exigindo Etapas Obrigatórias” é grátis?

Sim — o texto completo de “Exigindo Etapas Obrigatórias” é 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 “Exigindo Etapas Obrigatórias”?

Impeça build() até que todos os campos obrigatórios estejam definidos. 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 3 de 4.

Quanto tempo leva a aula “Exigindo Etapas Obrigatórias”?

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

← Voltar para TypeScript Academy