0Pricing
TypeScript Academy · Lección

Conteo con la longitud de tuplas

Represente números como longitudes de tuplas en los tipos.

Conteo con la longitud de tuplas es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 1 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.

Los números necesitan una representación

El sistema de tipos no puede sumar literales numéricos directamente. La solución clásica consiste en representar un número N como una tupla con N elementos. El contenido no importa; solo importa la longitud.

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

Lectura de length

Todo tipo de tupla tiene una propiedad length que es un tipo literal numérico. Al indexar con ["length"], se obtiene como un número que puede utilizar.

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

Por qué usar unknown como relleno

Usamos unknown como tipo de elemento porque los valores son irrelevantes; solo importa la cantidad. Cualquier tipo funciona, pero unknown indica claramente que se trata de un «placeholder».

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

Construcción de una tupla de longitud N

Para hacerlo al revés, construya una tupla con una longitud objetivo mediante recursión. Añada elementos hasta que la longitud coincida con N y, después, devuelva la tupla. Esta es la famosa utilidad 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]

Cómo funciona el bucle de BuildTuple

Analicemos BuildTuple<3>:

  • Longitud de Acc: 0; no es 3; añada uno
  • Longitud de Acc: 1; no es 3; añada uno
  • Longitud de Acc: 2; no es 3; añada uno
  • Longitud de Acc: 3; coincide con 3; devuelva

La longitud del acumulador es el contador del bucle.

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

length es el puente

Dos operaciones permiten pasar de números a tuplas y viceversa:

  • De número a tupla: BuildTuple<N>
  • De tupla a número: T["length"]

Toda la aritmética a nivel de tipos se basa en cruzar este puente.

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

Comparación por longitud

Como la longitud de una tupla es un literal, puede comprobar la igualdad entre cantidades. Construya tuplas y compare sus longitudes mediante asignabilidad.

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

Un contador genérico de length

Puede volver a implementar length mediante recursión para entenderlo, aunque leer ["length"] es más rápido. Esto muestra que contar consiste simplemente en recorrer una 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

Las tuplas como contadores

Considere la tupla como un conteo: cada elemento es una marca. Añadir un elemento incrementa el valor; quitar uno lo decrementa. Este modelo mental hace que la aritmética resulte intuitiva.

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

type A = Inc<3>; // 4

Vista previa del decremento

Para decrementar, se construye la tupla para N, después se infiere todo excepto el último elemento y se lee la longitud más corta. Formalizará esto en la lección siguiente.

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

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

Límites que debe recordar

Esta técnica funciona para enteros no negativos pequeños. Un N muy grande alcanza los límites de recursión y no existe ninguna operación integrada para negativos o decimales. Dentro de esos límites, es fiable y completamente estática.

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

Comprobación rápida

Compruebe su comprensión del conteo mediante la longitud de tuplas.

Recapitulación

Contar es la base de las matemáticas a nivel de tipos.

  • Represente N como una tupla de longitud N.
  • Lea el número con T["length"].
  • BuildTuple<N> transforma un número en una tupla.
  • Solo funciona con enteros no negativos pequeños.

Siguiente: suma y resta reales.

Preguntas frecuentes

¿La lección «Conteo con la longitud de tuplas» es gratis?

Sí — el texto completo de «Conteo con la longitud de tuplas» 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 «Conteo con la longitud de tuplas»?

Represente números como longitudes de tuplas en los 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 1 de 4.

¿Cuánto tiempo toma la lección «Conteo con la longitud de tuplas»?

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

  1. Conteo con la longitud de tuplas
  2. Suma y resta a nivel de tipos
  3. Comparaciones a nivel de tipos
  4. Utilidades prácticas para tipos numéricos
← Volver a TypeScript Academy