TypeScript Academy · Lección

Definiciones de tipos recursivos

Escriba tipos que se referencien a sí mismos de forma segura.

Definiciones de tipos recursivos 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.

¿Qué es un tipo recursivo?

Un tipo recursivo es un tipo que hace referencia a sí mismo en su propia definición. Esto permite describir estructuras de datos de profundidad ilimitada.

type LinkedList<T> = {
  value: T;
  next: LinkedList<T> | null;
};
// next is the same type again, ending at null.

Un tipo de lista enlazada

El ejemplo clásico: cada nodo contiene un value y un puntero next a otro nodo, o null para finalizar la cadena.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const list: LinkedList<number> = {
  value: 1,
  next: { value: 2, next: null }
};
console.log(list.value, list.next?.value);

El caso base es importante

Todo tipo recursivo necesita un terminador, en este caso null, para que la recursión pueda finalizar. Sin él, el tipo tendría una profundidad infinita.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const single: LinkedList<string> = { value: "only", next: null };
console.log(single.next);

Construir cadenas más largas

Puede anidar tantos niveles como quiera; el tipo permite cualquier longitud porque next es una lista o un valor nulo.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const chain: LinkedList<number> = {
  value: 10,
  next: { value: 20, next: { value: 30, next: null } }
};
console.log(chain.next?.next?.value);

Recorrer una lista enlazada

Una función puede recorrer la cadena siguiendo next hasta llegar a null. El tipo recursivo hace que todo el proceso sea completamente seguro respecto a los tipos.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function toArray<T>(list: LinkedList<T> | null): T[] {
  const out: T[] = [];
  let cur = list;
  while (cur) { out.push(cur.value); cur = cur.next; }
  return out;
}
const l: LinkedList<number> = { value: 1, next: { value: 2, next: null } };
console.log(toArray(l));

Funciones recursivas sobre tipos recursivos

Los tipos recursivos se combinan naturalmente con las funciones recursivas. Aquí calculamos la longitud aplicando la recursión sobre next.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function length<T>(list: LinkedList<T> | null): number {
  return list === null ? 0 : 1 + length(list.next);
}
const l: LinkedList<string> = { value: "a", next: { value: "b", next: null } };
console.log(length(l));

Añadir elementos al principio de una lista

Como el tipo es uniforme, crear listas nuevas es sencillo: envuelva una lista existente como next de un nuevo nodo inicial.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function prepend<T>(value: T, list: LinkedList<T> | null): LinkedList<T> {
  return { value, next: list };
}
const l = prepend(1, prepend(2, null));
console.log(l.value, l.next?.value);

Terminadores opcionales frente a anulables

Puede terminar con null o hacer que next sea opcional. Ambas opciones finalizan la recursión; elija según cómo quiera representar el final.

type ListA<T> = { value: T; next: ListA<T> | null };
type ListB<T> = { value: T; next?: ListB<T> };
const a: ListA<number> = { value: 1, next: null };
const b: ListB<number> = { value: 1 };
console.log(a.value, b.value);

Los tipos recursivos son perezosos

TypeScript solo expande un tipo recursivo hasta donde realmente se utiliza. La definición puede autorreferenciarse sin provocar un trabajo infinito.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
// Using two levels only expands two levels.
const l: LinkedList<number> = { value: 1, next: { value: 2, next: null } };
console.log(l.next?.value);

Aplicar un mapeo sobre una lista

Un mapeo recursivo transforma cada valor mientras conserva la estructura y devuelve una lista nueva con la misma forma.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function mapList<T, U>(list: LinkedList<T> | null, fn: (v: T) => U): LinkedList<U> | null {
  if (list === null) return null;
  return { value: fn(list.value), next: mapList(list.next, fn) };
}
const l: LinkedList<number> = { value: 1, next: { value: 2, next: null } };
console.log(mapList(l, x => x * 10)?.value);

Por qué son potentes los tipos recursivos

Los tipos autorreferenciados permiten modelar datos anidados arbitrariamente, listas, árboles y JSON, con seguridad completa de tipos y sin un límite de profundidad fijo en el diseño.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const l: LinkedList<boolean> = { value: true, next: { value: false, next: null } };
console.log(l.value, l.next?.value);

Comprobación rápida: tipos recursivos

Compruebe que entiende las definiciones de tipos recursivos.

Resumen: definiciones de tipos recursivos

Ha aprendido que un tipo recursivo hace referencia a sí mismo, necesita un caso base como null para terminar y se combina naturalmente con funciones recursivas para recorrer, transformar y construir listas enlazadas.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const l: LinkedList<number> = { value: 1, next: null };
console.log(l.value);

Preguntas frecuentes

¿La lección «Definiciones de tipos recursivos» es gratis?

Sí — el texto completo de «Definiciones de tipos recursivos» 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 «Definiciones de tipos recursivos»?

Escriba tipos que se referencien a sí mismos de forma segura. 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 «Definiciones de tipos recursivos»?

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

← Volver a TypeScript Academy