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 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

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

// Baumknotentyp definieren, children verweist auf sich selbst
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

// Typ für verschachtelte Liste definieren
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

// Deep-Readonly-Typ - rekursive Anwendung
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

// Tiefer partieller Typ - rekursive Anwendung
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

// Typ des Knotens einer verketteten Liste
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:ListNodeDurch 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

// Rekursive Typdefinition für JSON-Werte
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.

Empfehlung:Bei der Arbeit mit verschachtelten Daten sollten vorrangig rekursive Typen verwendet werden, um die Typsicherheit zu gewährleisten.

Andere Erweiterungen