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 Fondo Título Cómo funcionan los tipos recursivos Tipo base Nodo base interface TreeNode { value: string } Flecha Referencia recursiva Tipo recursivo Tipo recursivo interface TreeNode { value: string children?: TreeNode[] } Flecha Ejemplo Estructura real root ├── child1 └── child2 Parte inferior: escenarios de aplicación Escenarios de aplicación de los tipos recursivos Escenario 1 Estructura de árbol Escenario 2 Objetos anidados Escenario 3 Conversión de tipos profunda Marca de flecha

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

// Define el tipo de nodo de árbol, children se referencia a sí mismo
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

// Definir el tipo de lista anidada
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

// Tipo de solo lectura profundo - Aplicación recursiva
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

// Tipo opcional profundo - Aplicación recursiva
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

// Tipo de nodo de lista enlazada
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:ListNodeAl 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

// Definición de tipo recursivo para valores JSON
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.

Recomendación:Al manejar datos anidados, prioriza el uso de tipos recursivos para garantizar la seguridad de tipos.

Otras extensiones