TypeScript Academy · Leçon

Typer des structures arborescentes

Modéliser des nœuds d’arbre imbriqués avec des types récursifs.

Typer des structures arborescentes est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 4 leçons au total.

Un type de nœud d’arbre

Les arbres généralisent les listes : chaque nœud possède une valeur et un tableau de nœuds child du même type. Il s’agit d’un type récursif avec un tableau children.

type TreeNode<T> = {
  value: T;
  children: TreeNode<T>[];
};
const leaf: TreeNode<number> = { value: 1, children: [] };
console.log(leaf.value);

Construire un petit arbre

Un nœud avec des enfants n’est qu’un ensemble d’objets imbriqués. Le tableau vide est le cas de base naturel pour une leaf.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
const tree: TreeNode<string> = {
  value: "root",
  children: [
    { value: "a", children: [] },
    { value: "b", children: [] }
  ]
};
console.log(tree.children.length);

Ajouter des niveaux d’imbrication

Les enfants peuvent avoir leurs propres enfants à n’importe quelle profondeur, car chaque child est lui-même un TreeNode complet.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
const tree: TreeNode<number> = {
  value: 1,
  children: [
    { value: 2, children: [{ value: 4, children: [] }] },
    { value: 3, children: [] }
  ]
};
console.log(tree.children[0].children[0].value);

Additionner toutes les valeurs

Une fonction récursive visite chaque nœud et descend récursivement dans ses enfants, en accumulant un résultat : il s’agit d’un parcours en profondeur.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function sum(node: TreeNode<number>): number {
  let total = node.value;
  for (const child of node.children) total += sum(child);
  return total;
}
const t: TreeNode<number> = { value: 1, children: [{ value: 2, children: [] }, { value: 3, children: [] }] };
console.log(sum(t));

Compter les nœuds

La même structure de parcours permet de compter les nœuds : un pour le nœud actuel, plus les nombres de nœuds de tous les sous-arbres.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function count<T>(node: TreeNode<T>): number {
  return 1 + node.children.reduce((acc, c) => acc + count(c), 0);
}
const t: TreeNode<string> = { value: "r", children: [{ value: "a", children: [] }] };
console.log(count(t));

Trouver la profondeur maximale

La profondeur vaut un de plus que la profondeur maximale parmi les enfants, ou un pour une feuille sans enfant.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function depth<T>(node: TreeNode<T>): number {
  if (node.children.length === 0) return 1;
  return 1 + Math.max(...node.children.map(depth));
}
const t: TreeNode<number> = { value: 1, children: [{ value: 2, children: [{ value: 3, children: [] }] }] };
console.log(depth(t));

Rassembler toutes les valeurs

Aplatissez un arbre en tableau en concaténant la valeur actuelle avec les enfants aplatis.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function flatten<T>(node: TreeNode<T>): T[] {
  return [node.value, ...node.children.flatMap(flatten)];
}
const t: TreeNode<number> = { value: 1, children: [{ value: 2, children: [] }, { value: 3, children: [] }] };
console.log(flatten(t));

Rechercher dans l’arbre

Une recherche récursive renvoie le premier nœud correspondant à un prédicat et explore les enfants lorsque le nœud actuel ne correspond pas.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function find<T>(node: TreeNode<T>, pred: (v: T) => boolean): TreeNode<T> | null {
  if (pred(node.value)) return node;
  for (const c of node.children) {
    const hit = find(c, pred);
    if (hit) return hit;
  }
  return null;
}
const t: TreeNode<number> = { value: 1, children: [{ value: 5, children: [] }] };
console.log(find(t, v => v === 5)?.value);

Mapper un arbre

Transformez chaque valeur tout en conservant la structure, en mappant récursivement la valeur et les enfants.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function mapTree<T, U>(node: TreeNode<T>, fn: (v: T) => U): TreeNode<U> {
  return { value: fn(node.value), children: node.children.map(c => mapTree(c, fn)) };
}
const t: TreeNode<number> = { value: 1, children: [{ value: 2, children: [] }] };
console.log(mapTree(t, x => x * 100).value);

Les arbres modélisent des données réelles

Les systèmes de fichiers, les arbres DOM, les organigrammes et les arbres syntaxiques abstraits sont tous des arbres. Un seul type récursif permet de tous les décrire avec une sécurité de typage complète.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
type FileTree = TreeNode<string>;
const fs: FileTree = { value: "/", children: [{ value: "home", children: [] }] };
console.log(fs.value, fs.children[0].value);

Feuilles et branches

Un nœud est une feuille lorsque children est vide, et une branche dans le cas contraire. Cette distinction détermine souvent la logique de parcours.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function isLeaf<T>(node: TreeNode<T>): boolean {
  return node.children.length === 0;
}
console.log(isLeaf({ value: 1, children: [] }));

Vérification rapide : structures arborescentes

Vérifiez votre compréhension du typage des structures arborescentes.

Récapitulatif : typer les structures arborescentes

Vous avez modélisé les arbres avec TreeNode<T>, où chaque nœud possède une valeur et un tableau de nœuds enfants, puis écrit des fonctions récursives pour les additionner, les compter, les rechercher et les mapper.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
const t: TreeNode<number> = { value: 1, children: [{ value: 2, children: [] }] };
console.log(t.children[0].value);

Questions Fréquemment Posées

La leçon « Typer des structures arborescentes » est-elle gratuite ?

Oui — le texte complet de « Typer des structures arborescentes » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Typer des structures arborescentes » ?

Modéliser des nœuds d’arbre imbriqués avec des types récursifs. Tu pratiques TypeScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer TypeScript Academy ?

Aucune expérience préalable n'est requise. TypeScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Typer des structures arborescentes » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon TypeScript Academy ?

Oui. Chaque leçon TypeScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à TypeScript Academy