Рекурсивные типы в TypeScript

Рекурсивный тип — это тип, который ссылается на самого себя, и он очень полезен для обработки древовидных структур и вложенных данных.

TypeScript поддерживает рекурсивные определения типов, позволяя выражать структуры данных бесконечной глубины.


SVG-иллюстрация: как работают рекурсивные типы Background Title How Recursive Types Work Base Type Base Node interface TreeNode { value: string } Arrow Recursive Reference Recursive Type Recursive Type interface TreeNode { value: string children?: TreeNode[] } Arrow Example Actual Structure root ├── child1 └── child2 Lower Section: Application Scenarios Application Scenarios for Recursive Types Scenario 1 Tree Structure Scenario 2 Nested Objects Scenario 3 Deep Type Transformation Arrow Marker

Зачем нужны рекурсивные типы?

В реальном мире структуры данных часто бывают вложенными.

Например, файловая система имеет папки и подпапки, организационная структура имеет отделы и подотделы, а данные JSON могут быть вложены бесконечно.

Рекурсивные типы позволяют выражать такого рода бесконечно вложенную структуру, и они являются краеугольным камнем обработки древовидных данных.

Концепция:Рекурсивный тип — это тип, который ссылается на самого себя в своём собственном определении, и он может выражать вложенные структуры произвольной глубины.


Древовидная структура

Наиболее распространённое применение рекурсивных типов — представление древовидных структур.

Пример

// Определить тип узла дерева, children ссылается на себя
interface TreeNode {
    id: number;                    // ID узла
    name: string;                  // Имя узла
    children?: TreeNode[];         // Массив дочерних узлов, рекурсивная ссылка
}

// Создать структуру дерева
const fileSystem: TreeNode = {
    id: 1,
    name: "Root",
    children: [
        {
            id: 2,
            name: "Folder 1",
            children: [
                { id: 5, name: "File A.txt" },
                { id: 6, name: "File B.txt" }
            ]
        },
        {
            id: 3,
            name: "Folder 2",
            children: [
                { id: 7, name: "File C.txt" }
            ]
        },
        {
            id: 4,
            name: "File.txt"
        }
    ]
};

// Функция для обхода дерева
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);

Вывод:

📁 根目录
  📁 文件夹1
    📁 文件A.txt
    📁 文件B.txt
  📁 文件夹2
    📁 文件C.txt
  📁 文件.txt

Файловая система:Древовидная структура — классический пример применения рекурсивных типов, и она может представлять деревья каталогов, организационные структуры и многое другое.


Вложенные списки

Рекурсивные типы также могут представлять вложенные структуры списков.

Пример

// Определить тип вложенного списка
type NestedList<T> = T | NestedList<T>[];

// Определить тип задачи
interface Task {
    id: number;
    title: string;
    completed: boolean;
}

// Создать вложенный список задач
const tasks: NestedList<Task> = [
    { id: 1, title: "Проект A", completed: false },
    [
        { id: 2, title: "Подзадача 1", completed: истина },
        { id: 3, title: "Подзадача 2", completed: false }
    ],
    { id: 4, title: "Проект B", completed: false }
];

// Вычислить глубину вложенного списка
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("Глубина списка: " + getDepth(tasks));

Тип объединения:Использование T | NestedList[] может обрабатывать как отдельные элементы, так и массивы.


Глубокий тип Readonly

Используйте рекурсивные типы для реализации глубокого readonly-преобразования.

Пример

// Глубокий readonly-тип — рекурсивное применение
type DeepReadonly<T> = T extends Function
    ? T  // Функции остаются без изменений
    : T extends object
        ? { readonly [P in keyof T]: DeepReadonly<T[P]> }
        : T;

// Тип User
interface User {
    name: string;
    profile: {
        email: string;
        address: {
            city: string;
            zip: string;
        };
    };
    friends: User[];
}

// Создаём глубоко readonly пользователя
const user: DeepReadonly<User> = {
    name: "Alice",
    profile: {
        email: "alice@test.com",
        address: {
            city: "Beijing",
            zip: "100000"
        }
    },
    friends: []
};

