TypeScript Academy · Leçon

Parcourir l’AST avec des visiteurs

Parcourez les nœuds de l’arbre syntaxique pour analyser la structure du code

Leçon 2 sur 413 étapes

Parcourir l’AST avec des visiteurs 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.

Qu’est-ce que l’AST ?

TypeScript analyse le code source pour produire un arbre syntaxique abstrait (AST), c’est-à-dire un arbre de nœuds représentant des constructions du langage telles que les variables, les fonctions et les expressions.

import ts from "typescript";
const sf = ts.createSourceFile(
  "example.ts",
  "const x = 1;",
  ts.ScriptTarget.Latest
);

Types de nœuds

Chaque nœud de l’AST possède une propriété kind, une valeur d’énumération ts.SyntaxKind, qui indique ce qu’il représente.

import ts from "typescript";
// Common kinds:
// ts.SyntaxKind.VariableDeclaration
// ts.SyntaxKind.FunctionDeclaration
// ts.SyntaxKind.Identifier

Parcourir avec forEachChild

ts.forEachChild(node, visitor) appelle votre visiteur pour chaque enfant direct d’un nœud. Utilisez la récursion pour parcourir l’arbre entier.

function visit(node: ts.Node) {
  if (ts.isFunctionDeclaration(node)) {
    console.log("Function:", node.name?.text);
  }
  ts.forEachChild(node, visit);
}
visit(sourceFile);

Fonctions de garde de type

TypeScript fournit des fonctions de garde de type telles que ts.isVariableDeclaration et ts.isFunctionDeclaration pour restreindre les types de nœuds en toute sécurité.

ts.forEachChild(sf, node => {
  if (ts.isClassDeclaration(node)) {
    console.log("Class:", node.name?.getText());
  }
  if (ts.isInterfaceDeclaration(node)) {
    console.log("Interface:", node.name.getText());
  }
});

Obtenir le texte d’un nœud

Utilisez node.getText(sourceFile) pour récupérer le texte source exact d’un nœud, ou node.getFullText() pour y inclure les éléments triviaux.

ts.forEachChild(sf, node => {
  if (ts.isIdentifier(node)) {
    console.log("Id:", node.text);
  }
});

Positions des nœuds

Chaque nœud possède des positions pos et end, qui correspondent à des décalages de caractères utilisables pour localiser les nœuds dans le code source.

ts.forEachChild(sf, node => {
  console.log(node.kind, "at", node.pos, "-", node.end);
});

Parcourir avec une fonction auxiliaire récursive

Une fonction utilitaire courante est une fonction walk qui applique récursivement un visiteur à chaque nœud de l’arbre.

function walk(node: ts.Node, visitor: (n: ts.Node) => void) {
  visitor(node);
  ts.forEachChild(node, child => walk(child, visitor));
}

Recherche de tous les appels de fonction

Utilisez une fonction de parcours récursive pour trouver toutes les expressions d’appel dans un fichier source — ce qui est utile pour détecter l’utilisation d’une API.

walk(sf, node => {
  if (ts.isCallExpression(node)) {
    const expr = node.expression.getText(sf);
    console.log("Call:", expr);
  }
});

Accès aux nœuds parents

Les nœuds AST n’ont pas de pointeur vers leur parent par défaut. Appelez ts.setParent(sourceFile) ou utilisez program.getSourceFile, qui définit automatiquement les parents pour les programmes.

// For manually created source files:
// (ts as any).setParents(sf);

Utilisation du TypeChecker avec les nœuds

Combinez le parcours de l’AST avec le vérificateur de types afin de déterminer le type TypeScript de n’importe quel nœud d’expression.

const checker = program.getTypeChecker();
walk(sf, node => {
  if (ts.isExpression(node)) {
    const type = checker.getTypeAtLocation(node);
    console.log(checker.typeToString(type));
  }
});

Récapitulatif : parcours de l’AST

Parcourez l’AST TypeScript avec forEachChild et des fonctions de garde de type. Combinez cette approche avec le vérificateur de types pour créer de puissants outils d’analyse statique et de génération de code.

Vérification rapide

Quelle fonction visite récursivement les nœuds enfants de l’AST TypeScript ?

Réponds-y dans la leçon interactive

Ce que vous avez appris

Le parcours de l’AST utilise ts.forEachChild ainsi que des fonctions de garde de type pour parcourir et inspecter chaque nœud d’un fichier TypeScript. Associé au vérificateur de types, il permet de créer des outils d’analyse de code, d’analyse des programmes et de refactorisation.

Gratuit pour commencer

Apprends TypeScript avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 101
Leçons: 352

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Parcourir l’AST avec des visiteurs » est-elle gratuite ?

Oui — le texte complet de « Parcourir l’AST avec des visiteurs » 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 « Parcourir l’AST avec des visiteurs » ?

Parcourez les nœuds de l’arbre syntaxique pour analyser la structure du code 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 « Parcourir l’AST avec des visiteurs » ?

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

Créer un programme TypeScript avec l’API
Parcourir l’AST avec des visiteurs
Transformateurs personnalisés et génération de code
Créer un outil simple d’analyse statique

← Retour à TypeScript Academy