División de cadenas a nivel de tipos
Divida cadenas en tuplas dentro del sistema de tipos.
División de cadenas a nivel de tipos es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 2 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.
Tipos de plantilla literal
El sistema de tipos puede buscar patrones en tipos literales de cadena mediante tipos de plantilla literal combinados con infer. Esta es la herramienta fundamental para analizar cadenas a nivel de tipos.
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 StartsWithA<S> = S extends Tpl<'a', string> ? true : false;
// Tpl<'a', string> is a backtick template literal type: 'a' then anything
type X = StartsWithA<'abc'>; // true
type Y = StartsWithA<'bcd'>; // falseInferencia de un sufijo
Coloque infer dentro de la plantilla para capturar una parte de la cadena. Aquí capturamos todo lo que aparece después de un "a" inicial.
type AfterA<S> = S extends Tpl<'a', infer Rest> ? Rest : never;
// Tpl<'a', Rest> captures everything after a leading 'a'
type X = AfterA<'abc'>; // 'bc'División mediante un delimitador
Para dividir una cadena en la primera aparición de un separador, haga coincidir el patrón «cabeza, separador, cola» e infiera ambos lados. La primera coincidencia es la que prevalece porque la inferencia de la cabeza es codiciosa desde la izquierda.
type SplitOnce<S, Sep extends string> =
S extends Tpl<infer Head, Sep, infer Tail>
? [Head, Tail]
: [S];
// Tpl<Head, Sep, Tail> matches up to the first separator
type X = SplitOnce<'a-b-c', '-'>; // ['a', 'b-c']División recursiva
Para dividir en todas las partes, aplique recursión sobre la cola. Recopile cada cabeza en una tupla hasta que no quede ningún separador.
type Split<S extends string, Sep extends string> =
S extends Tpl<infer Head, Sep, infer Tail>
? [Head, ...Split<Tail, Sep>]
: [S];
// recurse on Tail until no separator remains
type X = Split<'a.b.c', '.'>; // ['a', 'b', 'c']Recorrido de la recursión
Trace Split<"a.b.c", ".">:
- Head "a", Tail "b.c" -> ["a", ...Split<"b.c">]
- Head "b", Tail "c" -> ["b", ...Split<"c">]
- "c" no contiene ".", caso base -> ["c"]
Resultado: ["a", "b", "c"].
type X = Split<"one,two", ",">; // ["one", "two"]
type Y = Split<"x/y/z", "/">; // ["x", "y", "z"]Gestión de segmentos vacíos
La división puede producir cadenas vacías cuando los separadores están juntos o aparecen en los extremos. El patrón sigue coincidiendo e infiere un Head o Tail vacío.
type X = Split<"a,,b", ",">; // ["a", "", "b"]
type Y = Split<",a", ",">; // ["", "a"]Volver a unir
La operación inversa de dividir es unir: recorra una tupla de cadenas y concaténelas con un separador mediante una plantilla literal. Esto combina de forma natural con la división.
type Join<T extends string[], Sep extends string> =
T extends [infer H extends string, ...infer R extends string[]]
? R extends [] ? H : Tpl<H, Sep, Join<R, Sep>>
: '';
// Tpl<...> denotes a template literal type concatenation
type X = Join<['a', 'b', 'c'], '-'>; // 'a-b-c'Recorte de espacios en blanco
Las utilidades de cadenas se pueden componer. Un tipo Trim elimina los espacios iniciales y finales quitando repetidamente un espacio mediante inferencia de plantillas.
type TrimLeft<S extends string> =
S extends Tpl<' ', infer R> ? TrimLeft<R> : S;
type TrimRight<S extends string> =
S extends Tpl<infer R, ' '> ? TrimRight<R> : S;
type Trim<S extends string> = TrimRight<TrimLeft<S>>;
// Tpl<' ', R> strips a leading space; Tpl<R, ' '> strips a trailing one
type X = Trim<' hi '>; // 'hi'Reemplazo de subcadenas
El reemplazo funciona dividiendo alrededor del objetivo y volviendo a unir con el reemplazo, todo mediante inferencia de plantillas y recursión.
type ReplaceAll<S extends string, From extends string, To extends string> =
S extends Tpl<infer A, From, infer B>
? Tpl<A, To, ReplaceAll<B, From, To>>
: S;
// split around From, then rejoin with To via template literal types
type X = ReplaceAll<'a-b-c', '-', '_'>; // 'a_b_c'Por qué es importante dividir
La división es la base del análisis estructurado. Las rutas se dividen por "/", las cadenas de consulta por "&" y las filas CSV por ",". Con Split convierte un tipo de cadena plana en una tupla que puede procesar elemento por elemento.
type Segments = Split<"users/42/posts", "/">; // ["users", "42", "posts"]Precaución con la profundidad
La recursión de cadenas a nivel de tipos está limitada por el límite de profundidad del compilador. Las cadenas muy largas o con muchos separadores pueden superarlo. Para entradas habituales (rutas y formatos pequeños), funciona sin problemas.
type Ok = Split<"a/b/c/d/e", "/">; // fine for small stringsComprobación rápida
Compruebe cuánto entiende la división de cadenas a nivel de tipos.
Resumen
Ha dividido cadenas completamente dentro de los tipos.
- Los tipos de plantilla literal junto con
inferbuscan coincidencias y capturan partes de cadenas. SplitOncedivide en el primer separador; la recursión produce unSplitcompleto.- Join, Trim y ReplaceAll se componen a partir de las mismas herramientas.
A continuación: extraer datos estructurados de tipos de cadena.
Preguntas frecuentes
¿La lección «División de cadenas a nivel de tipos» es gratis?
Sí — el texto completo de «División de cadenas a nivel de tipos» 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 «División de cadenas a nivel de tipos»?
Divida cadenas en tuplas dentro del sistema de tipos. 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 2 de 4.
¿Cuánto tiempo toma la lección «División de cadenas a nivel de tipos»?
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