// Попытка изменить вызовет ошибку
// user.name = "Bob"; // Ошибка: name — readonly
// user.profile.address.city = "Shanghai"; // Ошибка: вложенные свойства также readonly

console.log("Пользователь: " + user.name);
console.log("Город: " + user.profile.address.city);

Рекурсивное преобразование:DeepReadonly рекурсивно преобразует все вложенные свойства объекта в readonly.


Тип глубокой частичности

Используйте рекурсивные типы для реализации глубокого опционального преобразования.

Пример

// Тип глубокой частичности — рекурсивное применение
type DeepPartial<T> = T extends object
    ? { [P in keyof T]?: DeepPartial<T[P]> }
    : T;

// Тип конфигурации
interface AppConfig {
    база данных: {
        host: string;
        port: number;
        credentials: {
            username: string;
            password: string;
        };
    };
    server: {
        port: number;
        ssl: boolean;
    };
}

// Используя глубокую частичность, можно указать только часть конфигурации
const partialConfig: DeepPartial<AppConfig> = {
    база данных: {
        host: "localhost"
        // порт и учётные данные необязательны
    }
    // сервер необязателен
};

console.log("Хост базы данных: " + partialConfig.database?.host);

Необязательная вложенность:DeepPartial рекурсивно делает все свойства необязательными, что упрощает работу с частичными конфигурациями.


Связные структуры данных

Рекурсивные типы могут представлять связные структуры данных, такие как связные списки.

Пример

// Тип узла связного списка
interface ListNode<T> {
    value: T;              // Значение текущего узла
    next?: ListNode<T>;    // Следующий узел, рекурсивная ссылка
}

// Создать связный список
const linkedList: ListNode<number> = {
    value: 1,
    Далее: {
        value: 2,
        Далее: {
            value: 3,
            Далее: {
                value: 4,
                next: undefined
            }
        }
    }
};

// Обход связанного списка
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("Значения связанного списка: " + values.join(" -> "));
}

traverseList(linkedList);

// Вычислить длину связанного списка
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("Длина связанного списка: " + getLength(linkedList));

Связанный список:ListNodeСсылаясь на себя через next, он образует цепочную структуру, что является классическим применением рекурсивных типов.


Рекурсивные объединённые типы

Используйте рекурсивные типы для обработки объединённых типов в данных JSON.

Тип JSON:Рекурсивные типы могут точно выражать все возможные типы JSON.

Пример

// Рекурсивное определение типа для значений JSON
type JSONValue = string | number | boolean | null | JSONValue[] | { [key: string]: JSONValue };

// Определить объект конфигурации
const config: JSONValue = {
    "name": "my-app",
    "version": "1.0.0",
    "enabled": true,
    "settings": {
        "debug": false,
        "ports": [3000, 8080],
        "metadata": {
            "author": "Alice",
            "tags": ["web", "typescript"]
        }
    }
};

// Функция для получения значения 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("Версия: " + getValue(config, "version"));
console.log("Порт: " + getValue(config, "settings.ports"));
console.log("Автор: " + getValue(config, "settings.metadata.author"));

Примечания

  • Базовый случай рекурсии:Убедитесь, что рекурсивные типы имеют условие завершения, чтобы избежать бесконечной рекурсии.
  • Условные типы:Рекурсия часто используется в сочетании с условными типами.
  • Ограничение глубины:Компилятор TypeScript имеет ограничение на глубину рекурсии.
  • Вопросы производительности:Глубокая рекурсия может повлиять на производительность проверки типов.

Лучшие практики:Рекурсивные типы — мощный инструмент для работы с древовидными и вложенными данными. Их освоение позволяет решать многие сложные задачи типизации.


Итог

Рекурсивные типы — это продвинутая возможность системы типов TypeScript.

  • Самореференция:Ссылка на себя в определении типа.
  • Древовидная структура:Представление бесконечно вложенных данных.
  • Глубокое преобразование:Реализация служебных типов, таких как DeepReadonly и DeepPartial.
  • Цепочные структуры:Представление линейных рекурсивных структур, таких как связные списки.

Рекомендация:При работе с вложенными данными отдавайте предпочтение рекурсивным типам, чтобы обеспечить типобезопасность.

Другие расширения