Recorrido del AST con visitors
Recorra los nodos del árbol sintáctico para analizar la estructura del código.
Recorrido del AST con visitors es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de TypeScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de TypeScript Academy incluye 4 lecciones en total.
¿Qué es el AST?
TypeScript analiza el código fuente y lo convierte en un árbol de sintaxis abstracta (AST): un árbol de nodos que representan construcciones del lenguaje, como variables, funciones y expresiones.
import ts from "typescript";
const sf = ts.createSourceFile(
"example.ts",
"const x = 1;",
ts.ScriptTarget.Latest
);Tipos de nodos
Cada nodo del AST tiene una propiedad kind —un valor del enum ts.SyntaxKind— que indica qué representa.
import ts from "typescript";
// Common kinds:
// ts.SyntaxKind.VariableDeclaration
// ts.SyntaxKind.FunctionDeclaration
// ts.SyntaxKind.IdentifierRecorrido con forEachChild
ts.forEachChild(node, visitor) llama a su visitor para cada hijo directo de un nodo. Use la recursión para recorrer el árbol completo.
function visit(node: ts.Node) {
if (ts.isFunctionDeclaration(node)) {
console.log("Function:", node.name?.text);
}
ts.forEachChild(node, visit);
}
visit(sourceFile);Funciones de comprobación de tipos
TypeScript proporciona funciones de comprobación de tipos como ts.isVariableDeclaration y ts.isFunctionDeclaration para restringir nodos de forma segura.
ts.forEachChild(sf, node => {
if (ts.isClassDeclaration(node)) {
console.log("Class:", node.name?.getText());
}
if (ts.isInterfaceDeclaration(node)) {
console.log("Interface:", node.name.getText());
}
});Obtención del texto de un nodo
Use node.getText(sourceFile) para recuperar el texto exacto del código fuente de un nodo o node.getFullText() para incluir la información auxiliar.
ts.forEachChild(sf, node => {
if (ts.isIdentifier(node)) {
console.log("Id:", node.text);
}
});Posiciones de los nodos
Cada nodo tiene las posiciones pos y end —desplazamientos de caracteres— que puede usar para localizar nodos en el código fuente.
ts.forEachChild(sf, node => {
console.log(node.kind, "at", node.pos, "-", node.end);
});Recorrido con un auxiliar recursivo
Una utilidad común es una función walk que aplica recursivamente un visitante a cada nodo del árbol.
function walk(node: ts.Node, visitor: (n: ts.Node) => void) {
visitor(node);
ts.forEachChild(node, child => walk(child, visitor));
}Encontrar todas las llamadas a funciones
Use un recorrido recursivo para encontrar todas las expresiones de llamada en un archivo fuente, lo que resulta útil para detectar el uso de API.
walk(sf, node => {
if (ts.isCallExpression(node)) {
const expr = node.expression.getText(sf);
console.log("Call:", expr);
}
});Acceder a los nodos padre
Los nodos del AST no tienen un puntero al nodo padre de forma predeterminada. Llame a ts.setParent(sourceFile) o use program.getSourceFile, que establece los padres automáticamente en los programas.
// For manually created source files:
// (ts as any).setParents(sf);Usar TypeChecker con nodos
Combine el recorrido del AST con el comprobador de tipos para resolver el tipo de TypeScript de cualquier nodo de expresión.
const checker = program.getTypeChecker();
walk(sf, node => {
if (ts.isExpression(node)) {
const type = checker.getTypeAtLocation(node);
console.log(checker.typeToString(type));
}
});Resumen: recorrido del AST
Recorra el AST de TypeScript con forEachChild y funciones de comprobación de tipos. Combínelo con el comprobador de tipos para crear herramientas potentes de análisis estático y generación de código.
Comprobación rápida
¿Qué función visita recursivamente los nodos secundarios del AST de TypeScript?
Lo que ha aprendido
El recorrido del AST utiliza ts.forEachChild junto con funciones de comprobación de tipos para recorrer e inspeccionar cada nodo de un archivo TypeScript. Combinado con el comprobador de tipos, permite crear linters, analizadores de código y herramientas de refactorización.
Preguntas frecuentes
¿La lección «Recorrido del AST con visitors» es gratis?
Sí — el texto completo de «Recorrido del AST con visitors» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de TypeScript Academy, actualiza a CoddyKit PRO. El curso de TypeScript Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Recorrido del AST con visitors»?
Recorra los nodos del árbol sintáctico para analizar la estructura del código. Practicas TypeScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar TypeScript Academy?
No se requiere experiencia previa. TypeScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «Recorrido del AST con visitors»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de TypeScript Academy?
Sí. Cada lección de TypeScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Creación de un programa de TypeScript con la API
- Recorrido del AST con visitors
- Transformadores personalizados y generación de código
- Creación de una herramienta de linting sencilla