Рекурсивные типы в TypeScript
Рекурсивный тип — это тип, который ссылается на самого себя, и он очень полезен для обработки древовидных структур и вложенных данных.
TypeScript поддерживает рекурсивные определения типов, позволяя выражать структуры данных бесконечной глубины.
SVG-иллюстрация: как работают рекурсивные типы
Зачем нужны рекурсивные типы?
В реальном мире структуры данных часто бывают вложенными.
Например, файловая система имеет папки и подпапки, организационная структура имеет отделы и подотделы, а данные JSON могут быть вложены бесконечно.
Рекурсивные типы позволяют выражать такого рода бесконечно вложенную структуру, и они являются краеугольным камнем обработки древовидных данных.
Концепция:Рекурсивный тип — это тип, который ссылается на самого себя в своём собственном определении, и он может выражать вложенные структуры произвольной глубины.
Древовидная структура
Наиболее распространённое применение рекурсивных типов — представление древовидных структур.
Пример
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-преобразования.
Пример
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.
Пример
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.
- Цепочные структуры:Представление линейных рекурсивных структур, таких как связные списки.
Другие расширенияРекомендация:При работе с вложенными данными отдавайте предпочтение рекурсивным типам, чтобы обеспечить типобезопасность.