Comparaciones a nivel de tipos
Compare números completamente en el nivel de tipos.
Comparaciones a nivel de tipos es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de TypeScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de TypeScript Academy incluye 4 lecciones en total.
Comparación de números
Para comparar tipos literales numéricos, vuelva a apoyarse en las tuplas. La idea consiste en reducir ambos números al mismo ritmo y comprobar cuál llega primero a cero. El que alcanza primero la tupla vacía es el número menor.
type BuildTuple<N extends number, Acc extends unknown[] = []> =
Acc["length"] extends N ? Acc : BuildTuple<N, [...Acc, unknown]>;Igualdad de literales
La igualdad entre literales numéricos utiliza la asignabilidad mutua. Dos literales son iguales cuando cada uno extiende al otro. Envolverlos en tuplas evita sorpresas con las uniones.
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>; // falseMayor que mediante reducción
Para A > B, construya tuplas para ambos números y elimine un elemento de cada una en cada paso. Si B se vacía primero mientras A aún tiene elementos, entonces A es mayor.
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>; // falseCómo se interpreta el patrón
El patrón [...BuildTuple<B>, unknown, ...unknown[]] significa: un prefijo de longitud B y, después, al menos un elemento más. Si A encaja en él, A tiene más elementos que B, por lo que A > B.
type A = GreaterThan<4, 4>; // false (no extra element)
type B = GreaterThan<6, 2>; // trueMenor que
LessThan no es más que GreaterThan con los argumentos invertidos. Reutilice en lugar de volver a derivar la lógica.
type LessThan<A extends number, B extends number> =
GreaterThan<B, A>;
type X = LessThan<3, 5>; // true
type Y = LessThan<5, 3>; // falseMayor o igual
Combine la comparación con la igualdad. A >= B es verdadero cuando A > B o 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>; // falseComparación recursiva
Otra alternativa consiste en comparar decrementando ambos números hasta que uno llegue a cero. Esto muestra explícitamente la idea de avanzar al mismo ritmo: el que llega primero a cero es el 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"La dependencia de Dec
La versión recursiva necesita Dec de la lección anterior. En cada paso se elimina una marca de cada lado. Cuando ambos son cero, son iguales; si solo uno es cero, el otro es mayor.
type Dec<N extends number> =
BuildTuple<N> extends [unknown, ...infer R] ? R["length"] : 0;Igualdad frente a asignabilidad
Tenga cuidado: number extends number es verdadero, pero eso no es igualdad literal. Estas comparaciones presuponen tipos literales específicos, como 3 y 5, no el tipo amplio number.
type A = NumEquals<3, 3>; // true
type B = 3 extends number ? 1 : 0; // 1 (assignability, not equality)Construcción de una clave de ordenación
Con las comparaciones puede codificar reglas de ordenación. Por ejemplo, puede decidir a nivel de tipos si una tupla de dos números está ordenada de forma ascendente.
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>; // falseUsar con moderación
Las comparaciones consumen recursión. Son excelentes para proteger valores pequeños y acotados, como índices y límites fijos, pero no constituyen una biblioteca numérica general. Mantenga los operandos pequeños y prefiera la forma basada en patrones de prefijo, que es menos profunda que una recursión completa al mismo ritmo.
type A = GreaterThan<9, 4>; // true (cheap, prefix pattern)Comprobación rápida
Compruebe su comprensión de las comparaciones a nivel de tipos.
Recapitulación
Ahora puede ordenar números en el sistema de tipos.
- Igualdad mediante asignabilidad mutua de literales.
GreaterThanmediante un prefijo de longitud B más un elemento adicional.LessThaninvierte los argumentos;Gteañade la igualdad.- Funciona con números literales pequeños, no con el tipo amplio
number.
Siguiente: convertir todo esto en utilidades prácticas.
Preguntas frecuentes
¿La lección «Comparaciones a nivel de tipos» es gratis?
Sí — el texto completo de «Comparaciones a nivel de tipos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de TypeScript Academy, actualiza a CoddyKit PRO. El curso de TypeScript Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Comparaciones a nivel de tipos»?
Compare números completamente en el nivel de tipos. Practicas TypeScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar TypeScript Academy?
No se requiere experiencia previa. TypeScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «Comparaciones a nivel de tipos»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de TypeScript Academy?
Sí. Cada lección de TypeScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Conteo con la longitud de tuplas
- Suma y resta a nivel de tipos
- Comparaciones a nivel de tipos
- Utilidades prácticas para tipos numéricos