TypeScript Academy · Lekcja

Przechodzenie po AST za pomocą odwiedzających

Przechodź po węzłach drzewa składni, aby analizować strukturę kodu.

Przechodzenie po AST za pomocą odwiedzających to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej TypeScript Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs TypeScript Academy zawiera 4 lekcji w sumie.

Czym jest AST?

TypeScript analizuje kod źródłowy i tworzy abstrakcyjne drzewo składniowe (AST) — drzewo węzłów reprezentujących konstrukcje języka, takie jak zmienne, funkcje i wyrażenia.

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

Rodzaje węzłów

Każdy węzeł AST ma właściwość kind — wartość enuma ts.SyntaxKind — wskazującą, co reprezentuje.

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

Odwiedzanie za pomocą forEachChild

ts.forEachChild(node, visitor) wywołuje visitor dla każdego bezpośredniego elementu podrzędnego węzła. Użyj rekurencji, aby przejść przez całe drzewo.

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

Funkcje ochrony typów

TypeScript udostępnia funkcje ochrony typów, takie jak ts.isVariableDeclaration i ts.isFunctionDeclaration, umożliwiające bezpieczne zawężanie typów węzłów.

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

Pobieranie tekstu węzła

Użyj node.getText(sourceFile), aby pobrać dokładny tekst źródłowy węzła, lub node.getFullText(), aby uwzględnić także elementy pomocnicze.

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

Pozycje węzłów

Każdy węzeł ma pozycje pos i end — przesunięcia znakowe — których można użyć do zlokalizowania węzłów w kodzie źródłowym.

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

Przechodzenie za pomocą pomocniczej funkcji rekurencyjnej

Często używanym narzędziem pomocniczym jest funkcja walk, która rekurencyjnie stosuje funkcję visitor do każdego węzła drzewa.

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

Znajdowanie wszystkich wywołań funkcji

Użyj rekurencyjnego przechodzenia po drzewie, aby znaleźć wszystkie wyrażenia wywołań w pliku źródłowym — jest to przydatne do wykrywania użycia API.

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

Uzyskiwanie dostępu do węzłów nadrzędnych

Węzły AST domyślnie nie mają wskaźnika do węzła nadrzędnego. Wywołaj ts.setParent(sourceFile) albo użyj program.getSourceFile, które automatycznie ustawia węzły nadrzędne dla programów.

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

Używanie TypeChecker z węzłami

Połącz przechodzenie po AST ze sprawdzarką typów, aby określić typ TypeScript dowolnego węzła reprezentującego wyrażenie.

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

Podsumowanie: przechodzenie po AST

Przechodź po AST TypeScriptu za pomocą forEachChild i funkcji sprawdzających typ. Połącz je ze sprawdzarką typów, aby tworzyć zaawansowane narzędzia do analizy statycznej i generowania kodu.

Szybkie sprawdzenie

Która funkcja rekurencyjnie odwiedza węzły potomne w AST TypeScriptu?

Czego się Państwo nauczyli

Przechodzenie po AST wykorzystuje ts.forEachChild oraz funkcje sprawdzające typ, aby przejść przez każdy węzeł pliku TypeScriptu i go zbadać. W połączeniu ze sprawdzarką typów umożliwia tworzenie linterów, analizatorów kodu i narzędzi do refaktoryzacji.

Często zadawane pytania

Czy lekcja „Przechodzenie po AST za pomocą odwiedzających” jest bezpłatna?

Tak — pełny tekst „Przechodzenie po AST za pomocą odwiedzających” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu TypeScript Academy, przejdź na CoddyKit PRO. Kurs TypeScript Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Przechodzenie po AST za pomocą odwiedzających”?

Przechodź po węzłach drzewa składni, aby analizować strukturę kodu. Ćwiczysz TypeScript Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć TypeScript Academy?

Nie wymagamy żadnego doświadczenia. TypeScript Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Przechodzenie po AST za pomocą odwiedzających”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji TypeScript Academy?

Tak. Każda lekcja TypeScript Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Tworzenie programu TypeScript za pomocą API
Przechodzenie po AST za pomocą odwiedzających
Niestandardowe transformatory i generowanie kodu
Budowanie prostego narzędzia do lintowania

← Powrót do TypeScript Academy