0Pricing
TypeScript Academy · บทเรียน

การท่องผ่าน AST ด้วยตัวเยี่ยมชม

เดินผ่านโหนดต้นไม้ไวยากรณ์เพื่อวิเคราะห์โครงสร้างโค้ด

การท่องผ่าน AST ด้วยตัวเยี่ยมชม เป็นบทเรียน TypeScript Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน TypeScript Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส TypeScript Academy มีบทเรียนทั้งหมด 4 บทเรียน

AST คืออะไร

TypeScript แยกวิเคราะห์โค้ดต้นฉบับเป็นต้นไม้นิพจน์นามธรรม (AST) ซึ่งเป็นต้นไม้ของโหนดที่แทนโครงสร้างภาษา เช่น ตัวแปร ฟังก์ชัน และนิพจน์

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

ชนิดของโหนด

โหนด AST ทุกโหนดมีคุณสมบัติ kind ซึ่งเป็นค่า enum ของ ts.SyntaxKind ที่ระบุว่าโหนดนั้นแทนสิ่งใด

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

การเยี่ยมชมด้วย forEachChild

ts.forEachChild(node, visitor) เรียก visitor ของคุณสำหรับลูกโดยตรงแต่ละตัวของโหนด ใช้การเวียนเกิดเพื่อเดินสำรวจต้นไม้ทั้งหมด

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

ฟังก์ชันตรวจสอบชนิดข้อมูล

TypeScript มีฟังก์ชันตรวจสอบชนิดข้อมูล เช่น ts.isVariableDeclaration และ ts.isFunctionDeclaration เพื่อทำให้ชนิดข้อมูลของโหนดแคบลงอย่างปลอดภัย

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

การรับข้อความของโหนด

ใช้ node.getText(sourceFile) เพื่อรับข้อความต้นฉบับที่ตรงกันทุกประการของโหนด หรือใช้ node.getFullText() เพื่อรวมอักขระประกอบด้วย

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

ตำแหน่งของโหนด

โหนดทุกโหนดมีตำแหน่ง pos และ end ซึ่งเป็นออฟเซ็ตอักขระที่คุณใช้ระบุตำแหน่งโหนดในต้นฉบับได้

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

การเดินสำรวจด้วยตัวช่วยแบบเวียนเกิด

ยูทิลิตีที่ใช้กันทั่วไปคือฟังก์ชัน walk ซึ่งนำตัวเยี่ยมชมไปใช้กับทุกโหนดในต้นไม้แบบเรียกซ้ำ

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

ค้นหาการเรียกฟังก์ชันทั้งหมด

ใช้การเดินสำรวจแบบเรียกซ้ำเพื่อค้นหานิพจน์การเรียกทั้งหมดในไฟล์ต้นฉบับ ซึ่งมีประโยชน์สำหรับตรวจจับการใช้งานส่วนติดต่อการเขียนโปรแกรมประยุกต์

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

การเข้าถึงโหนดแม่

โหนด AST ไม่มีตัวชี้ไปยังโหนดแม่มาให้โดยค่าเริ่มต้น ให้เรียก ts.setParent(sourceFile) หรือใช้ program.getSourceFile ซึ่งจะตั้งค่าโหนดแม่โดยอัตโนมัติสำหรับ program

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

การใช้ TypeChecker กับโหนด

ผสานการสำรวจ AST กับตัวตรวจสอบชนิดเพื่อระบุชนิด TypeScript ของโหนดนิพจน์ใด ๆ

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

ทบทวน: การสำรวจ AST

สำรวจ AST ของ TypeScript ด้วย forEachChild และฟังก์ชันตรวจสอบชนิด ผสานการทำงานกับตัวตรวจสอบชนิดเพื่อสร้างเครื่องมือวิเคราะห์แบบสถิตและสร้างโค้ดที่ทรงพลัง

ตรวจสอบความเข้าใจ

ฟังก์ชันใดเยี่ยมชมโหนดลูกใน AST ของ TypeScript แบบเรียกซ้ำ

สิ่งที่ได้เรียนรู้

การสำรวจ AST ใช้ ts.forEachChild ร่วมกับฟังก์ชันตรวจสอบชนิดเพื่อเดินสำรวจและตรวจสอบทุกโหนดในไฟล์ TypeScript เมื่อใช้ร่วมกับตัวตรวจสอบชนิด จะช่วยให้สร้างเครื่องมือตรวจสอบโค้ด เครื่องมือวิเคราะห์โค้ด และเครื่องมือปรับโครงสร้างโค้ดได้

คำถามที่พบบ่อย

บทเรียน “การท่องผ่าน AST ด้วยตัวเยี่ยมชม” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การท่องผ่าน AST ด้วยตัวเยี่ยมชม” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส TypeScript Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส TypeScript Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การท่องผ่าน AST ด้วยตัวเยี่ยมชม”

เดินผ่านโหนดต้นไม้ไวยากรณ์เพื่อวิเคราะห์โครงสร้างโค้ด คุณปฏิบัติ TypeScript Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน TypeScript Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน TypeScript Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน

บทเรียน “การท่องผ่าน AST ด้วยตัวเยี่ยมชม” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน TypeScript Academy นี้ได้ไหม

ได้ บทเรียน TypeScript Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. การสร้างโปรแกรม TypeScript ด้วย API
  2. การท่องผ่าน AST ด้วยตัวเยี่ยมชม
  3. ตัวแปลงแบบกำหนดเองและการสร้างโค้ด
  4. การสร้างเครื่องมือตรวจสอบโค้ดอย่างง่าย
← กลับไปที่ TypeScript Academy