Analisando com Literais de Modelo
Extraia dados estruturados de textos usando infer.
Analisando com Literais de Modelo é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 3 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.
Da divisão à estrutura
A divisão fornece uma tupla de partes. A análise vai além: extrai dados nomeados e estruturados de um tipo de cadeia de caracteres. Usamos padrões de modelo literal com várias variáveis infer para extrair as partes que nos interessam.
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 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' }Vários pontos de inferência
Um único padrão pode capturar vários campos de uma vez. Para analisar "GET /users", faça a inferência do método e do caminho em um ú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' }Restringindo partes inferidas
Você pode restringir uma variável inferida com extends diretamente na expressão, de modo que ela corresponda apenas a determinadas formas. Aqui, o método precisa ser um verbo conhecido.
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' }Analisando pares chave-valor
Combine divisão e análise: divida uma cadeia de query em pares e, em seguida, analise cada par em uma chave e um valor. O resultado é uma tupla de entradas estruturadas.
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']Construindo um objeto a partir de pares
Acumule uma tupla de pares chave-valor em um tipo de objeto usando um acumulador de mapeamento/interseção. Cada par adiciona uma propriedade.
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" }Analisando uma cadeia de query
Junte tudo: divida em "&", analise cada parte em "=" e, em seguida, construa o objeto. Agora o compilador conhece as chaves exatas de uma cadeia de query literal.
type ParseQuery<S extends string> =
FromPairs<{ [I in keyof SplitAmp<S>]: Pair<SplitAmp<S>[I] & string> }>;
// where SplitAmp splits on "&" (from previous lesson)Extraindo números
As partes inferidas são sempre tipos literais de cadeia de caracteres. Para tratar uma parte como um número, verifique se ela corresponde a um padrão numérico ou mapeie-a por meio de uma restrição que aceite somente digits. O valor continua sendo um 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 opcionais
Use uma união de padrões para lidar com partes opcionais. Tente primeiro o padrão mais completo; recorra ao mais simples se ele não corresponder.
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' }Espaços em branco e casos extremos
Cadeias de caracteres reais contêm espaços indesejados. Componha seu analisador com o tipo Trim da lição anterior para que os espaços em branco iniciais e finais não corrompam os campos extraídos.
type CleanKey<S extends string> = Trim<S>;
// Apply Trim to each inferred segment before using itPor que isso é poderoso
A análise de literais de modelo permite que o compilador compreenda formatos: datas, rotas, chaves de ambiente e fragmentos de SQL. Cadeias de caracteres com erros de digitação tornam-se erros de compilação, e os tipos subsequentes podem depender da estrutura analisada. A cadeia de caracteres literal torna-se um 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' }Compondo analisadores
Assim como os combinadores no nível de valores, os analisadores no nível de tipos podem ser compostos. Divida, analise cada parte e, em seguida, monte um objeto. Cada etapa é um pequeno tipo condicional e, juntas, elas formam um analisador completo e tipado.
// Split -> Pair -> FromPairs is a parser pipeline at the type levelVerificação rápida
Teste sua compreensão sobre a análise de literais de modelo.
Recapitulação
Você extraiu dados estruturados de tipos de cadeia de caracteres.
- Vários pontos de
infercapturam campos nomeados em um único padrão. - As partes inferidas podem ser restringidas com
extendsdiretamente na expressão. Split,PaireFromPairspodem ser compostos em um analisador de query.Trime as verificações numéricas lidam com casos extremos.
A seguir: um analisador completo de mini-rotas.
Aprenda TypeScript com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 101
- Aulas
- 352
Perguntas Frequentes
A aula “Analisando com Literais de Modelo” é grátis?
Sim — o texto completo de “Analisando com Literais de Modelo” é 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 “Analisando com Literais de Modelo”?
Extraia dados estruturados de textos usando infer. 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 3 de 4.
Quanto tempo leva a aula “Analisando com Literais de Modelo”?
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