Attraversamento dell'AST con i visitor
Esplori i nodi dell'albero sintattico per analizzare la struttura del codice.
Attraversamento dell'AST con i visitor è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 4 lezioni in totale.
Che cos'è l'AST?
TypeScript analizza il codice sorgente trasformandolo in un Abstract Syntax Tree (AST), un albero di nodi che rappresentano costrutti del linguaggio come variabili, funzioni ed espressioni.
import ts from "typescript";
const sf = ts.createSourceFile(
"example.ts",
"const x = 1;",
ts.ScriptTarget.Latest
);Tipi di nodo
Ogni nodo dell'AST ha una proprietà kind, ovvero un valore dell'enum ts.SyntaxKind, che indica cosa rappresenta.
import ts from "typescript";
// Common kinds:
// ts.SyntaxKind.VariableDeclaration
// ts.SyntaxKind.FunctionDeclaration
// ts.SyntaxKind.IdentifierVisita con forEachChild
ts.forEachChild(node, visitor) chiama il visitor per ogni figlio diretto di un nodo. Utilizzi la ricorsione per attraversare l'intero albero.
function visit(node: ts.Node) {
if (ts.isFunctionDeclaration(node)) {
console.log("Function:", node.name?.text);
}
ts.forEachChild(node, visit);
}
visit(sourceFile);Funzioni type guard
TypeScript fornisce funzioni type guard come ts.isVariableDeclaration e ts.isFunctionDeclaration per restringere i tipi dei nodi in modo sicuro.
ts.forEachChild(sf, node => {
if (ts.isClassDeclaration(node)) {
console.log("Class:", node.name?.getText());
}
if (ts.isInterfaceDeclaration(node)) {
console.log("Interface:", node.name.getText());
}
});Ottenere il testo di un nodo
Utilizzi node.getText(sourceFile) per recuperare il testo sorgente esatto di un nodo oppure node.getFullText() per includere anche il testo accessorio.
ts.forEachChild(sf, node => {
if (ts.isIdentifier(node)) {
console.log("Id:", node.text);
}
});Posizioni dei nodi
Ogni nodo ha le posizioni pos e end, ovvero offset di caratteri che è possibile utilizzare per localizzare i nodi nel sorgente.
ts.forEachChild(sf, node => {
console.log(node.kind, "at", node.pos, "-", node.end);
});Attraversamento con una funzione di supporto ricorsiva
Un'utilità comune è una funzione walk che applica ricorsivamente un visitor a ogni nodo dell'albero.
function walk(node: ts.Node, visitor: (n: ts.Node) => void) {
visitor(node);
ts.forEachChild(node, child => walk(child, visitor));
}Individuazione di tutte le chiamate di funzione
Utilizzi una visita ricorsiva per trovare tutte le espressioni di chiamata in un file sorgente, utile per rilevare l'uso delle API.
walk(sf, node => {
if (ts.isCallExpression(node)) {
const expr = node.expression.getText(sf);
console.log("Call:", expr);
}
});Accesso ai nodi padre
I nodi AST non hanno un puntatore al nodo padre per impostazione predefinita. Chiami ts.setParent(sourceFile) oppure utilizzi program.getSourceFile, che imposta automaticamente i nodi padre per i programmi.
// For manually created source files:
// (ts as any).setParents(sf);Utilizzo di TypeChecker con i nodi
Combini l'attraversamento dell'AST con il type checker per determinare il tipo TypeScript di qualsiasi nodo espressione.
const checker = program.getTypeChecker();
walk(sf, node => {
if (ts.isExpression(node)) {
const type = checker.getTypeAtLocation(node);
console.log(checker.typeToString(type));
}
});Riepilogo: attraversamento dell'AST
Attraversi l'AST di TypeScript con forEachChild e funzioni di type guard. Lo combini con il type checker per creare potenti strumenti di analisi statica e generazione del codice.
Verifica rapida
Quale funzione visita ricorsivamente i nodi figlio nell'AST di TypeScript?
Cosa ha imparato
L'attraversamento dell'AST utilizza ts.forEachChild insieme alle funzioni di type guard per visitare e analizzare ogni nodo di un file TypeScript. In combinazione con il type checker, consente di creare linter, analizzatori di codice e strumenti di refactoring.
Domande Frequenti
La lezione «Attraversamento dell'AST con i visitor» è gratuita?
Sì — il testo completo di «Attraversamento dell'AST con i visitor» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 4 lezioni in totale.
Cosa imparerò in «Attraversamento dell'AST con i visitor»?
Esplori i nodi dell'albero sintattico per analizzare la struttura del codice. Eserciti TypeScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare TypeScript Academy?
Non è richiesta alcuna esperienza precedente. TypeScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «Attraversamento dell'AST con i visitor»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione TypeScript Academy?
Sì. Ogni lezione TypeScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Creazione di un programma TypeScript con l'API
- Attraversamento dell'AST con i visitor
- Transformer personalizzati e generazione del codice
- Creazione di un semplice strumento di linting