Análisis con literales de plantilla
Extraiga datos estructurados de cadenas mediante infer.
Análisis con literales de plantilla 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.
De la división a la estructura
La división proporciona una tupla de partes. El análisis va más allá: extrae datos con nombre y estructurados de un tipo de cadena. Usamos patrones de plantilla literal con varias variables infer para extraer las partes que nos interesan.
Notación: TypeScript real escribe los tipos de plantilla literal con cadenas delimitadas por comillas invertidas que contienen marcadores de dólar y llaves. En estos fragmentos mostramos ese patrón como Tpl<...>, enumerando cada parte en orden; por ejemplo, una plantilla con comillas invertidas que coincide con el prefijo literal seguido de Rest aparece como Tpl<'prefix', infer Rest>.
type KeyValue<S> =
S extends Tpl<infer K, '=', infer V> ? { key: K; value: V } : never;
// Tpl<K, '=', V> matches K, an equals sign, then V
type X = KeyValue<'name=alice'>; // { key: 'name'; value: 'alice' }Múltiples puntos de inferencia
Un solo patrón puede capturar varios campos a la vez. Para analizar "GET /users", infiera el método y la ruta en un único condicional.
type Request<S> =
S extends Tpl<infer Method, ' ', infer Path>
? { method: Method; path: Path }
: never;
// Tpl<Method, ' ', Path> matches the method, a space, then the path
type X = Request<'GET /users'>; // { method: 'GET'; path: '/users' }Restricción de las partes inferidas
Puede restringir una variable inferida con extends en línea, de modo que solo coincida con determinadas formas. Aquí el método debe ser un verbo conocido.
type Method = 'GET' | 'POST';
type Parse<S> =
S extends Tpl<(infer M extends Method), ' ', infer P>
? { method: M; path: P }
: never;
// the inferred M is constrained to Method inside the template pattern
type X = Parse<'POST /x'>; // { method: 'POST'; path: '/x' }Análisis de pares clave-valor
Combine división y análisis: divida una cadena de consulta en pares y, después, analice cada par para obtener una clave y un valor. El resultado es una tupla de entradas estructuradas.
type Pair<S> =
S extends Tpl<infer K, '=', infer V> ? [K, V] : [S, ''];
// Tpl<K, '=', V> splits a 'key=value' string literal type
type X = Pair<'page=2'>; // ['page', '2']Construcción de un objeto a partir de pares
Pliegue una tupla de pares clave-valor en un tipo de objeto mediante un acumulador de tipo mapped/intersection. Cada par añade una propiedad.
type FromPairs<T extends [string, string][]> =
T extends [[infer K extends string, infer V], ...infer R extends [string, string][]]
? { [P in K]: V } & FromPairs<R>
: {};
type X = FromPairs<[["a", "1"], ["b", "2"]]>; // { a: "1" } & { b: "2" }Análisis de una cadena de consulta
Reúna todos los pasos: divida por "&", analice cada parte por "=" y, después, construya el objeto. Ahora el compilador conoce las claves exactas de un literal de cadena de consulta.
type ParseQuery<S extends string> =
FromPairs<{ [I in keyof SplitAmp<S>]: Pair<SplitAmp<S>[I] & string> }>;
// where SplitAmp splits on "&" (from previous lesson)Extracción de números
Las partes inferidas siempre son tipos literales de cadena. Para tratar una parte como un número, compruebe si coincide con un patrón numérico o pásela por una restricción que solo admita dígitos. El valor sigue siendo un tipo literal.
type IsNumeric<S extends string> =
S extends Tpl<number> ? true : false;
// Tpl<number> is a template literal type that matches any numeric string
type X = IsNumeric<'42'>; // true
type Y = IsNumeric<'4a'>; // falseSegmentos opcionales
Use una unión de patrones para gestionar partes opcionales. Pruebe primero el patrón más completo y recurra al más sencillo si no coincide.
type ParsePath<S> =
S extends Tpl<infer Base, '?', infer Query>
? { base: Base; query: Query }
: { base: S; query: '' };
// Tpl<Base, '?', Query> matches an optional query after a question mark
type X = ParsePath<'/x?a=1'>; // { base: '/x'; query: 'a=1' }Espacios en blanco y casos límite
Las cadenas reales pueden contener espacios sobrantes. Componga el parser con Trim de la lección anterior para que los espacios iniciales y finales no corrompan los campos extraídos.
type CleanKey<S extends string> = Trim<S>;
// Apply Trim to each inferred segment before using itPor qué esto es potente
El análisis mediante plantillas literales permite que el compilador comprenda formatos: fechas, rutas, claves de entorno y fragmentos SQL. Las cadenas mal escritas se convierten en errores de compilación y los tipos posteriores pueden depender de la estructura analizada. El literal de cadena se convierte en un valor tipado.
type Event<S> =
S extends Tpl<infer Domain, ':', infer Action>
? { domain: Domain; action: Action }
: never;
// Tpl<Domain, ':', Action> matches 'domain:action'
type X = Event<'user:created'>; // { domain: 'user'; action: 'created' }Composición de parsers
Al igual que los combinadores a nivel de valores, los parsers a nivel de tipos se pueden componer. Divida, analice cada parte y, después, ensamble un objeto. Cada paso es un tipo condicional pequeño y, juntos, forman un parser completo y tipado.
// Split -> Pair -> FromPairs is a parser pipeline at the type levelComprobación rápida
Compruebe cuánto entiende el análisis mediante plantillas literales.
Resumen
Ha extraído datos estructurados de tipos de cadena.
- Varios puntos
infercapturan campos con nombre en un único patrón. - Las partes inferidas se pueden restringir con
extendsen línea. - Split, Pair y FromPairs se componen para formar un parser de consultas.
- Trim y las comprobaciones numéricas gestionan los casos límite.
A continuación: un parser completo de rutas pequeñas.
Preguntas frecuentes
¿La lección «Análisis con literales de plantilla» es gratis?
Sí — el texto completo de «Análisis con literales de plantilla» 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 «Análisis con literales de plantilla»?
Extraiga datos estructurados de cadenas mediante infer. 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 «Análisis con literales de plantilla»?
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 de combinadores de analizadores
- División de cadenas a nivel de tipos
- Análisis con literales de plantilla
- Un mini analizador de rutas a nivel de tipos