Tipos recursivos de TypeScript
Los tipos recursivos son tipos que se referencian a sí mismos, muy útiles para manejar estructuras de árbol y datos anidados.
TypeScript admite definiciones de tipos recursivos, que pueden expresar estructuras de datos de profundidad infinita.
Diagrama SVG: cómo funcionan los tipos recursivos
Por qué se necesitan tipos recursivos
En el mundo real, las estructuras de datos suelen estar anidadas.
Por ejemplo, el sistema de archivos tiene carpetas y subcarpetas, la estructura organizacional tiene departamentos y subdepartamentos, y los datos JSON pueden anidarse infinitamente.
Los tipos recursivos nos permiten expresar esta estructura infinitamente anidada, son la base para manejar datos en forma de árbol.
Concepto:Un tipo recursivo es un tipo que se referencia a sí mismo en su definición, y puede expresar estructuras anidadas de cualquier profundidad.
Estructura de árbol
La aplicación más común de los tipos recursivos es representar estructuras de árbol.
Ejemplo
interface TreeNode {
id: number; // ID del nodo
name: string; // Nombre del nodo
children?: TreeNode[]; // Matriz de nodos hijos, referencia recursiva
}
// Crear estructura de árbol
const fileSystem: TreeNode = {
id: 1,
name: "Directorio raíz",
children: [
{
id: 2,
name: "Carpeta1",
children: [
{ id: 5, name: "ArchivoA.txt" },
{ id: 6, name: "ArchivoB.txt" }
]
},
{
id: 3,
name: "Carpeta2",
children: [
{ id: 7, name: "ArchivoC.txt" }
]
},
{
id: 4,
name: "Archivo.txt"
}
]
};
// Función para recorrer el árbol
function traverse(node: TreeNode, depth: number = 0): void {
const indent = " ".repeat(depth);
console.log(indent + "📁 " + node.name);
if (node.children) {
for (const child of node.children) {
traverse(child, depth + 1);
}
}
}
traverse(fileSystem);
Resultado de ejecución:
📁 根目录
📁 文件夹1
📁 文件A.txt
📁 文件B.txt
📁 文件夹2
📁 文件C.txt
📁 文件.txt
Sistema de archivos:La estructura de árbol es una aplicación clásica de los tipos recursivos; puede representar árboles de directorios, estructuras organizativas, etc.
Lista anidada
Los tipos recursivos también pueden representar estructuras de listas anidadas.
Ejemplo
type NestedList<T> = T | NestedList<T>[];
// Definir el tipo de tarea
interface Task {
id: number;
title: string;
completed: boolean;
}
// Crear lista de tareas anidada
const tasks: NestedList<Task> = [
{ id: 1, title: "Proyecto A", completed: false },
[
{ id: 2, title: "Subtarea 1", completed: true },
{ id: 3, title: "Subtarea 2", completed: false }
],
{ id: 4, title: "Proyecto B", completed: false }
];
// Calcular la profundidad de la lista anidada
function getDepth<T>(list: NestedList<T>, depth: number = 0): number {
if (Array.isArray(list)) {
let maxDepth = depth + 1;
for (const item of list) {
maxDepth = Math.max(maxDepth, getDepth(item, depth + 1));
}
return maxDepth;
}
return depth;
}
console.log("Profundidad de la lista: " + getDepth(tasks));
Tipos unión:Usa T | NestedList
[] puede manejar tanto elementos individuales como arrays.
Tipo de solo lectura profundo
Usa tipos recursivos para implementar una conversión profunda de solo lectura.
Ejemplo
type DeepReadonly<T> = T extends Function
? T // Las funciones se mantienen igual
: T extends object
? { readonly [P in keyof T]: DeepReadonly<T[P]> }
: T;
// Tipo de usuario
interface User {
name: string;
profile: {
email: string;
address: {
city: string;
zip: string;
};
};
friends: User[];
}
// Crear usuario de solo lectura profundo
const user: DeepReadonly<User> = {
name: "Alice",
profile: {
email: "alice@test.com",
address: {
city: "Beijing",
zip: "100000"
}
},
friends: []
};
// Intentar modificar dará un error
// user.name = "Bob"; // Error: name es de solo lectura
// user.profile.address.city = "Shanghai"; // Error: los niveles profundos también son de solo lectura
console.log("Usuario: " + user.name);
console.log("Ciudad: " + user.profile.address.city);
Conversión recursiva:DeepReadonly convierte recursivamente todas las propiedades de los objetos anidados en solo lectura.
Tipo opcional profundo
Usa tipos recursivos para implementar una conversión profunda con propiedades opcionales.
Ejemplo
type DeepPartial<T> = T extends object
? { [P in keyof T]?: DeepPartial<T[P]> }
: T;
// Tipo de configuración
interface AppConfig {
database: {
host: string;
port: number;
credentials: {
username: string;
password: string;
};
};
server: {
port: number;
ssl: boolean;
};
}
// Al usar opcional profundo, se puede proporcionar solo una configuración parcial
const partialConfig: DeepPartial<AppConfig> = {
database: {
host: "localhost"
// port y credentials son opcionales
}
// server es opcional
};
console.log("Host de la base de datos: " + partialConfig.database?.host);
Anidamiento opcional:DeepPartial convierte recursivamente todas las propiedades en opcionales, lo que facilita el manejo de configuraciones parciales.
Estructura de datos en cadena
Los tipos recursivos pueden representar estructuras de datos en cadena, como listas enlazadas.
Ejemplo
interface ListNode<T> {
value: T; // Valor del nodo actual
next?: ListNode<T>; // Siguiente nodo, referencia recursiva
}
// Crear lista enlazada
const linkedList: ListNode<number> = {
value: 1,
next: {
value: 2,
next: {
value: 3,
next: {
value: 4,
next: undefined
}
}
}
};
// Recorrer la lista enlazada
function traverseList<T>(node: ListNode<T>): void {
let current: ListNode<T> | undefined = node;
const values: T[] = [];
while (current) {
values.push(current.value);
current = current.next;
}
console.log("Valor de la lista enlazada: " + values.join(" -> "));
}
traverseList(linkedList);
// Calcular la longitud de la lista enlazada
function getLength<T>(node: ListNode<T>): number {
let length = 0;
let current: ListNode<T> | undefined = node;
while (current) {
length++;
current = current.next;
}
return length;
}
console.log("Longitud de la lista enlazada: " + getLength(linkedList));
Lista enlazada:ListNode
Al referenciarse a sí mismo mediante next, se forma una estructura en cadena, una aplicación clásica de los tipos recursivos.
Recursión de tipos unión
Usa tipos recursivos para manejar tipos unión de datos JSON.
Tipo JSON:Los tipos recursivos pueden expresar con precisión todos los tipos posibles de JSON.
Ejemplo
type JSONValue = string | number | boolean | null | JSONValue[] | { [key: string]: JSONValue };
// Definir objeto de configuración
const config: JSONValue = {
"name": "my-app",
"version": "1.0.0",
"enabled": true,
"settings": {
"debug": false,
"ports": [3000, 8080],
"metadata": {
"author": "Alice",
"tags": ["web", "typescript"]
}
}
};
// Función para obtener valores JSON
function getValue(obj: JSONValue, path: string): JSONValue | undefined {
const keys = path.split(".");
let current: JSONValue | undefined = obj;
for (const key of keys) {
if (current && typeof current === "object" && !Array.isArray(current)) {
current = (current as { [key: string]: JSONValue })[key];
} else {
return undefined;
}
}
return current;
}
console.log("Versión: " + getValue(config, "version"));
console.log("Puerto: " + getValue(config, "settings.ports"));
console.log("Autor: " + getValue(config, "settings.metadata.author"));
Consideraciones
- Caso base de recursión:Asegúrate de que el tipo recursivo tenga una condición de terminación para evitar la recursión infinita.
- Tipos condicionales:La recursión suele combinarse con tipos condicionales.
- Límite de profundidad:El compilador de TypeScript tiene límites en la profundidad de la recursión.
- Consideraciones de rendimiento:La recursión profunda puede afectar el rendimiento de la verificación de tipos.
Mejores prácticas:Los tipos recursivos son una herramienta poderosa para manejar datos en árbol y anidados; dominarlos permite resolver muchos problemas de tipos complejos.
Resumen
Los tipos recursivos son una característica avanzada del sistema de tipos de TypeScript.
- Autorreferencia:Se referencian a sí mismos en la definición del tipo.
- Estructura de árbol:Expresan datos infinitamente anidados.
- Conversión profunda:Implementan tipos de utilidad como solo lectura profunda y opcional profundo.
- Estructura en cadena:Representan estructuras recursivas lineales como listas enlazadas.
Otras extensionesRecomendación:Al manejar datos anidados, prioriza el uso de tipos recursivos para garantizar la seguridad de tipos.