0Pricing
TypeScript Academy · Lección

Validación de entradas en tiempo de compilación

Rechace expresiones DSL con formato incorrecto antes del tiempo de ejecución.

Validación de entradas en tiempo de compilación 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.

Validación de entradas en tiempo de compilación

Los DSL en el nivel de tipos pueden rechazar expresiones mal formadas antes del tiempo de ejecución. Mediante tipos de literales de plantilla y tipos condicionales, validamos la estructura de una cadena en el nivel de tipos y rechazamos las entradas no válidas.

Ejemplo: un pequeño lenguaje de selección

Imagine que acepta cadenas como "user.name" u "order.items.length". Queremos rechazar "user." o ".name" durante la compilación.

Analizar con literales de plantilla

Los tipos de literales de plantilla dividen una cadena en partes mediante infer, que es la base del análisis durante la compilación. El patrón real está delimitado por comillas invertidas (Head dot Tail con infer); representamos ese patrón de división como DotSplit.

// Real TS: backtick pattern matching Head, ".", Tail.

type Split<S extends string> =
  S extends DotSplit<infer Head, infer Tail>
    ? [Head, ...Split<Tail>]
    : [S];

type P = Split<"a.b.c">; // ["a", "b", "c"]

Validar cada segmento

Un tipo condicional comprueba que ningún segmento esté vacío. Un segmento vacío marca la entrada como no válida. El mismo patrón DotSplit (un literal de plantilla delimitado por comillas invertidas en el código real) dirige la recursión.

type NonEmpty<S extends string> = S extends "" ? false : true;

type Valid<S extends string> =
  S extends DotSplit<infer H, infer T>
    ? H extends "" ? false : Valid<T>
    : NonEmpty<S>;

type V1 = Valid<"a.b">;  // true
type V2 = Valid<"a.">;   // false

Restringir la API según la validez

Utilice el tipo de validez para restringir un parámetro de función: las cadenas válidas conservan su tipo; las no válidas se resuelven en never, por lo que la llamada no se puede compilar.

declare function path<S extends string>(
  p: Valid<S> extends true ? S : never
): void;

path("user.name"); // ok
path("user.");     // Error: argument is never

Rechazar tokens desconocidos

También puede restringir los caracteres permitidos. Haga coincidir únicamente patrones de segmentos conocidos; cualquier otra cosa se convierte en un tipo que rechaza el valor.

type Allowed = "user" | "order" | "name" | "items";
type CheckSeg<S extends string> = S extends Allowed ? true : false;

Validar operadores

Para un DSL de expresiones como "age > 18", haga coincidir el operador con un literal de plantilla y asegúrese de que pertenezca a un conjunto permitido. El patrón de coincidencia (espacio izquierdo O espacio derecho) es un literal de plantilla con backticks en el código real; aquí lo representamos como CondMatch.

type Op = ">" | "<" | "=" | ">=" | "<=";

// Real TS: backtick pattern -> left, " ", infer O, " ", right.
type IsCond<S extends string> =
  S extends CondMatch<infer O>
    ? O extends Op ? true : false
    : false;

type C1 = IsCond<"age > 18">; // true
type C2 = IsCond<"age ! 18">; // false

Combinar comprobaciones

Los validadores reales combinan varias condiciones: segmentos no vacíos, tokens permitidos y estructura equilibrada. Cada una es un tipo condicional; combínelas con tipos auxiliares de estilo lógico.

type And<A, B> = A extends true ? (B extends true ? true : false) : false;

Límites de la recursión

La recursión a nivel de tipos tiene límites de profundidad. Para cadenas muy largas, el compilador puede mostrar el error «la instanciación de tipos es excesivamente profunda». Mantenga acotadas las entradas analizadas o simplifique la gramática.

Mejor que analizar en tiempo de ejecución

Un analizador en tiempo de ejecución solo avisa cuando se evalúa la cadena incorrecta. La validación en tiempo de compilación rechaza el literal en el momento en que lo escribe, con toda la información del editor y sin coste en tiempo de ejecución.

Por qué es importante

Muchos DSL aceptan entradas de tipo cadena (rutas, consultas y formatos). Validar su estructura en el sistema de tipos detecta errores tipográficos y expresiones mal formadas antes de que se ejecute el programa, y convierte una clase de errores de tiempo de ejecución en errores de compilación.

Comprobación rápida

Compruebe su comprensión de la validación de entradas en tiempo de compilación.

Resumen

Validó las entradas de un DSL antes del tiempo de ejecución mediante el análisis de literales de cadena con tipos de literales de plantilla y infer, y después comprobó los segmentos y operadores con tipos condicionales. Restringir un parámetro de función según el tipo de validez hace que las expresiones mal formadas se resuelvan en never y no se puedan compilar, teniendo en cuenta los límites de recursión.

Preguntas frecuentes

¿La lección «Validación de entradas en tiempo de compilación» es gratis?

Sí — el texto completo de «Validación de entradas en tiempo de compilación» 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 «Validación de entradas en tiempo de compilación»?

Rechace expresiones DSL con formato incorrecto antes del tiempo de ejecución. 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 «Validación de entradas en tiempo de compilación»?

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

  1. Qué es un DSL a nivel de tipos
  2. Diseño de un DSL fluido de consultas
  3. Validación de entradas en tiempo de compilación
  4. Mensajes de error en DSL a nivel de tipos
← Volver a TypeScript Academy