TypeScript Academy · Aula

Fundamentos do Padrão Builder

Construa objetos complexos passo a passo.

Fundamentos do Padrão Builder é 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 usar um construtor?

Alguns objetos precisam de muitos campos, e construí-los com um construtor enorme, cheio de argumentos posicionais, é propenso a erros. O padrão de construção cria um objeto complexo passo a passo, uma chamada nomeada por vez.

O objeto que queremos

Imagine uma solicitação HTTP com um url, método, headers e body. Passar tudo isso para um único construtor é difícil de ler. Um construtor permite definir cada parte com um método claramente nomeado.

interface HttpRequest {
  url: string;
  method: string;
  headers: Record<string, string>;
  body?: string;
}

Uma classe construtora básica

O construtor mantém um estado parcial internamente e expõe métodos de configuração. Cada método de configuração altera o estado interno e é responsável por um campo.

class RequestBuilder {
  private url = "";
  private method = "GET";
  private headers: Record<string, string> = {};
  private body?: string;
}

O encadeamento de métodos retorna this

O segredo que torna a leitura dos construtores fluida é retornar this de cada método de configuração. Como cada método retorna o mesmo construtor, você pode encadear calls.

class RequestBuilder {
  private url = "";
  setUrl(u: string): this {
    this.url = u;
    return this;
  }
}

Adicionando mais etapas

Cada etapa de configuração segue o mesmo padrão: armazene o valor e depois retorne this. Observe que o tipo de retorno this mantém o tipo concreto do construtor durante todo o encadeamento.

  setMethod(m: string): this {
    this.method = m;
    return this;
  }
  addHeader(k: string, v: string): this {
    this.headers[k] = v;
    return this;
  }

O método build()

Por fim, um método build() reúne o estado acumulado no objeto finalizado. Esse é o único método que não retorna o construtor.

  build(): HttpRequest {
    return {
      url: this.url,
      method: this.method,
      headers: this.headers,
      body: this.body,
    };
  }

Usando o construtor

Agora a construção parece uma frase. Cada etapa tem um nome, a ordem é flexível e você nunca precisa lidar com argumentos posicionais.

const req = new RequestBuilder()
  .setUrl("https://api.test")
  .setMethod("POST")
  .addHeader("Accept", "application/json")
  .build();
console.log(req.method);

Um exemplo completo executável

Aqui está uma versão independente que você pode executar. O construtor acumula o estado e build() produz o objeto final, com aparência de imutável.

interface Req { url: string; method: string }
class B {
  private url = ""; private method = "GET";
  setUrl(u: string): this { this.url = u; return this; }
  setMethod(m: string): this { this.method = m; return this; }
  build(): Req { return { url: this.url, method: this.method }; }
}
const r = new B().setUrl("/users").setMethod("POST").build();
console.log(r.url, r.method);

Os valores padrão vêm de graça

Como o construtor inicializa os campos com valores padrão sensatos, os chamadores só substituem o que precisam. As etapas não definidas simplesmente mantêm seus valores padrão.

const getReq = new B().setUrl("/health").build();
console.log(getReq.method); // GET (default)

Legibilidade versus construtores

Compare new Req("/x", "POST", {}, undefined) com o construtor encadeado. A versão com construtor documenta a intenção em cada etapa e evita marcadores undefined cujo significado não é claro.

Quando recorrer a ele

Use um construtor quando um objeto tiver muitas partes opcionais, quando a construção ocorrer em etapas ou quando você quiser uma API legível e autodescritiva. Para dois ou três campos, um literal de objeto simples é mais prático.

Verificação rápida

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

Recapitulação

Um construtor cria objetos complexos passo a passo. Cada método definidor armazena um campo e devolve this para permitir o encadeamento, enquanto build() reúne o objeto final. Os construtores são especialmente úteis quando os objetos têm muitas partes opcionais.

Perguntas Frequentes

A aula “Fundamentos do Padrão Builder” é grátis?

Sim — o texto completo de “Fundamentos do Padrão Builder” é 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 “Fundamentos do Padrão Builder”?

Construa objetos complexos passo a passo. 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 “Fundamentos do Padrão Builder”?

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