Validação de Entrada em Tempo de Compilação
Rejeite expressões malformadas de DSL antes da execução.
Validação de Entrada em Tempo de Compilação é 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.
Validação de entradas em tempo de compilação
As DSLs em nível de tipos podem rejeitar expressões malformadas antes da execução. Usando tipos de literais de modelo e tipos condicionais, validamos a estrutura de uma cadeia de caracteres em nível de tipos e recusamos entradas inválidas.
Exemplo: uma pequena linguagem de seleção
Imagine aceitar cadeias de caracteres como "user.name" ou "order.items.length". Queremos rejeitar "user." ou ".name" em tempo de compilação.
Analisando com literais de modelo
Tipos de literais de modelo dividem uma cadeia de caracteres em partes usando infer, a base da análise em tempo de compilação. O padrão real é delimitado por crases (Cabeça ponto Cauda com infer); denotamos esse padrão de divisão 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"]Validando cada segmento
Um tipo condicional verifica se nenhum segmento está vazio. Um segmento vazio torna a entrada inválida. O mesmo padrão DotSplit (um literal de modelo entre crases no código real) conduz a recursão.
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.">; // falseCondicionando a API à validade
Use o tipo de validade para restringir um parâmetro de função: cadeias de caracteres válidas mantêm seu tipo; as inválidas resultam em never, portanto a chamada não compila.
declare function path<S extends string>(
p: Valid<S> extends true ? S : never
): void;
path("user.name"); // ok
path("user."); // Error: argument is neverRejeitando símbolos desconhecidos
Também é possível restringir os caracteres permitidos. Faça a correspondência apenas com padrões de segmentos conhecidos; qualquer outra coisa se reduz a um tipo que rejeita.
type Allowed = "user" | "order" | "name" | "items";
type CheckSeg<S extends string> = S extends Allowed ? true : false;Validando operadores
Para uma DSL de expressões como "age > 18", corresponda ao operador usando um literal de modelo e garanta que ele pertença a um conjunto permitido. O comparador (espaço à esquerda O espaço à direita) é um literal de modelo com acentos graves no código real; nós o denotamos por 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">; // falseCombinando verificações
Os validadores reais combinam várias condições: segmentos não vazios, símbolos permitidos e estrutura equilibrada. Cada uma é um tipo condicional; combine-as com tipos auxiliares de estilo lógico.
type And<A, B> = A extends true ? (B extends true ? true : false) : false;Limites da recursão
A recursão no nível de tipos tem limites de profundidade. Para cadeias de caracteres muito longas, o compilador pode emitir o erro "a instanciação de tipo é excessivamente profunda". Mantenha as entradas analisadas limitadas ou simplifique a gramática.
Melhor que a análise em tempo de execução
Um analisador em tempo de execução só reclama quando a cadeia de caracteres inválida é avaliada. A validação em tempo de compilação rejeita o literal no momento em que você o digita, com retorno completo do editor e nenhum custo em tempo de execução.
Por que isso é importante
Muitas DSLs aceitam entradas de texto (caminhos, consultas e formatos). Validar sua estrutura no sistema de tipos detecta erros de digitação e expressões malformadas antes da execução do programa, transformando uma categoria de erros em tempo de execução em erros de compilação.
Verificação rápida
Verifique sua compreensão da validação de entradas em tempo de compilação.
Recapitulação
Você validou entradas de DSL antes da execução, analisando literais de cadeia de caracteres com tipos de literais de modelo e infer, e depois verificando segmentos e operadores com tipos condicionais. Condicionar um parâmetro de função ao tipo de validade faz com que expressões malformadas resultem em never e não compilem, levando em conta os limites da recursão.
Perguntas Frequentes
A aula “Validação de Entrada em Tempo de Compilação” é grátis?
Sim — o texto completo de “Validação de Entrada em Tempo de Compilação” é 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 “Validação de Entrada em Tempo de Compilação”?
Rejeite expressões malformadas de DSL antes da execução. 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 “Validação de Entrada em Tempo de Compilação”?
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
- O que é uma DSL no Nível de Tipos
- Projetando uma DSL Fluente de Consultas
- Validação de Entrada em Tempo de Compilação
- Mensagens de Erro em DSLs no Nível de Tipos