TypeScript Academy · Aula

Builders Imutáveis

Retorne novas instâncias de builder para uma composição mais segura.

Builders Imutáveis é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 4 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.

Mutação versus imutabilidade

Até aqui, os construtores modificam this e o devolvem. Um construtor imutável, por outro lado, devolve uma instância nova do construtor a cada etapa, sem nunca alterar o original. Isso torna a composição mais segura.

O problema da mutação compartilhada

Se duas partes do código mantiverem o mesmo construtor mutável, uma chamada a um método definidor afetará ambas. Os construtores imutáveis evitam completamente essa surpresa causada por referências compartilhadas.

const base = makeMutableBuilder().url("/x");
// If base is shared, later .method() calls mutate everyone's copy.

Devolvendo uma nova instância

Um método definidor imutável copia o estado atual, adiciona o novo campo e cria um construtor novo. O original permanece intacto.

class IB<S> {
  constructor(private readonly d: Record<string, unknown> = {}) {}
  with<K extends string, V>(k: K, v: V): IB<S & Record<K, V>> {
    return new IB<S & Record<K, V>>({ ...this.d, [k]: v });
  }
}

Compartilhamento estrutural por expansão

A expansão { ...this.d, [k]: v } copia as entradas existentes e substitui uma chave. Os valores inalterados são compartilhados por referência, portanto as cópias permanecem econômicas.

const a = new IB<{}>().with("url", "/x");
const c = a.with("method", "GET");
// a still only has url; c has url and method.

Os originais nunca mudam

Como cada etapa produz um objeto novo, é seguro criar ramificações a partir de um construtor anterior. É possível reutilizar uma base parcialmente construída em vários lugares.

const base = new IB<{}>().with("url", "/api");
const get = base.with("method", "GET");
const post = base.with("method", "POST");
console.log("base untouched; get and post diverge");

Estado interno somente para leitura

Marcar os dados internos como readonly documenta a intenção e impede escritas acidentais diretamente no objeto dentro da classe. A única forma de avançar é criar uma nova instância.

class IB<S> {
  constructor(private readonly d: Readonly<Record<string, unknown>> = {}) {}
}

Construção imutável tipada

O parâmetro de estado continua sendo transportado, portanto podemos condicionar build() exatamente como antes, agora sobre uma base imutável.

interface Out { url: string; method: string }
class IB<S> {
  constructor(private readonly d: Record<string, unknown> = {}) {}
  with<K extends string, V>(k: K, v: V): IB<S & Record<K, V>> {
    return new IB<S & Record<K, V>>({ ...this.d, [k]: v });
  }
  build(this: IB<{ url: string; method: string }>): Out { return this.d as Out; }
}
const out = new IB<{}>().with("url", "/u").with("method", "GET").build();
console.log(out.url);

Composição mais segura

Os construtores imutáveis são compostos como valores: passe um deles adiante, derive novos construtores e nunca se preocupe com uma chamada posterior reescrevendo o estado compartilhado. Esse é o mesmo benefício que os dados imutáveis oferecem em qualquer contexto.

Predefinições reutilizáveis

É possível capturar um ponto de partida comum uma vez e criar várias ramificações a partir dele. Cada ramificação é independente graças aos métodos definidores com cópia na escrita.

const jsonBase = new IB<{}>().with("header", "application/json");
const usersReq = jsonBase.with("url", "/users");
const ordersReq = jsonBase.with("url", "/orders");
console.log("two independent requests from one base");

Considerações sobre o custo

Cada etapa aloca um objeto novo. Para a construção de configurações típica, isso é insignificante, e o compartilhamento estrutural mantém as cópias superficiais. Somente laços extremamente intensivos perceberiam a diferença.

Resumo: mutável versus imutável

Os construtores mutáveis são um pouco mais rápidos e simples; os imutáveis são mais seguros para compartilhar e compreender. Prefira os imutáveis quando os construtores forem passados entre diferentes partes do código ou reutilizados como predefinições.

Verificação rápida

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

Recapitulação

Um construtor imutável devolve uma nova instância a cada etapa usando o compartilhamento estrutural { ...this.d, [k]: v }, sem nunca modificar this. Os originais permanecem intactos, permitindo composição segura e predefinições reutilizáveis, com apenas um pequeno custo de alocação.

Perguntas Frequentes

A aula “Builders Imutáveis” é grátis?

Sim — o texto completo de “Builders Imutáveis” é 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 “Builders Imutáveis”?

Retorne novas instâncias de builder para uma composição mais segura. 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 4 de 4.

Quanto tempo leva a aula “Builders Imutáveis”?

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