Conceptos básicos del patrón Builder
Construya objetos complejos paso a paso.
Conceptos básicos del patrón Builder es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de TypeScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de TypeScript Academy incluye 4 lecciones en total.
¿Por qué usar un builder?
Algunos objetos necesitan muchos campos, y construirlos con un constructor enorme lleno de argumentos posicionales puede provocar errores. El patrón Builder construye un objeto complejo paso a paso, mediante una llamada con nombre cada vez.
El objeto que queremos
Imagine una solicitud HTTP con una url, un método, headers y un body. Pasar todos estos elementos a un único constructor dificulta la lectura. Un builder permite establecer cada parte mediante un método con un nombre claro.
interface HttpRequest {
url: string;
method: string;
headers: Record<string, string>;
body?: string;
}Una clase Builder básica
El builder mantiene internamente un estado parcial y expone métodos setter. Cada setter modifica el estado interno y se encarga de un campo.
class RequestBuilder {
private url = "";
private method = "GET";
private headers: Record<string, string> = {};
private body?: string;
}El encadenamiento de métodos devuelve this
El truco que hace que los builders se lean de forma fluida consiste en devolver this desde cada setter. Como cada método devuelve el mismo builder, puede encadenar las llamadas.
class RequestBuilder {
private url = "";
setUrl(u: string): this {
this.url = u;
return this;
}
}Añadir más pasos
Cada paso de configuración sigue el mismo patrón: almacenar el valor y devolver this. Observe que el tipo de retorno this mantiene el tipo concreto del builder durante todo el encadenamiento.
setMethod(m: string): this {
this.method = m;
return this;
}
addHeader(k: string, v: string): this {
this.headers[k] = v;
return this;
}El método build()
Por último, el método build() reúne el estado acumulado en el objeto terminado. Es el único método que no devuelve el builder.
build(): HttpRequest {
return {
url: this.url,
method: this.method,
headers: this.headers,
body: this.body,
};
}Usar el builder
Ahora la construcción se lee como una frase. Cada paso tiene un nombre, el orden es flexible y nunca tendrá que gestionar argumentos posicionales.
const req = new RequestBuilder()
.setUrl("https://api.test")
.setMethod("POST")
.addHeader("Accept", "application/json")
.build();
console.log(req.method);Un ejemplo completo ejecutable
Aquí tiene una versión independiente que puede ejecutar. El builder acumula el estado y build() produce el objeto final con apariencia inmutable.
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);Los valores predeterminados vienen incluidos
Como el builder inicializa los campos con valores predeterminados razonables, quienes llaman solo tienen que sobrescribir lo que necesiten. Los pasos que no se establezcan conservan sus valores predeterminados.
const getReq = new B().setUrl("/health").build();
console.log(getReq.method); // GET (default)Legibilidad frente a constructores
Compare new Req("/x", "POST", {}, undefined) con el builder encadenado. La versión con builder documenta la intención en cada paso y evita los marcadores de posición undefined cuyo significado no está claro.
Cuándo recurrir a él
Use un builder cuando un objeto tenga muchas partes opcionales, cuando su construcción se realice por pasos o cuando quiera una API legible y autodocumentada. Para dos o tres campos, un literal de objeto sencillo es más fácil.
Comprobación rápida
Comprobación rápida de esta lección.
Resumen
Un builder construye objetos complejos paso a paso. Los setters almacenan un campo cada uno y devuelven this para permitir el encadenamiento, mientras que build() ensambla el objeto final. Los builders son especialmente útiles cuando los objetos tienen muchas partes opcionales.
Preguntas frecuentes
¿La lección «Conceptos básicos del patrón Builder» es gratis?
Sí — el texto completo de «Conceptos básicos del patrón Builder» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de TypeScript Academy, actualiza a CoddyKit PRO. El curso de TypeScript Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Conceptos básicos del patrón Builder»?
Construya objetos complejos paso a paso. Practicas TypeScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar TypeScript Academy?
No se requiere experiencia previa. TypeScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «Conceptos básicos del patrón Builder»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de TypeScript Academy?
Sí. Cada lección de TypeScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Conceptos básicos del patrón Builder
- Interfaces fluidas con tipos
- Imposición de pasos obligatorios
- Builders inmutables