Types récursifs TypeScript
Un type récursif est un type qui se référence lui-même, et il est très utile pour gérer les structures arborescentes et les données imbriquées.
TypeScript prend en charge les définitions de types récursifs, vous permettant d'exprimer des structures de données de profondeur infinie.
Illustration SVG : Comment fonctionnent les types récursifs
Pourquoi avons-nous besoin de types récursifs ?
Dans le monde réel, les structures de données sont souvent imbriquées.
Par exemple, un système de fichiers comporte des dossiers et des sous-dossiers, une structure organisationnelle comporte des départements et des sous-départements, et les données JSON peuvent être imbriquées à l'infini.
Les types récursifs nous permettent d'exprimer ce type de structure imbriquée à l'infini, et ils sont la pierre angulaire de la gestion des données en forme d'arbre.
Concept :Un type récursif est un type qui se référence lui-même dans sa propre définition, et il peut exprimer des structures imbriquées de profondeur arbitraire.
Structure arborescente
L'application la plus courante des types récursifs est de représenter des structures arborescentes.
Exemple
interface TreeNode {
id: number; // ID du nœud
name: string; // Nom du nœud
children?: TreeNode[]; // Tableau de nœuds enfants, référence récursive
}
// Créer une structure d'arbre
const fileSystem: TreeNode = {
id: 1,
name: "Racine",
children: [
{
id: 2,
name: "Dossier 1",
children: [
{ id: 5, name: "Fichier A.txt" },
{ id: 6, name: "Fichier B.txt" }
]
},
{
id: 3,
name: "Dossier 2",
children: [
{ id: 7, name: "File C.txt" }
]
},
{
id: 4,
name: "File.txt"
}
]
};
// Fonction pour parcourir l'arbre
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);
Sortie :
📁 根目录
📁 文件夹1
📁 文件A.txt
📁 文件B.txt
📁 文件夹2
📁 文件C.txt
📁 文件.txt
Système de fichiers :La structure arborescente est une application classique des types récursifs, et elle peut représenter des arborescences de répertoires, des structures organisationnelles, et plus encore.
Listes imbriquées
Les types récursifs peuvent également représenter des structures de listes imbriquées.
Exemple
type NestedList<T> = T | NestedList<T>[];
// Définir le type de tâche
interface Task {
id: number;
title: string;
completed: boolean;
}
// Créer une liste de tâches imbriquée
const tasks: NestedList<Task> = [
{ id: 1, title: "Project A", completed: false },
[
{ id: 2, title: "Subtask 1", completed: vrai },
{ id: 3, title: "Subtask 2", completed: false }
],
{ id: 4, title: "Project B", completed: false }
];
// Calculer la profondeur de la liste imbriquée
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("Profondeur de la liste : " + getDepth(tasks));
Type union :Utilisation de T | NestedList
[] peut gérer à la fois des éléments individuels et des tableaux.
Type Readonly profond
Utiliser des types récursifs pour implémenter une transformation profonde en lecture seule.
Exemple
type DeepReadonly<T> = T extends Function
? T // Les fonctions restent inchangées
: T extends object
? { readonly [P in keyof T]: DeepReadonly<T[P]> }
: T;
// Type User
interface User {
name: string;
profile: {
email: string;
address: {
city: string;
zip: string;
};
};
friends: User[];
}
// Créer un utilisateur en lecture seule profonde
const user: DeepReadonly<User> = {
name: "Alice",
profile: {
email: "alice@test.com",
address: {
city: "Beijing",
zip: "100000"
}
},
friends: []
};
// Toute tentative de modification provoquera une erreur
// user.name = "Bob"; // Erreur : name est en lecture seule
// user.profile.address.city = "Shanghai"; // Erreur : les propriétés imbriquées sont aussi en lecture seule
console.log("Utilisateur : " + user.name);
console.log("Ville : " + user.profile.address.city);
Transformation récursive :DeepReadonly convertit récursivement toutes les propriétés des objets imbriqués en readonly.
Type partiel profond
Utilisez des types récursifs pour implémenter une transformation profonde en optionnel.
Exemple
type DeepPartial<T> = T extends object
? { [P in keyof T]?: DeepPartial<T[P]> }
: T;
// Type de configuration
interface AppConfig {
base de données: {
host: string;
port: number;
credentials: {
username: string;
password: string;
};
};
server: {
port: number;
ssl: boolean;
};
}
// En utilisant le type partiel profond, vous pouvez ne fournir qu'une partie de la configuration
const partialConfig: DeepPartial<AppConfig> = {
base de données: {
host: "localhost"
// le port et les identifiants sont facultatifs
}
// le serveur est facultatif
};
console.log("Hôte de la base de données : " + partialConfig.database?.host);
Imbrication facultative :DeepPartial rend récursivement toutes les propriétés facultatives, ce qui facilite la gestion des configurations partielles.
Structures de données chaînées
Les types récursifs peuvent représenter des structures de données chaînées telles que les listes chaînées.
Exemple
interface ListNode<T> {
value: T; // Valeur du nœud actuel
next?: ListNode<T>; // Nœud suivant, référence récursive
}
// Créer une liste chaînée
const linkedList: ListNode<number> = {
value: 1,
next: {
value: 2,
next: {
value: 3,
next: {
value: 4,
next: undefined
}
}
}
};
// Parcourir la liste chaînée
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("Valeurs de la liste chaînée : " + values.join(" -> "));
}
traverseList(linkedList);
// Calculer la longueur de la liste chaînée
function getLength<T>(node: ListNode<T>): number {
let length = 0;
let current: ListNode<T> | undefined = node;
while (current) {
longueur++;
current = current.next;
}
return length;
}
console.log("Longueur de la liste chaînée : " + getLength(linkedList));
Liste chaînée :ListNode
En se référençant lui-même via next, il forme une structure chaînée, ce qui est une application classique des types récursifs.
Types d'union récursifs
Utilisez des types récursifs pour gérer les types d'union dans les données JSON.
Type JSON :Les types récursifs peuvent exprimer précisément tous les types possibles de JSON.
Exemple
type JSONValue = string | number | boolean | null | JSONValue[] | { [key: string]: JSONValue };
// Définir un objet de configuration
const config: JSONValue = {
"name": "my-app",
"version": "1.0.0",
"enabled": true,
"settings": {
"debug": false,
"ports": [3000, 8080],
"metadata": {
"author": "Alice",
"tags": ["web", "typescript"]
}
}
};
// Fonction pour obtenir une valeur 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 = (as { [key: string]: JSONValue })[key];
} else {
return current;
}
}
return current;
}
console.log("Version: " + getValue⟧(config, "version"));
console.log("Port: " + getValue⟧(config, "settings.ports"));
console.log("Auteur: " + getValue(config, "settings.metadata.author"));
Notes
- Cas de base récursif:Assurez-vous que les types ont une condition de terminaison pour éviter une récursion infinie.
- Types conditionnels:La récursion est souvent utilisée en combinaison avec des types conditionnels.
- Limite de profondeur:Le compilateur TypeScript a une limite sur la profondeur de récursion.
- Considérations de performance:Une récursion profonde peut affecter la vérification des types.
Bonnes pratiques :Les types récursifs sont un outil puissant pour gérer les données arborescentes et imbriquées. Les maîtriser peut résoudre de nombreux problèmes de types complexes.
Résumé
Les types récursifs sont une fonctionnalité avancée du système de types TypeScript.
- Auto-référence :Référence à soi-même dans la définition du type.
- Structure arborescente :Exprimer des données infiniment imbriquées.
- Transformation profonde :Implémentation de types utilitaires tels que DeepReadonly et DeepPartial.
- Structures chaînées :Représenter des structures récursives linéaires telles que les listes chaînées.
Autres extensionsSuggestion :Lorsque vous manipulez des données imbriquées, privilégiez l'utilisation de types récursifs pour garantir la sécurité des types.