Adição e Subtração no Nível de Tipos
Crie operações aritméticas a partir da manipulação de tuplas.
Adição e Subtração 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.
Aritmética por comprimento
Com a representação por comprimento de tupla, a adição se torna concatenação e a subtração se torna remoção de um prefixo. Você calcula nas tuplas e, depois, lê o comprimento resultante.
type BuildTuple<N extends number, Acc extends unknown[] = []> =
Acc["length"] extends N ? Acc : BuildTuple<N, [...Acc, unknown]>;Adição
Para somar A + B: crie uma tupla de comprimento A, crie outra de comprimento B, expanda ambas em uma nova tupla e leia seu comprimento.
type Add<A extends number, B extends number> =
[...BuildTuple<A>, ...BuildTuple<B>]["length"];
type S = Add<3, 4>; // 7Por que a concatenação soma
Uma tupla de comprimento 3 seguida por uma tupla de comprimento 4 resulta em uma tupla de comprimento 7. Unir as marcas de duas contagens produz uma contagem combinada, portanto os comprimentos são somados.
type A = Add<2, 2>; // 4
type B = Add<0, 5>; // 5
type C = Add<1, 6>; // 7Subtração por prefixo
Para calcular A - B: crie uma tupla de comprimento A e, então, infira-a como um prefixo de comprimento B seguido por um restante. O rest tem comprimento A - B.
type Sub<A extends number, B extends number> =
BuildTuple<A> extends [...BuildTuple<B>, ...infer Rest]
? Rest["length"]
: never;
type D = Sub<7, 4>; // 3Subtração passo a passo
Para Sub<7, 4>: crie uma tupla de comprimento 7, corresponda a um prefixo de comprimento 4, capture Rest (de comprimento 3) e leia seu comprimento. O prefixo removido corresponde exatamente a B marcas.
type A = Sub<5, 2>; // 3
type B = Sub<4, 4>; // 0Subfluxo resulta em um tipo impossível
Os números em nível de tipos são não negativos. Se B > A, não existe um prefixo válido, o padrão falha e o resultado é never. Se preferir, você pode defini-lo como 0 por padrão.
type A = Sub<2, 5>; // never
type SubSafe<A extends number, B extends number> =
[Sub<A, B>] extends [never] ? 0 : Sub<A, B>;
type B = SubSafe<2, 5>; // 0Incremento e decremento
Os casos especiais de somar e subtrair um são comuns o bastante para receber nomes. Inc acrescenta um elemento; Dec remove um.
type Inc<N extends number> = [...BuildTuple<N>, unknown]["length"];
type Dec<N extends number> =
BuildTuple<N> extends [unknown, ...infer R] ? R["length"] : 0;
type A = Inc<4>; // 5
type B = Dec<4>; // 3Multiplicação por repetição
Multiplicação é adição repetida. Adicione B a um acumulador A vezes, fazendo a contagem regressiva com Dec e acumulando com Add.
type Mul<A extends number, B extends number, Acc extends number = 0> =
A extends 0 ? Acc : Mul<Dec<A>, B, Add<Acc, B>>;
type A = Mul<3, 4>; // 12O auxiliar BuildTuple
Toda operação apresentada depende de BuildTuple. Ele é a única primitiva reutilizável: forneça um número e obtenha uma tupla com esse comprimento. Mantenha-o em um único lugar e construa o restante sobre ele.
type Five = BuildTuple<5>; // [unknown, unknown, unknown, unknown, unknown]
type N = Five["length"]; // 5Compondo operações
Como cada operação recebe e retorna um número, elas podem ser compostas livremente. Você pode escrever expressões como Add<Mul<2, 3>, 4>, e o compilador as avalia.
type Result = Add<Mul<2, 3>, 4>; // 10Cuidado prático
Esses truques são ótimos para quantidades pequenas: índices de vetores, tamanhos fixos e intervalos limitados. Para números grandes ou matemática geral, o limite de recursão e a ausência de números negativos tornam-nos impraticáveis. Use-os quando os valores permanecerem pequenos e estáticos.
type A = Add<8, 7>; // 15 (fine)
// Add<5000, 5000> would exceed recursion limitsVerificação rápida
Teste sua compreensão da aritmética em nível de tipos.
Recapitulação
Você implementou aritmética no sistema de tipos.
- Adição: concatene tuplas e leia o comprimento.
- Subtração: infira um prefixo e leia o comprimento do restante.
Inc/Decsão as versões de uma única etapa.BuildTupleé a primitiva compartilhada.
A seguir: comparação de números em nível de tipos.
Perguntas Frequentes
A aula “Adição e Subtração no Nível de Tipos” é grátis?
Sim — o texto completo de “Adição e Subtração 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 “Adição e Subtração no Nível de Tipos”?
Crie operações aritméticas a partir da manipulação de tuplas. 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 “Adição e Subtração 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
- Contagem com o Comprimento de Tuplas
- Adição e Subtração no Nível de Tipos
- Comparações no Nível de Tipos
- Utilitários Práticos para Tipos Numéricos