టైప్‌స్క్రిప్ట్ కంపైలర్ APIకి ఒక సమగ్ర గైడ్. ఇందులో అబ్స్ట్రాక్ట్ సింటాక్స్ ట్రీస్ (AST), కోడ్ విశ్లేషణ, రూపాంతరం, మరియు జనరేషన్ గురించి వివరించబడింది.
టైప్‌స్క్రిప్ట్ కంపైలర్ API: AST మానిప్యులేషన్ మరియు కోడ్ ట్రాన్స్‌ఫర్మేషన్‌లో నైపుణ్యం
టైప్‌స్క్రిప్ట్ కంపైలర్ API, టైప్‌స్క్రిప్ట్ మరియు జావాస్క్రిప్ట్ కోడ్‌ను విశ్లేషించడానికి, మార్చడానికి మరియు ఉత్పత్తి చేయడానికి ఒక శక్తివంతమైన ఇంటర్‌ఫేస్‌ను అందిస్తుంది. దీనికి మూలం అబ్స్ట్రాక్ట్ సింటాక్స్ ట్రీ (AST), ఇది మీ సోర్స్ కోడ్ యొక్క ఒక నిర్మాణాత్మక ప్రాతినిధ్యం. ASTతో ఎలా పనిచేయాలో అర్థం చేసుకోవడం ద్వారా లింటర్‌లు, కోడ్ ఫార్మాటర్‌లు, స్టాటిక్ ఎనలైజర్‌లు మరియు కస్టమ్ కోడ్ జనరేటర్‌ల వంటి అధునాతన టూలింగ్‌ను నిర్మించే సామర్థ్యాలను అన్‌లాక్ చేస్తుంది.
టైప్‌స్క్రిప్ట్ కంపైలర్ API అంటే ఏమిటి?
టైప్‌స్క్రిప్ట్ కంపైలర్ API అనేది టైప్‌స్క్రిప్ట్ కంపైలర్ యొక్క అంతర్గత పనితీరును వెల్లడించే టైప్‌స్క్రిప్ట్ ఇంటర్‌ఫేస్‌లు మరియు ఫంక్షన్‌ల సమితి. ఇది డెవలపర్‌లను కేవలం కోడ్‌ను కంపైల్ చేయడం కంటే ఎక్కువగా, ప్రోగ్రామాటిక్‌గా కంపైలేషన్ ప్రక్రియతో సంప్రదించడానికి అనుమతిస్తుంది. మీరు దీనిని ఉపయోగించి:
- కోడ్‌ను విశ్లేషించడం: కోడ్ నిర్మాణాన్ని పరిశీలించడం, సంభావ్య సమస్యలను గుర్తించడం, మరియు సెమాంటిక్ సమాచారాన్ని సంగ్రహించడం.
- కోడ్‌ను రూపాంతరం చేయడం: ఇప్పటికే ఉన్న కోడ్‌ను సవరించడం, కొత్త ఫీచర్లను జోడించడం, లేదా కోడ్‌ను స్వయంచాలకంగా రీఫాక్టర్ చేయడం.
- కోడ్‌ను ఉత్పత్తి చేయడం: టెంప్లేట్‌లు లేదా ఇతర ఇన్‌పుట్ ఆధారంగా కొత్త కోడ్‌ను మొదటి నుండి సృష్టించడం.
ఈ API, కోడ్ నాణ్యతను మెరుగుపరిచే, పునరావృతమయ్యే పనులను ఆటోమేట్ చేసే మరియు డెవలపర్ ఉత్పాదకతను పెంచే అధునాతన డెవలప్‌మెంట్ టూల్స్ నిర్మించడానికి అవసరం.
అబ్స్ట్రాక్ట్ సింటాక్స్ ట్రీ (AST)ని అర్థం చేసుకోవడం
AST అనేది మీ కోడ్ నిర్మాణం యొక్క ఒక ట్రీ-లాంటి ప్రాతినిధ్యం. ట్రీలోని ప్రతి నోడ్ వేరియబుల్ డిక్లరేషన్, ఫంక్షన్ కాల్, లేదా కంట్రోల్ ఫ్లో స్టేట్‌మెంట్ వంటి ఒక వాక్యనిర్మాణాన్ని సూచిస్తుంది. టైప్‌స్క్రిప్ట్ కంపైలర్ API, ASTని ట్రావెర్స్ చేయడానికి, దాని నోడ్‌లను పరిశీలించడానికి మరియు వాటిని సవరించడానికి టూల్స్ అందిస్తుంది.
ఈ సరళమైన టైప్‌స్క్రిప్ట్ కోడ్‌ను పరిగణించండి:
function greet(name: string): string {
return `Hello, ${name}!`;
}
console.log(greet("World"));
ఈ కోడ్ కోసం AST ఫంక్షన్ డిక్లరేషన్, రిటర్న్ స్టేట్‌మెంట్, టెంప్లేట్ లిటరల్, console.log కాల్ మరియు కోడ్‌లోని ఇతర అంశాలను సూచిస్తుంది. ASTని విజువలైజ్ చేయడం సవాలుగా ఉంటుంది, కానీ AST ఎక్స్‌ప్లోరర్ (astexplorer.net) వంటి టూల్స్ సహాయపడతాయి. ఈ టూల్స్ మీరు కోడ్‌ను ఎంటర్ చేసి దాని సంబంధిత ASTని యూజర్-ఫ్రెండ్లీ ఫార్మాట్‌లో చూడటానికి అనుమతిస్తాయి. AST ఎక్స్‌ప్లోరర్ ఉపయోగించడం వల్ల మీరు ఎలాంటి కోడ్ నిర్మాణాన్ని మార్చబోతున్నారో అర్థం చేసుకోవడంలో సహాయపడుతుంది.
కీలకమైన AST నోడ్ రకాలు
టైప్‌స్క్రిప్ట్ కంపైలర్ API వివిధ AST నోడ్ రకాలను నిర్వచిస్తుంది, ప్రతి ఒక్కటి వేరే వాక్యనిర్మాణాన్ని సూచిస్తుంది. ఇక్కడ కొన్ని సాధారణ నోడ్ రకాలు ఉన్నాయి:
- SourceFile: ఒక పూర్తి టైప్‌స్క్రిప్ట్ ఫైల్‌ను సూచిస్తుంది.
- FunctionDeclaration: ఒక ఫంక్షన్ నిర్వచనాన్ని సూచిస్తుంది.
- VariableDeclaration: ఒక వేరియబుల్ డిక్లరేషన్‌ను సూచిస్తుంది.
- Identifier: ఒక ఐడెంటిఫైయర్‌ను (ఉదా., వేరియబుల్ పేరు, ఫంక్షన్ పేరు) సూచిస్తుంది.
- StringLiteral: ఒక స్ట్రింగ్ లిటరల్‌ను సూచిస్తుంది.
- CallExpression: ఒక ఫంక్షన్ కాల్‌ను సూచిస్తుంది.
- ReturnStatement: ఒక రిటర్న్ స్టేట్‌మెంట్‌ను సూచిస్తుంది.
ప్రతి నోడ్ రకంలో సంబంధిత కోడ్ మూలకం గురించి సమాచారాన్ని అందించే లక్షణాలు ఉంటాయి. ఉదాహరణకు, ఒక `FunctionDeclaration` నోడ్‌కు దాని పేరు, పారామీటర్లు, రిటర్న్ రకం మరియు బాడీ కోసం లక్షణాలు ఉండవచ్చు.
కంపైలర్ APIతో ప్రారంభించడం
కంపైలర్ APIని ఉపయోగించడం ప్రారంభించడానికి, మీరు టైప్‌స్క్రిప్ట్‌ను ఇన్‌స్టాల్ చేయాలి మరియు టైప్‌స్క్రిప్ట్ సింటాక్స్‌పై ప్రాథమిక అవగాహన కలిగి ఉండాలి. ఇక్కడ ఒక టైప్‌స్క్రిప్ట్ ఫైల్‌ను చదివి దాని ASTని ప్రింట్ చేయడం ఎలాగో చూపించే ఒక సరళమైన ఉదాహరణ ఉంది:
import * as ts from "typescript";
import * as fs from "fs";
const fileName = "example.ts";
const sourceCode = fs.readFileSync(fileName, "utf8");
const sourceFile = ts.createSourceFile(
fileName,
sourceCode,
ts.ScriptTarget.ES2015, // లక్ష్య ECMAScript వెర్షన్
true // SetParentNodes: ASTలో పేరెంట్ రిఫరెన్స్‌లను నిలుపుకోవడానికి true
);
function printAST(node: ts.Node, indent = 0) {
const indentStr = " ".repeat(indent);
console.log(`${indentStr}${ts.SyntaxKind[node.kind]}`);
node.forEachChild(child => printAST(child, indent + 1));
}
printAST(sourceFile);
వివరణ:
- మాడ్యూల్స్‌ను ఇంపోర్ట్ చేయడం: ఫైల్ సిస్టమ్ ఆపరేషన్ల కోసం `typescript` మాడ్యూల్ మరియు `fs` మాడ్యూల్‌ను ఇంపోర్ట్ చేస్తుంది.
- సోర్స్ ఫైల్‌ను చదవడం: `example.ts` అనే టైప్‌స్క్రిప్ట్ ఫైల్ కంటెంట్‌ను చదువుతుంది. ఇది పని చేయడానికి మీరు `example.ts` ఫైల్‌ను సృష్టించాలి.
- SourceFile సృష్టించడం: ఒక `SourceFile` ఆబ్జెక్ట్‌ను సృష్టిస్తుంది, ఇది AST యొక్క రూట్‌ను సూచిస్తుంది. `ts.createSourceFile` ఫంక్షన్ సోర్స్ కోడ్‌ను పార్స్ చేసి ASTని ఉత్పత్తి చేస్తుంది.
- ASTని ప్రింట్ చేయడం: ASTని ట్రావెర్స్ చేసి ప్రతి నోడ్ యొక్క రకాన్ని ప్రింట్ చేసే `printAST` అనే రికర్సివ్ ఫంక్షన్‌ను నిర్వచిస్తుంది.
- printASTని కాల్ చేయడం: రూట్ `SourceFile` నోడ్ నుండి ASTని ప్రింట్ చేయడం ప్రారంభించడానికి `printAST`ని కాల్ చేస్తుంది.
ఈ కోడ్‌ను రన్ చేయడానికి, దానిని `.ts` ఫైల్‌గా సేవ్ చేయండి (ఉదా., `ast-example.ts`), కొన్ని టైప్‌స్క్రిప్ట్ కోడ్‌తో `example.ts` ఫైల్‌ను సృష్టించండి, ఆపై కోడ్‌ను కంపైల్ చేసి రన్ చేయండి:
tsc ast-example.ts
node ast-example.js
ఇది మీ `example.ts` ఫైల్ యొక్క ASTని కన్సోల్‌కు ప్రింట్ చేస్తుంది. అవుట్‌పుట్ నోడ్‌ల సోపానక్రమం మరియు వాటి రకాలను చూపుతుంది. ఉదాహరణకు, ఇది `FunctionDeclaration`, `Identifier`, `Block` మరియు ఇతర నోడ్ రకాలను చూపవచ్చు.
ASTని ట్రావెర్స్ చేయడం
కంపైలర్ API ASTని ట్రావెర్స్ చేయడానికి అనేక మార్గాలను అందిస్తుంది. మునుపటి ఉదాహరణలో చూపినట్లుగా, `forEachChild` పద్ధతిని ఉపయోగించడం సరళమైనది. ఈ పద్ధతి ఇచ్చిన నోడ్ యొక్క ప్రతి చైల్డ్ నోడ్‌ను సందర్శిస్తుంది.
మరింత సంక్లిష్టమైన ట్రావెర్సల్ సందర్భాల కోసం, మీరు `Visitor` ప్యాట్రన్‌ను ఉపయోగించవచ్చు. ఒక విజిటర్ అనేది నిర్దిష్ట నోడ్ రకాల కోసం కాల్ చేయబడే పద్ధతులను నిర్వచించే ఒక ఆబ్జెక్ట్. ఇది ట్రావెర్సల్ ప్రక్రియను అనుకూలీకరించడానికి మరియు నోడ్ రకం ఆధారంగా చర్యలను నిర్వహించడానికి మిమ్మల్ని అనుమతిస్తుంది.
import * as ts from "typescript";
import * as fs from "fs";
const fileName = "example.ts";
const sourceCode = fs.readFileSync(fileName, "utf8");
const sourceFile = ts.createSourceFile(
fileName,
sourceCode,
ts.ScriptTarget.ES2015,
true
);
class IdentifierVisitor {
visit(node: ts.Node) {
if (ts.isIdentifier(node)) {
console.log(`Found identifier: ${node.text}`);
}
ts.forEachChild(node, n => this.visit(n));
}
}
const visitor = new IdentifierVisitor();
visitor.visit(sourceFile);
వివరణ:
- IdentifierVisitor క్లాస్: `visit` పద్ధతితో `IdentifierVisitor` అనే క్లాస్‌ను నిర్వచిస్తుంది.
- Visit పద్ధతి: `visit` పద్ధతి ప్రస్తుత నోడ్ ఒక `Identifier` అవునో కాదో తనిఖీ చేస్తుంది. అలా అయితే, అది ఐడెంటిఫైయర్ యొక్క టెక్స్ట్‌ను ప్రింట్ చేస్తుంది. ఆపై చైల్డ్ నోడ్‌లను సందర్శించడానికి `ts.forEachChild`ని రికర్సివ్‌గా కాల్ చేస్తుంది.
- విజిటర్‌ను సృష్టించడం: `IdentifierVisitor` యొక్క ఒక ఉదాహరణను సృష్టిస్తుంది.
- ట్రావెర్సల్ ప్రారంభించడం: ట్రావెర్సల్ ప్రారంభించడానికి `SourceFile`పై `visit` పద్ధతిని కాల్ చేస్తుంది.
ఈ ఉదాహరణ ASTలోని అన్ని ఐడెంటిఫైయర్‌లను ఎలా కనుగొనాలో చూపిస్తుంది. మీరు ఇతర నోడ్ రకాలను కనుగొనడానికి మరియు విభిన్న చర్యలను నిర్వహించడానికి ఈ ప్యాట్రన్‌ను స్వీకరించవచ్చు.
ASTని రూపాంతరం చేయడం
కంపైలర్ API యొక్క నిజమైన శక్తి ASTని రూపాంతరం చేసే సామర్థ్యంలో ఉంది. మీ కోడ్ యొక్క నిర్మాణం మరియు ప్రవర్తనను మార్చడానికి మీరు ASTని సవరించవచ్చు. ఇది కోడ్ రీఫ్యాక్టరింగ్ టూల్స్, కోడ్ జనరేటర్లు మరియు ఇతర అధునాతన టూలింగ్‌కు ఆధారం.
ASTని రూపాంతరం చేయడానికి, మీరు `ts.transform` ఫంక్షన్‌ను ఉపయోగించాలి. ఈ ఫంక్షన్ ఒక `SourceFile` మరియు `TransformerFactory` ఫంక్షన్‌ల జాబితాను తీసుకుంటుంది. `TransformerFactory` అనేది `TransformationContext`ను తీసుకుని `Transformer` ఫంక్షన్‌ను తిరిగి ఇచ్చే ఒక ఫంక్షన్. `Transformer` ఫంక్షన్ ASTలోని నోడ్‌లను సందర్శించడం మరియు రూపాంతరం చేయడం బాధ్యత వహిస్తుంది.
ఇక్కడ ఒక టైప్‌స్క్రిప్ట్ ఫైల్ ప్రారంభంలో ఒక వ్యాఖ్యను ఎలా జోడించాలో చూపించే ఒక సరళమైన ఉదాహరణ ఉంది:
import * as ts from "typescript";
import * as fs from "fs";
const fileName = "example.ts";
const sourceCode = fs.readFileSync(fileName, "utf8");
const sourceFile = ts.createSourceFile(
fileName,
sourceCode,
ts.ScriptTarget.ES2015,
true
);
const transformerFactory: ts.TransformerFactory = context => {
return transformer => {
return node => {
if (ts.isSourceFile(node)) {
// ఒక లీడింగ్ కామెంట్ సృష్టించండి
const comment = ts.addSyntheticLeadingComment(
node,
ts.SyntaxKind.MultiLineCommentTrivia,
" This file was automatically transformed ",
true // hasTrailingNewLine
);
return node;
}
return node;
};
};
};
const { transformed } = ts.transform(sourceFile, [transformerFactory]);
const printer = ts.createPrinter({
newLine: ts.NewLineKind.LineFeed
});
const result = printer.printFile(transformed[0]);
fs.writeFileSync("example.transformed.ts", result);
వివరణ:
- TransformerFactory: `Transformer` ఫంక్షన్‌ను తిరిగి ఇచ్చే ఒక `TransformerFactory` ఫంక్షన్‌ను నిర్వచిస్తుంది.
- Transformer: `Transformer` ఫంక్షన్ ప్రస్తుత నోడ్ ఒక `SourceFile` అవునో కాదో తనిఖీ చేస్తుంది. అలా అయితే, `ts.addSyntheticLeadingComment` ఉపయోగించి నోడ్‌కు ఒక లీడింగ్ వ్యాఖ్యను జోడిస్తుంది.
- ts.transform: `SourceFile`కి రూపాంతరం వర్తింపజేయడానికి `ts.transform`ని కాల్ చేస్తుంది.
- Printer: రూపాంతరం చెందిన AST నుండి కోడ్‌ను ఉత్పత్తి చేయడానికి ఒక `Printer` ఆబ్జెక్ట్‌ను సృష్టిస్తుంది.
- ప్రింట్ మరియు రైట్: రూపాంతరం చెందిన కోడ్‌ను ప్రింట్ చేసి దానిని `example.transformed.ts` అనే కొత్త ఫైల్‌కు రాస్తుంది.
ఈ ఉదాహరణ ఒక సరళమైన రూపాంతరాన్ని చూపిస్తుంది, కానీ మీరు కోడ్‌ను రీఫ్యాక్టరింగ్ చేయడం, లాగింగ్ స్టేట్‌మెంట్‌లను జోడించడం లేదా డాక్యుమెంటేషన్‌ను ఉత్పత్తి చేయడం వంటి మరింత సంక్లిష్టమైన రూపాంతరాలను నిర్వహించడానికి అదే ప్యాట్రన్‌ను ఉపయోగించవచ్చు.
అధునాతన రూపాంతర పద్ధతులు
కంపైలర్ APIతో మీరు ఉపయోగించగల కొన్ని అధునాతన రూపాంతర పద్ధతులు ఇక్కడ ఉన్నాయి:
- కొత్త నోడ్‌లను సృష్టించడం: కొత్త AST నోడ్‌లను సృష్టించడానికి `ts.createXXX` ఫంక్షన్‌లను ఉపయోగించండి. ఉదాహరణకు, `ts.createVariableDeclaration` ఒక కొత్త వేరియబుల్ డిక్లరేషన్ నోడ్‌ను సృష్టిస్తుంది.
- నోడ్‌లను భర్తీ చేయడం: `ts.visitEachChild` ఫంక్షన్‌ను ఉపయోగించి ఇప్పటికే ఉన్న నోడ్‌లను కొత్త నోడ్‌లతో భర్తీ చేయండి.
- నోడ్‌లను జోడించడం: `ts.updateXXX` ఫంక్షన్‌లను ఉపయోగించి ASTకి కొత్త నోడ్‌లను జోడించండి. ఉదాహరణకు, `ts.updateBlock` ఒక బ్లాక్ స్టేట్‌మెంట్‌ను కొత్త స్టేట్‌మెంట్‌లతో అప్‌డేట్ చేస్తుంది.
- నోడ్‌లను తొలగించడం: ట్రాన్స్‌ఫార్మర్ ఫంక్షన్ నుండి `undefined` తిరిగి ఇవ్వడం ద్వారా AST నుండి నోడ్‌లను తొలగించండి.
కోడ్ జనరేషన్
ASTని రూపాంతరం చేసిన తర్వాత, మీరు దాని నుండి కోడ్‌ను ఉత్పత్తి చేయాలి. కంపైలర్ API ఈ ప్రయోజనం కోసం ఒక `Printer` ఆబ్జెక్ట్‌ను అందిస్తుంది. `Printer` ఒక ASTని తీసుకుని కోడ్ యొక్క స్ట్రింగ్ ప్రాతినిధ్యాన్ని ఉత్పత్తి చేస్తుంది.
`ts.createPrinter` ఫంక్షన్ ఒక `Printer` ఆబ్జెక్ట్‌ను సృష్టిస్తుంది. మీరు ప్రింటర్‌ను వివిధ ఎంపికలతో కాన్ఫిగర్ చేయవచ్చు, যেমন ఉపయోగించాల్సిన న్యూలైన్ క్యారెక్టర్ మరియు వ్యాఖ్యలను ఎమిట్ చేయాలో లేదో వంటివి.
`printer.printFile` పద్ధతి ఒక `SourceFile`ను తీసుకుని కోడ్ యొక్క స్ట్రింగ్ ప్రాతినిధ్యాన్ని తిరిగి ఇస్తుంది. మీరు ఈ స్ట్రింగ్‌ను ఫైల్‌కు రాయవచ్చు.
కంపైలర్ API యొక్క ఆచరణాత్మక అనువర్తనాలు
టైప్‌స్క్రిప్ట్ కంపైలర్ API సాఫ్ట్‌వేర్ డెవలప్‌మెంట్‌లో అనేక ఆచరణాత్మక అనువర్తనాలను కలిగి ఉంది. ఇక్కడ కొన్ని ఉదాహరణలు ఉన్నాయి:
- లింటర్‌లు: కోడింగ్ ప్రమాణాలను అమలు చేయడానికి మరియు మీ కోడ్‌లో సంభావ్య సమస్యలను గుర్తించడానికి కస్టమ్ లింటర్‌లను నిర్మించండి.
- కోడ్ ఫార్మాటర్‌లు: ఒక నిర్దిష్ట శైలి గైడ్ ప్రకారం మీ కోడ్‌ను స్వయంచాలకంగా ఫార్మాట్ చేయడానికి కోడ్ ఫార్మాటర్‌లను సృష్టించండి.
- స్టాటిక్ ఎనలైజర్‌లు: మీ కోడ్‌లో బగ్‌లు, భద్రతా బలహీనతలు మరియు పనితీరు అడ్డంకులను గుర్తించడానికి స్టాటిక్ ఎనలైజర్‌లను అభివృద్ధి చేయండి.
- కోడ్ జనరేటర్లు: టెంప్లేట్‌లు లేదా ఇతర ఇన్‌పుట్ నుండి కోడ్‌ను ఉత్పత్తి చేయండి, పునరావృతమయ్యే పనులను ఆటోమేట్ చేయడం మరియు బాయిలర్‌ప్లేట్ కోడ్‌ను తగ్గించడం. ఉదాహరణకు, ఒక వివరణ ఫైల్ నుండి API క్లయింట్లు లేదా డేటాబేస్ స్కీమాలను ఉత్పత్తి చేయడం.
- రీఫ్యాక్టరింగ్ టూల్స్: వేరియబుల్స్‌ను స్వయంచాలకంగా పేరు మార్చడానికి, ఫంక్షన్‌లను సంగ్రహించడానికి లేదా ఫైల్‌ల మధ్య కోడ్‌ను తరలించడానికి రీఫ్యాక్టరింగ్ టూల్స్ నిర్మించండి.
- అంతర్జాతీయీకరణ (i18n) ఆటోమేషన్: మీ టైప్‌స్క్రిప్ట్ కోడ్ నుండి అనువదించగల స్ట్రింగ్‌లను స్వయంచాలకంగా సంగ్రహించండి మరియు వివిధ భాషల కోసం స్థానికీకరణ ఫైల్‌లను ఉత్పత్తి చేయండి. ఉదాహరణకు, ఒక టూల్ `translate()` ఫంక్షన్‌కు పంపబడిన స్ట్రింగ్‌ల కోసం కోడ్‌ను స్కాన్ చేసి, వాటిని స్వయంచాలకంగా అనువాద వనరు ఫైల్‌కు జోడించగలదు.
ఉదాహరణ: ఒక సరళమైన లింటర్ నిర్మించడం
టైప్‌స్క్రిప్ట్ కోడ్‌లో ఉపయోగించని వేరియబుల్స్ కోసం తనిఖీ చేసే ఒక సరళమైన లింటర్‌ను సృష్టిద్దాం. ఈ లింటర్ డిక్లేర్ చేయబడి కానీ ఎప్పుడూ ఉపయోగించని వేరియబుల్స్‌ను గుర్తిస్తుంది.
import * as ts from "typescript";
import * as fs from "fs";
const fileName = "example.ts";
const sourceCode = fs.readFileSync(fileName, "utf8");
const sourceFile = ts.createSourceFile(
fileName,
sourceCode,
ts.ScriptTarget.ES2015,
true
);
function findUnusedVariables(sourceFile: ts.SourceFile) {
const usedVariables = new Set();
function visit(node: ts.Node) {
if (ts.isIdentifier(node)) {
usedVariables.add(node.text);
}
ts.forEachChild(node, visit);
}
visit(sourceFile);
const unusedVariables: string[] = [];
function checkVariableDeclaration(node: ts.Node) {
if (ts.isVariableDeclaration(node) && node.name && ts.isIdentifier(node.name)) {
const variableName = node.name.text;
if (!usedVariables.has(variableName)) {
unusedVariables.push(variableName);
}
}
ts.forEachChild(node, checkVariableDeclaration);
}
checkVariableDeclaration(sourceFile);
return unusedVariables;
}
const unusedVariables = findUnusedVariables(sourceFile);
if (unusedVariables.length > 0) {
console.log("Unused variables:");
unusedVariables.forEach(variable => console.log(`- ${variable}`));
} else {
console.log("No unused variables found.");
}
వివరణ:
- findUnusedVariables ఫంక్షన్: ఇన్‌పుట్‌గా `SourceFile` తీసుకునే `findUnusedVariables` అనే ఫంక్షన్‌ను నిర్వచిస్తుంది.
- usedVariables సెట్: ఉపయోగించిన వేరియబుల్స్ పేర్లను నిల్వ చేయడానికి ఒక `Set`ను సృష్టిస్తుంది.
- visit ఫంక్షన్: ASTని ట్రావెర్స్ చేసి అన్ని ఐడెంటిఫైయర్‌ల పేర్లను `usedVariables` సెట్‌కు జోడించే ఒక రికర్సివ్ ఫంక్షన్ `visit`ను నిర్వచిస్తుంది.
- checkVariableDeclaration ఫంక్షన్: ఒక వేరియబుల్ డిక్లరేషన్ ఉపయోగించబడలేదో లేదో తనిఖీ చేసే `checkVariableDeclaration` అనే రికర్సివ్ ఫంక్షన్‌ను నిర్వచిస్తుంది. అలా అయితే, అది వేరియబుల్ పేరును `unusedVariables` అర్రేకు జోడిస్తుంది.
- unusedVariables తిరిగి ఇవ్వడం: ఉపయోగించని వేరియబుల్స్ పేర్లను కలిగి ఉన్న ఒక అర్రేను తిరిగి ఇస్తుంది.
- అవుట్‌పుట్: ఉపయోగించని వేరియబుల్స్‌ను కన్సోల్‌కు ప్రింట్ చేస్తుంది.
ఈ ఉదాహరణ ఒక సరళమైన లింటర్‌ను చూపిస్తుంది. మీరు ఇతర కోడింగ్ ప్రమాణాల కోసం తనిఖీ చేయడానికి మరియు మీ కోడ్‌లో ఇతర సంభావ్య సమస్యలను గుర్తించడానికి దీనిని విస్తరించవచ్చు. ఉదాహరణకు, మీరు ఉపయోగించని ఇంపోర్ట్స్, మితిమీరిన సంక్లిష్ట ఫంక్షన్‌లు, లేదా సంభావ్య భద్రతా బలహీనతల కోసం తనిఖీ చేయవచ్చు. ముఖ్యమైన విషయం ఏమిటంటే, ASTని ఎలా ట్రావెర్స్ చేయాలో మరియు మీరు ఆసక్తి ఉన్న నిర్దిష్ట నోడ్ రకాలను ఎలా గుర్తించాలో అర్థం చేసుకోవడం.
ఉత్తమ పద్ధతులు మరియు పరిగణనలు
- ASTని అర్థం చేసుకోవడం: AST యొక్క నిర్మాణాన్ని అర్థం చేసుకోవడానికి సమయం కేటాయించండి. మీ కోడ్ యొక్క ASTని విజువలైజ్ చేయడానికి AST ఎక్స్‌ప్లోరర్ వంటి టూల్స్ ఉపయోగించండి.
- రకం గార్డ్‌లను ఉపయోగించడం: మీరు సరైన నోడ్ రకాలతో పని చేస్తున్నారని నిర్ధారించుకోవడానికి రకం గార్డ్‌లను (`ts.isXXX`) ఉపయోగించండి.
- పనితీరును పరిగణించడం: AST రూపాంతరాలు గణనపరంగా ఖరీదైనవి కావచ్చు. మీరు సందర్శించే మరియు రూపాంతరం చేసే నోడ్‌ల సంఖ్యను తగ్గించడానికి మీ కోడ్‌ను ఆప్టిమైజ్ చేయండి.
- లోపాలను నిర్వహించడం: లోపాలను సునాయాసంగా నిర్వహించండి. మీరు ASTపై చెల్లని ఆపరేషన్లను నిర్వహించడానికి ప్రయత్నిస్తే కంపైలర్ API మినహాయింపులను విసరగలదు.
- పూర్తిగా పరీక్షించడం: మీ రూపాంతరాలు కోరుకున్న ఫలితాలను ఇస్తున్నాయని మరియు కొత్త బగ్‌లను ప్రవేశపెట్టడం లేదని నిర్ధారించుకోవడానికి వాటిని పూర్తిగా పరీక్షించండి.
- ఇప్పటికే ఉన్న లైబ్రరీలను ఉపయోగించడం: కంపైలర్ APIపై ఉన్నత-స్థాయి అబ్స్ట్రాక్షన్‌లను అందించే ఇప్పటికే ఉన్న లైబ్రరీలను ఉపయోగించడాన్ని పరిగణించండి. ఈ లైబ్రరీలు సాధారణ పనులను సరళీకృతం చేయగలవు మరియు మీరు వ్రాయవలసిన కోడ్ పరిమాణాన్ని తగ్గించగలవు. ఉదాహరణలు `ts-morph` మరియు `typescript-eslint`.
ముగింపు
టైప్‌స్క్రిప్ట్ కంపైలర్ API అధునాతన డెవలప్‌మెంట్ టూల్స్ నిర్మించడానికి ఒక శక్తివంతమైన సాధనం. ASTతో ఎలా పనిచేయాలో అర్థం చేసుకోవడం ద్వారా, మీరు లింటర్‌లు, కోడ్ ఫార్మాటర్‌లు, స్టాటిక్ ఎనలైజర్‌లు మరియు ఇతర టూల్స్ సృష్టించవచ్చు, ఇవి కోడ్ నాణ్యతను మెరుగుపరుస్తాయి, పునరావృతమయ్యే పనులను ఆటోమేట్ చేస్తాయి మరియు డెవలపర్ ఉత్పాదకతను పెంచుతాయి. API సంక్లిష్టంగా ఉన్నప్పటికీ, దానిపై నైపుణ్యం సాధించడం వల్ల కలిగే ప్రయోజనాలు గణనీయమైనవి. ఈ సమగ్ర గైడ్ మీ ప్రాజెక్ట్‌లలో కంపైలర్ APIని సమర్థవంతంగా అన్వేషించడానికి మరియు ఉపయోగించుకోవడానికి ఒక పునాదిని అందిస్తుంది. AST ఎక్స్‌ప్లోరర్ వంటి టూల్స్‌ను ఉపయోగించుకోవడం, నోడ్ రకాలను జాగ్రత్తగా నిర్వహించడం మరియు మీ రూపాంతరాలను పూర్తిగా పరీక్షించడం గుర్తుంచుకోండి. సాధన మరియు అంకితభావంతో, మీరు టైప్‌స్క్రిప్ట్ కంపైలర్ API యొక్క పూర్తి సామర్థ్యాన్ని అన్‌లాక్ చేయవచ్చు మరియు సాఫ్ట్‌వేర్ డెవలప్‌మెంట్ ల్యాండ్‌స్కేప్ కోసం వినూత్న పరిష్కారాలను నిర్మించవచ్చు.
మరింత అన్వేషణ:
- టైప్‌స్క్రిప్ట్ కంపైలర్ API డాక్యుమెంటేషన్: [https://github.com/microsoft/TypeScript/wiki/Using-the-Compiler-API](https://github.com/microsoft/TypeScript/wiki/Using-the-Compiler-API)
- AST ఎక్స్‌ప్లోరర్: [https://astexplorer.net/](https://astexplorer.net/)
- ts-morph లైబ్రరీ: [https://ts-morph.com/](https://ts-morph.com/)
- typescript-eslint: [https://typescript-eslint.io/](https://typescript-eslint.io/)