Divisão de Textos no Nível de Tipos
Divida textos em tuplas dentro do sistema de tipos.
Divisão de Textos no Nível de Tipos é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 4 aulas no total.
Tipos literais de modelo
O sistema de tipos pode fazer correspondência de padrões em tipos literais de cadeia de caracteres usando tipos literais de modelo combinados com infer. Essa é a ferramenta central para analisar cadeias de caracteres no nível de tipos.
Notação: o TypeScript real escreve tipos literais de modelo com cadeias delimitadas por acentos graves que contêm lacunas de cifrão e chaves. Nestes trechos, mostramos esse padrão como Tpl<...>, listando cada parte em ordem; por exemplo, um modelo com acento grave que corresponde ao prefixo 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'>; // falseInferindo um sufixo
Coloque infer dentro do modelo para capturar uma parte da cadeia de caracteres. Aqui capturamos tudo depois de um "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'Dividindo por um delimitador
Para dividir uma cadeia de caracteres na primeira ocorrência de um separador, corresponda ao padrão "cabeça, separador, cauda" e faça a inferência dos dois lados. A primeira correspondência prevalece porque a inferência é gananciosa da esquerda para a cabeça.
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']Divisão recursiva
Para dividir em todas as partes, faça a recursão sobre a cauda. Reúna cada cabeça em uma tupla até que não reste nenhum 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']Percorrendo a recursão
Trace Split<"a.b.c", ".">:
- Cabeça "a", cauda "b.c" -> ["a", ...Split<"b.c">]
- Cabeça "b", cauda "c" -> ["b", ...Split<"c">]
- "c" não contém ".", caso-base -> ["c"]
Resultado: ["a", "b", "c"].
type X = Split<"one,two", ",">; // ["one", "two"]
type Y = Split<"x/y/z", "/">; // ["x", "y", "z"]Lidando com segmentos vazios
A divisão pode produzir cadeias vazias quando os separadores são adjacentes ou estão nas extremidades. O padrão ainda corresponde, inferindo uma Head ou Tail vazia.
type X = Split<"a,,b", ",">; // ["a", "", "b"]
type Y = Split<",a", ",">; // ["", "a"]Reunindo novamente
O inverso de dividir é reunir: percorra uma tupla de cadeias de caracteres e concatene-as com um separador usando um literal de modelo. Essa operação combina naturalmente com a divisão.
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'Removendo espaços em branco
Os utilitários de cadeia de caracteres podem ser compostos. Um tipo Trim remove os espaços iniciais e finais eliminando repetidamente um espaço por meio da inferência de modelo.
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'Substituindo substrings
A substituição funciona dividindo ao redor do alvo e reunindo novamente com a substituição, tudo por meio de inferência de modelo e recursão.
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 que dividir é importante
A divisão é a base da análise estruturada. As rotas são divididas em "/", as cadeias de query em "&" e as linhas CSV em ",". Com Split, você transforma um tipo de cadeia de caracteres plano em uma tupla que pode ser processada elemento por elemento.
type Segments = Split<"users/42/posts", "/">; // ["users", "42", "posts"]Cuidado com a profundidade
A recursão de cadeias de caracteres no nível de tipos é limitada pelo limite de profundidade do compilador. Cadeias muito longas ou muitos separadores podem ultrapassá-lo. Para entradas comuns, como caminhos e formatos pequenos, ela funciona sem problemas.
type Ok = Split<"a/b/c/d/e", "/">; // fine for small stringsVerificação rápida
Teste sua compreensão sobre a divisão de cadeias de caracteres no nível de tipos.
Recapitulação
Você dividiu cadeias de caracteres inteiramente em tipos.
- Tipos literais de modelo mais
inferfazem a correspondência e capturam partes de cadeias de caracteres. SplitOncedivide na primeira ocorrência do separador; a recursão produz umSplitcompleto.- Join, Trim e ReplaceAll são compostos a partir das mesmas ferramentas.
A seguir: extração de dados estruturados de tipos de cadeia de caracteres.
Perguntas Frequentes
A aula “Divisão de Textos no Nível de Tipos” é grátis?
Sim — o texto completo de “Divisão de Textos no Nível de Tipos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de TypeScript Academy, atualize para CoddyKit PRO. O curso de TypeScript Academy inclui 4 aulas no total.
O que vou aprender em “Divisão de Textos no Nível de Tipos”?
Divida textos em tuplas dentro do sistema de tipos. Você pratica TypeScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar TypeScript Academy?
Nenhuma experiência prévia é necessária. TypeScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “Divisão de Textos no Nível de Tipos”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de TypeScript Academy?
Sim. Cada aula de TypeScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Conceitos de Combinadores de Analisadores
- Divisão de Textos no Nível de Tipos
- Analisando com Literais de Modelo
- Um Mini Analisador de Rotas no Nível de Tipos