TypeScript-rekursive Typen
Ein rekursiver Typ ist ein Typ, der sich selbst referenziert, und er ist sehr nützlich für den Umgang mit Baumstrukturen und verschachtelten Daten.
TypeScript unterstützt rekursive Typdefinitionen, mit denen Sie Datenstrukturen unendlicher Tiefe ausdrücken können.
SVG-Illustration: Wie rekursive Typen funktionieren
Warum brauchen wir rekursive Typen?
In der realen Welt sind Datenstrukturen oft verschachtelt.
Zum Beispiel hat ein Dateisystem Ordner und Unterordner, eine Organisationsstruktur hat Abteilungen und Unterabteilungen, und JSON-Daten können unendlich verschachtelt sein.
Rekursive Typen ermöglichen es uns, diese Art von unendlich verschachtelter Struktur auszudrücken, und sie sind der Grundpfeiler für den Umgang mit baumförmigen Daten.
Konzept:Ein rekursiver Typ ist ein Typ, der sich in seiner eigenen Definition selbst referenziert, und er kann verschachtelte Strukturen beliebiger Tiefe ausdrücken.
Baumstruktur
Die häufigste Anwendung rekursiver Typen ist die Darstellung von Baumstrukturen.
Beispiel
interface TreeNode {
id: number; // Knoten-ID
name: string; // Knotenname
children?: TreeNode[]; // Array von Kindknoten, rekursive Referenz
}
// Baumstruktur erstellen
const fileSystem: TreeNode = {
id: 1,
name: "Wurzel",
children: [
{
id: 2,
name: "Ordner 1",
children: [
{ id: 5, name: "Datei A.txt" },
{ id: 6, name: "Datei B.txt" }
]
},
{
id: 3,
name: "Ordner 2",
children: [
{ id: 7, name: "File C.txt" }
]
},
{
id: 4,
name: "File.txt"
}
]
};
// Funktion zum Durchlaufen des Baums
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);
Ausgabe:
📁 根目录
📁 文件夹1
📁 文件A.txt
📁 文件B.txt
📁 文件夹2
📁 文件C.txt
📁 文件.txt
Dateisystem:Baumstruktur ist eine klassische Anwendung rekursiver Typen und kann Verzeichnisbäume, Organisationsstrukturen und mehr darstellen.
Verschachtelte Listen
Rekursive Typen können auch verschachtelte Listenstrukturen darstellen.
Beispiel
type NestedList<T> = T | NestedList<T>[];
// Aufgabentyp definieren
interface Task {
id: number;
title: string;
completed: boolean;
}
// Eine verschachtelte Aufgabenliste erstellen
const tasks: NestedList<Task> = [
{ id: 1, title: "Project A", completed: false },
[
{ id: 2, title: "Subtask 1", completed: wahr },
{ id: 3, title: "Subtask 2", completed: false }
],
{ id: 4, title: "Project B", completed: false }
];
// Die Tiefe der verschachtelten Liste berechnen
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("Listentiefe: " + getDepth(tasks));
Union-Typ:Verwendung von T | NestedList
[] kann sowohl einzelne Elemente als auch Arrays verarbeiten.
Tief schreibgeschützter Typ
Verwende rekursive Typen, um eine tiefgehende Readonly-Transformation zu implementieren.
Beispiel
type DeepReadonly<T> = T extends Function
? T // Funktionen bleiben unverändert
: T extends object
? { readonly [P in keyof T]: DeepReadonly<T[P]> }
: T;
// User-Typ
interface User {
name: string;
Profil: {
email: string;
address: {
city: string;
zip: string;
};
};
friends: User[];
}
// Einen tiefgehend schreibgeschützten Benutzer erstellen
const user: DeepReadonly<User> = {
name: "Alice",
Profil: {
email: "alice@test.com",
address: {
city: "Beijing",
zip: "100000"
}
},
friends: []
};
// Ein Änderungsversuch verursacht einen Fehler
// user.name = "Bob"; // Fehler: name ist schreibgeschützt
// user.profile.address.city = "Shanghai"; // Fehler: verschachtelte Eigenschaften sind ebenfalls schreibgeschützt
console.log("Benutzer: " + user.name);
console.log("Stadt: " + user.profile.address.city);
Rekursive Transformation:DeepReadonly wandelt rekursiv alle verschachtelten Objekteigenschaften in readonly um.
Deep-Partial-Typ
Verwende rekursive Typen, um eine tiefe optionale Transformation umzusetzen.
Beispiel
type DeepPartial<T> = T extends object
? { [P in keyof T]?: DeepPartial<T[P]> }
: T;
// Konfigurationstyp
interface AppConfig {
Datenbank: {
host: string;
port: number;
credentials: {
username: string;
password: string;
};
};
server: {
port: number;
ssl: boolean;
};
}
// Mit Deep Partial können Sie nur einen Teil der Konfiguration angeben
const partialConfig: DeepPartial<AppConfig> = {
Datenbank: {
host: "localhost"
// Port und Anmeldedaten sind optional
}
// Server ist optional
};
console.log("Datenbank-Host: " + partialConfig.database?.host);
Optionale Verschachtelung:DeepPartial macht rekursiv alle Eigenschaften optional, was den Umgang mit partiellen Konfigurationen erleichtert.
Verkettete Datenstrukturen
Rekursive Typen können verkettete Datenstrukturen wie verkettete Listen darstellen.
Beispiel
interface ListNode<T> {
value: T; // Wert des aktuellen Knotens
next?: ListNode<T>; // Nächster Knoten, rekursive Referenz
}
// Eine verkettete Liste erstellen
const linkedList: ListNode<number> = {
value: 1,
next: {
value: 2,
next: {
value: 3,
next: {
value: 4,
next: undefined
}
}
}
};
// Verkettete Liste durchlaufen
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("Werte der verketteten Liste: " + values.join(" -> "));
}
traverseList(linkedList);
// Berechne die Länge der verketteten Liste
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("Länge der verketteten Liste: " + getLength(linkedList));
Verkettete Liste:ListNode
Durch die Referenzierung auf sich selbst über next bildet es eine verkettete Struktur, was eine klassische Anwendung rekursiver Typen ist.
Rekursive Union-Typen
Verwenden Sie rekursive Typen, um Union-Typen in JSON-Daten zu verarbeiten.
JSON-Typ:Rekursive Typen können alle möglichen Typen von JSON präzise ausdrücken.
Beispiel
type JSONValue = string | number | boolean | null | JSONValue[] | { [key: string]: JSONValue };
// Ein Konfigurationsobjekt definieren
const config: JSONValue = {
"name": "my-app",
"version": "1.0.0",
"enabled": true,
"settings": {
"debug": false,
"ports": [3000, 8080],
"metadata": {
"author": "Alice",
"tags": ["web", "typescript"]
}
}
};
// Funktion zum Abrufen eines JSON-Werts
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("Version: " + getValue(config, "version"));
console.log("Port: " + getValue(config, "settings.ports"));
console.log("Autor: " + getValue(config, "settings.metadata.author"));
Hinweise
- Rekursiver Basisfall:Stellen Sie sicher, dass rekursive Typen eine Abbruchbedingung haben, um unendliche Rekursion zu vermeiden.
- Bedingte Typen:Rekursion wird oft in Kombination mit bedingten Typen verwendet.
- Tiefenbegrenzung:Der TypeScript-Compiler hat eine Begrenzung der Rekursionstiefe.
- Leistungsaspekte:Tiefe Rekursion kann die Leistung der Typprüfung beeinträchtigen.
Bewährte Vorgehensweisen:Rekursive Typen sind ein leistungsstarkes Werkzeug für den Umgang mit baumförmigen und verschachtelten Daten. Ihre Beherrschung kann viele komplexe Typprobleme lösen.
Zusammenfassung
Rekursive Typen sind eine fortgeschrittene Funktion des TypeScript-Typsystems.
- Selbstreferenz:Sich selbst in der Typdefinition referenzieren.
- Baumstruktur:Unendlich verschachtelte Daten ausdrücken.
- Tiefe Transformation:Implementierung von Utility-Typen wie DeepReadonly und DeepPartial.
- Verkettete Strukturen:Lineare rekursive Strukturen wie verkettete Listen darstellen.
Andere ErweiterungenEmpfehlung:Bei der Arbeit mit verschachtelten Daten sollten vorrangig rekursive Typen verwendet werden, um die Typsicherheit zu gewährleisten.