TypeScript Academy · Lección

Imposición de pasos obligatorios

Impida ejecutar build() hasta establecer todos los campos obligatorios.

Imposición de pasos obligatorios es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 3 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.

Impedir build() prematuramente

Ahora utilizamos el estado acumulado para impedir la llamada a build() hasta que se hayan configurado los campos obligatorios. Es el sistema de tipos, no una comprobación en tiempo de ejecución, el que bloquea una construcción incompleta.

Definición de la forma final

Comience declarando el objeto completo y especificando qué claves son obligatorias. El builder solo permitirá build() cuando el estado las contenga todas.

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

Firma condicional de build

Hacemos que build esté disponible únicamente cuando el estado acumulado S extienda las claves obligatorias. Un tipo condicional devuelve el método real o uno inutilizable.

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

Uso del parámetro this

El parámetro this: Builder<Required> restringe qué instancias de builder pueden llamar a build. Si S no satisface Required, la llamada produce un error de tipos.

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

Conexión de los setters con el estado

Cada setter amplía S como antes. Después de ejecutar ambos setters obligatorios, S finalmente extiende Required y build se puede llamar.

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; }
}

La ruta correcta se compila

Cuando están presentes ambos pasos obligatorios, la cadena pasa la comprobación de tipos y se ejecuta. El compilador confirma que S incluye todas las claves obligatorias.

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

La ruta incorrecta falla

Si omite un paso obligatorio, build() deja de pasar la comprobación de tipos, porque el S del builder no extiende Required. El error se detecta en tiempo de compilación.

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

Por qué es mejor que las comprobaciones en tiempo de ejecución

Un if (!this.url) throw en tiempo de ejecución solo falla cuando se ejecuta el código. El enfoque del parámetro this falla durante la comprobación de tipos, por lo que las construcciones incompletas nunca llegan a producción.

Los campos opcionales siguen siendo opcionales

Los pasos opcionales, como timeout, nunca forman parte de Required, por lo que no condicionan build(). Puede incluirlos u omitirlos libremente.

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

Escalado a muchos requisitos

Añada más claves obligatorias a la forma Required y al parámetro this, y el compilador las impondrá todas. El patrón se adapta a cualquier número de pasos obligatorios.

Limitaciones

La garantía depende de transmitir S correctamente a través de cada setter y de utilizar el tipado del parámetro this. Las aserciones deben limitarse a los setters para que quienes llaman mantengan la seguridad completa de tipos.

Comprobación rápida

Comprobación rápida de esta lección.

Resumen

Para imponer los pasos obligatorios, tipifique build con un parámetro this: Builder<Required>. El método solo pasa la comprobación de tipos cuando el estado acumulado S incluye todas las claves obligatorias, convirtiendo una construcción incompleta en un error de compilación.

Preguntas frecuentes

¿La lección «Imposición de pasos obligatorios» es gratis?

Sí — el texto completo de «Imposición de pasos obligatorios» 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 «Imposición de pasos obligatorios»?

Impida ejecutar build() hasta establecer todos los campos obligatorios. 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 3 de 4.

¿Cuánto tiempo toma la lección «Imposición de pasos obligatorios»?

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

← Volver a TypeScript Academy