0Pricing
TypeScript Academy · Aula

Utilitários Práticos para Tipos Numéricos

Aplique aritmética de tipos a restrições de intervalo e comprimento.

Utilitários Práticos para Tipos Numéricos é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 4 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 teoria às ferramentas

A aritmética e a comparação se tornam úteis quando são empacotadas como utilitários práticos: intervalos, vetores com comprimento imposto e índices limitados. Esta lição transforma as primitivas em recursos que você realmente usaria em um projeto.

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

Enumerando: de 0 a N-1

Um auxiliar fundamental produz uma união de todos os números de 0 a N-1. Crie uma tupla de comprimento N e leia cada índice de chave.

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

type A = Enumerate<4>; // 0 | 1 | 2 | 3

Tipos de intervalo

Um Range<Start, End> produz os números de Start até End - 1. Obtenha Enumerate<End> e exclua os valores abaixo de Start.

type Range<S extends number, E extends number> =
  Exclude<Enumerate<E>, Enumerate<S>>;

type A = Range<2, 6>; // 2 | 3 | 4 | 5

Restringindo um parâmetro

Use um intervalo para restringir os argumentos válidos. Uma função que aceite apenas o lançamento de um dado pequeno pode receber Range<1, 7>, fazendo o compilador rejeitar valores fora dos limites.

type DiceFace = Range<1, 7>; // 1|2|3|4|5|6
declare function roll(face: DiceFace): void;
roll(4); // ok
// roll(8); // compile error

Impondo o comprimento do vetor

Um tipo de vetor de comprimento fixo rejeita vetores com tamanho incorreto. Crie uma tupla com N elementos do tipo T usando recursão.

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

type RGB = FixedArray<number, 3>; // [number, number, number]

Usando comprimento fixo

Agora o uso incorreto gera um erro de compilação. Um ponto em 3D deve ter exatamente três coordenadas.

type Vec3 = FixedArray<number, 3>;
const v: Vec3 = [1, 2, 3]; // ok
// const w: Vec3 = [1, 2]; // error: missing element

Limitando índices

Você pode limitar um tipo de índice às posições válidas de um vetor. Combine o comprimento de uma tupla com Enumerate para que somente índices dentro dos limites sejam aceitos.

type Indices<T extends readonly unknown[]> = Enumerate<T["length"]>;

type Arr = readonly ["a", "b", "c"];
type I = Indices<Arr>; // 0 | 1 | 2

Acesso indexado seguro

Com um tipo de índice válido, você pode escrever uma função de acesso cujo parâmetro de índice não possa sair dos limites, detectando erros de deslocamento de uma posição durante a compilação.

declare function at<T extends readonly unknown[]>(
  arr: T,
  i: Indices<T>
): T[Indices<T>];

const x = at(["a", "b", "c"] as const, 2); // ok
// at(["a", "b", "c"] as const, 3); // error

Auxiliares de mínimo e máximo

Adicione a comparação para escolher o maior ou o menor de dois números, o que é útil para limitar um valor a um intervalo.

type Max<A extends number, B extends number> =
  GreaterThan<A, B> extends true ? A : B;
type Min<A extends number, B extends number> =
  GreaterThan<A, B> extends true ? B : A;

type X = Max<3, 8>; // 8
type Y = Min<3, 8>; // 3

Compondo utilitários

Esses utilitários podem ser combinados. Uma tupla com comprimento dentro de um intervalo, um índice limitado ao próprio vetor e um valor restrito pelo mínimo e pelo máximo: cada um é uma pequena função reutilizável em nível de tipos.

type ValidPort = Range<1, 4>; // 1 | 2 | 3 (toy example)
type Slots = FixedArray<ValidPort, 2>; // [1|2|3, 1|2|3]

Quando vale a pena

A aritmética de tipos é especialmente útil para limites pequenos e fixos: tuplas RGB, faces de dados, coordenadas de tabuleiro e tamanhos de campos de protocolo. Ela não vale a pena para números grandes ou dinâmicos, nos quais os limites de recursão e a complexidade superam o benefício da segurança. Use-a quando o limite for pequeno e a garantia for valiosa.

type Board = FixedArray<FixedArray<0 | 1, 3>, 3>; // 3x3 grid

Verificação rápida

Teste sua compreensão dos utilitários numéricos práticos.

Recapitulação

Você criou uma pequena biblioteca de utilitários numéricos de tipos.

  • Enumerate e Range produzem uniões de números.
  • FixedArray impõe comprimentos exatos.
  • Indices limita o acesso a posições válidas.
  • Min/Max restringem os valores.

Use-os para limites pequenos e fixos. A seguir, no curso 23: simulando tipos de ordem superior.

Perguntas Frequentes

A aula “Utilitários Práticos para Tipos Numéricos” é grátis?

Sim — o texto completo de “Utilitários Práticos para Tipos Numéricos” é 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 “Utilitários Práticos para Tipos Numéricos”?

Aplique aritmética de tipos a restrições de intervalo e comprimento. 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 4 de 4.

Quanto tempo leva a aula “Utilitários Práticos para Tipos Numéricos”?

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