0Pricing
TypeScript Academy · Aula

Comparações no Nível de Tipos

Compare números inteiramente no nível de tipos.

Comparações no Nível de Tipos é 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.

Comparando números

Para comparar tipos literais numéricos, você usa tuplas novamente. A ideia é reduzir os dois números passo a passo e verificar qual deles chega a zero primeiro. O número que chegar primeiro à tupla vazia é o menor.

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

Igualdade de literais

A igualdade entre literais numéricos usa a compatibilidade de atribuição mútua. Dois literais são iguais quando cada um pode ser atribuído ao outro. Envolvê-los em tuplas evita surpresas com uniões.

type NumEquals<A extends number, B extends number> =
  [A] extends [B] ? ([B] extends [A] ? true : false) : false;

type X = NumEquals<3, 3>; // true
type Y = NumEquals<3, 4>; // false

Maior que por redução

Para A > B, crie tuplas para ambos e remova um elemento de cada uma a cada etapa. Se B ficar vazia primeiro enquanto A ainda tiver elementos, então A será maior.

type GreaterThan<A extends number, B extends number> =
  BuildTuple<A> extends [...BuildTuple<B>, unknown, ...unknown[]]
    ? true : false;

type X = GreaterThan<5, 3>; // true
type Y = GreaterThan<3, 5>; // false

Como interpretar o padrão

O padrão [...BuildTuple<B>, unknown, ...unknown[]] significa: um prefixo de comprimento B e, depois, pelo menos mais um elemento. Se A corresponder a isso, A terá mais elementos que B; portanto, A > B.

type A = GreaterThan<4, 4>; // false (no extra element)
type B = GreaterThan<6, 2>; // true

Menor que

LessThan é simplesmente GreaterThan com os argumentos invertidos. Reutilize em vez de derivar novamente.

type LessThan<A extends number, B extends number> =
  GreaterThan<B, A>;

type X = LessThan<3, 5>; // true
type Y = LessThan<5, 3>; // false

Maior ou igual

Combine comparação e igualdade. A >= B é verdadeiro quando A > B ou A == B.

type Gte<A extends number, B extends number> =
  GreaterThan<A, B> extends true
    ? true
    : NumEquals<A, B>;

type X = Gte<5, 5>; // true
type Y = Gte<3, 5>; // false

Comparação recursiva

Uma alternativa compara decrementando ambos até que um chegue a zero. Isso mostra explicitamente a ideia de redução passo a passo: o número que chegar primeiro a zero é o menor.

type Cmp<A extends number, B extends number> =
  A extends 0
    ? (B extends 0 ? "eq" : "lt")
    : B extends 0
      ? "gt"
      : Cmp<Dec<A>, Dec<B>>;

type X = Cmp<3, 5>; // "lt"

A dependência do decremento

A versão recursiva precisa de Dec da lição anterior. Cada etapa remove uma marca de cada lado. Quando ambos são zero, eles são iguais; se apenas um for zero, o outro será maior.

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

Igualdade versus compatibilidade de atribuição

Tenha cuidado: number extends number é verdadeiro, mas isso não é igualdade literal. As comparações aqui pressupõem tipos literais específicos, como 3 e 5, e não o tipo amplo number.

type A = NumEquals<3, 3>;          // true
type B = 3 extends number ? 1 : 0; // 1 (assignability, not equality)

Criando uma chave de ordenação

Com a comparação, você pode codificar regras de ordenação. Por exemplo, pode decidir em nível de tipos se uma tupla de dois números está ordenada de forma crescente.

type IsSorted<A extends number, B extends number> =
  GreaterThan<A, B> extends true ? false : true;

type X = IsSorted<2, 5>; // true
type Y = IsSorted<5, 2>; // false

Use com moderação

As comparações consomem recursão. Elas são ótimas para proteger valores pequenos e limitados (índices e limites fixos), mas não constituem uma biblioteca numérica geral. Mantenha os operandos pequenos e prefira a forma baseada em padrão de prefixo, que é menos profunda que a recursão completa passo a passo.

type A = GreaterThan<9, 4>; // true (cheap, prefix pattern)

Verificação rápida

Teste sua compreensão das comparações em nível de tipos.

Recapitulação

Agora você pode ordenar números no sistema de tipos.

  • Igualdade por compatibilidade de atribuição mútua entre literais.
  • GreaterThan por meio de um prefixo de comprimento B mais um elemento adicional.
  • LessThan inverte os argumentos; Gte adiciona a igualdade.
  • Funciona com números literais pequenos, não com o tipo amplo number.

A seguir: transformar tudo isso em utilitários práticos.

Perguntas Frequentes

A aula “Comparações no Nível de Tipos” é grátis?

Sim — o texto completo de “Comparações 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 “Comparações no Nível de Tipos”?

Compare números inteiramente no nível de 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 3 de 4.

Quanto tempo leva a aula “Comparações 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

  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