0Pricing
TypeScript Academy · Aula

Contagem com o Comprimento de Tuplas

Represente números como comprimentos de tuplas nos tipos.

Contagem com o Comprimento de Tuplas é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 1 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.

Números precisam de uma representação

O sistema de tipos não pode somar literais numéricos diretamente. A solução clássica é representar um número N como uma tupla com N elementos. O conteúdo não importa; apenas o comprimento importa.

type Three = [unknown, unknown, unknown];
type N = Three["length"]; // 3

Leitura do comprimento

Cada tipo de tupla tem uma propriedade length que é um tipo literal numérico. A indexação com ["length"] recupera seu valor como um número que você pode usar.

type A = [1, 2, 3, 4]["length"]; // 4
type B = []["length"];           // 0
type C = ["x"]["length"];        // 1

Por que usar o tipo desconhecido como preenchimento

Usamos unknown como tipo dos elementos porque os valores são irrelevantes; somente a quantidade importa. Qualquer tipo funcionaria, mas unknown indica claramente um "marcador".

type Two = [unknown, unknown];
type N = Two["length"]; // 2

Criando uma tupla de comprimento N

Para fazer o caminho inverso, crie uma tupla com o comprimento desejado usando recursão. Adicione elementos até que o comprimento corresponda a N e, então, retorne a tupla. Este é o conhecido auxiliar BuildTuple.

type BuildTuple<N extends number, Acc extends unknown[] = []> =
  Acc["length"] extends N ? Acc : BuildTuple<N, [...Acc, unknown]>;

type A = BuildTuple<3>; // [unknown, unknown, unknown]

Como BuildTuple repete o processo

Acompanhe BuildTuple<3>:

  • Comprimento do acumulador 0, diferente de 3; adicione um elemento
  • Comprimento do acumulador 1, diferente de 3; adicione um elemento
  • Comprimento do acumulador 2, diferente de 3; adicione um elemento
  • Comprimento do acumulador 3, igual a 3; retorne

O comprimento do acumulador é o contador do processo.

type A = BuildTuple<2>; // [unknown, unknown]

O comprimento é a ponte

Duas operações permitem passar entre números e tuplas:

  • Número para tupla: BuildTuple<N>
  • Tupla para número: T["length"]

Toda a aritmética de tipos se baseia em atravessar essa ponte.

type FromN = BuildTuple<4>;        // tuple of length 4
type BackToN = FromN["length"];    // 4

Comparando por comprimento

Como o comprimento de uma tupla é um literal, você pode verificar a igualdade entre quantidades. Crie tuplas e compare seus comprimentos por meio da compatibilidade de atribuição.

type SameLength<A extends unknown[], B extends unknown[]> =
  A["length"] extends B["length"] ? true : false;

type X = SameLength<[1, 2], ["a", "b"]>;   // true
type Y = SameLength<[1], ["a", "b"]>;      // false

Um contador genérico de comprimento

Você pode reimplementar length por meio de recursão para entendê-lo, embora ler ["length"] seja mais rápido. Isso mostra que contar consiste apenas em percorrer uma tupla.

type Len<T extends unknown[], Acc extends unknown[] = []> =
  T extends [unknown, ...infer R]
    ? Len<R, [...Acc, unknown]>
    : Acc["length"];

type A = Len<["a", "b", "c"]>; // 3

Tuplas como contadores

Considere a tupla como uma contagem: cada elemento é uma marca. Adicionar um elemento incrementa a contagem; remover um a decrementa. Esse modelo mental torna a aritmética intuitiva.

type Inc<N extends number> = [...BuildTuple<N>, unknown]["length"];

type A = Inc<3>; // 4

Prévia do decremento

Para decrementar, crie a tupla de N, depois infira tudo, exceto o último elemento, e leia o comprimento menor. Você formalizará isso na próxima lição.

type Dec<N extends number> =
  BuildTuple<N> extends [unknown, ...infer R] ? R["length"] : 0;

type A = Dec<3>; // 2
type B = Dec<0>; // 0

Limites a lembrar

Essa técnica funciona para inteiros pequenos e não negativos. Um N muito grande atinge os limites de recursão, e não existe um recurso integrado para números negativos ou decimais. Dentro desses limites, ela é confiável e totalmente estática.

type A = BuildTuple<5>["length"]; // 5 (fine)
// BuildTuple<10000> would error: too deep

Verificação rápida

Teste sua compreensão da contagem por comprimento de tuplas.

Recapitulação

A contagem é a base da matemática em nível de tipos.

  • Represente N como uma tupla de comprimento N.
  • Leia o número com T["length"].
  • BuildTuple<N> transforma um número em uma tupla.
  • Funciona apenas para inteiros pequenos e não negativos.

A seguir: adição e subtração de verdade.

Perguntas Frequentes

A aula “Contagem com o Comprimento de Tuplas” é grátis?

Sim — o texto completo de “Contagem com o Comprimento de Tuplas” é 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 “Contagem com o Comprimento de Tuplas”?

Represente números como comprimentos de tuplas nos 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 1 de 4.

Quanto tempo leva a aula “Contagem com o Comprimento de Tuplas”?

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

  1. Contagem com o Comprimento de Tuplas
  2. Adição e Subtração no Nível de Tipos
  3. Comparações no Nível de Tipos
  4. Utilitários Práticos para Tipos Numéricos
← Voltar para TypeScript Academy