TypeScripti metaprogrammeerimine: peegeldamine ja koodi genereerimine

Metaprogrammeerimine, kunst kirjutada koodi, mis manipuleerib teist koodi, avab TypeScriptis põnevaid võimalusi. See postitus süveneb metaprogrammeerimise valdkonda, kasutades peegeldus- ja koodi genereerimise tehnikaid, uurides, kuidas saate oma koodi kompileerimise ajal analüüsida ja muuta. Vaatleme võimsaid tööriistu nagu dekoraatorid ja TypeScripti kompilaatori API, mis annavad teile võimaluse luua jõulisi, laiendatavaid ja väga hooldatavaid rakendusi.

Mis on metaprogrammeerimine?

Põhimõtteliselt hõlmab metaprogrammeerimine koodi kirjutamist, mis töötab teiste koodidega. See võimaldab teil koodi genereerida, analüüsida või teisendada dünaamiliselt kompileerimise ajal või käitamise ajal. TypeScriptis keskendub metaprogrammeerimine peamiselt kompileerimisaegsetele toimingutele, kasutades võimsaid abstraktsioonide saavutamiseks tüübisüsteemi ja kompilaatorit ennast.

Võrreldes käitamisajal põhinevate metaprogrammeerimise lähenemisviisidega, mida leidub sellistes keeltes nagu Python või Ruby, pakub TypeScripti kompileerimisajaline lähenemine eeliseid, nagu:

• Tüübiohutus: Vead püütakse kompileerimise ajal, mis takistab ootamatut käitumist käitamise ajal.
• Jõudlus: Koodi genereerimine ja manipuleerimine toimuvad enne käitamist, mille tulemuseks on optimeeritud koodi täitmine.
• Intellisense ja automaatne täitmine: Metaprogrammeerimise konstruktsioone saab TypeScripti keele teenus mõista, mis pakub paremat arendaja tööriistade tuge.

Peegeldamine TypeScriptis

Peegeldamine, metaprogrammeerimise kontekstis, on programmi võime uurida ja muuta oma struktuuri ja käitumist. TypeScriptis hõlmab see peamiselt tüüpide, klasside, omaduste ja meetodite uurimist kompileerimise ajal. Kuigi TypeScriptil ei ole traditsioonilist käitamisaja peegeldussüsteemi nagu Java või .NET, saame sarnaste efektide saavutamiseks kasutada tüübisüsteemi ja dekoraatoreid.

Dekoraatorid: annotatsioonid metaprogrammeerimiseks

Dekoraatorid on TypeScripti võimas funktsioon, mis võimaldab lisada annotatsioone ja muuta klasside, meetodite, omaduste ja parameetrite käitumist. Need toimivad kompileerimisaegsete metaprogrammeerimise tööriistadena, võimaldades teil oma koodi sisestada kohandatud loogikat ja metaandmeid.

Dekoraatorid deklareeritakse sümboliga @, millele järgneb dekoraatori nimi. Neid saab kasutada:

• Lisa metaandmeid klassidele või liikmetele.
• Muuda klasside definitsioone.
• Mähkida või asendada meetodeid.
• Registreerida klasse või meetodeid kesksesse registrisse.

Näide: logimisdekoraator

Loome lihtsa dekoraatori, mis logib meetodi väljakutsed:

            
function logMethod(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function (...args: any[]) {
    console.log(`Meetodi ${propertyKey} kutsumine argumentidega: ${JSON.stringify(args)}`);
    const result = originalMethod.apply(this, args);
    console.log(`Meetod ${propertyKey} tagastas: ${result}`);
    return result;
  };

  return descriptor;
}

class MyClass {
  @logMethod
  add(x: number, y: number): number {
    return x + y;
  }
}

const myInstance = new MyClass();
myInstance.add(5, 3);

            

              
                Copy
              
            
          

Selles näites peab dekoraator @logMethod kinni add meetodi kutsed, logib argumendid ja tagastusväärtuse ning seejärel käivitab algse meetodi. See näitab, kuidas dekoraatoreid saab kasutada ristlõikeliste murede, nagu logimine või jõudluse jälgimine, lisamiseks, muutmata klassi põhilist loogikat.

Dekoraatorite tehased

Dekoraatorite tehased võimaldavad teil luua parametriseeritud dekoraatoreid, muutes need paindlikumaks ja taaskasutatavamaks. Dekoraatorite tehas on funktsioon, mis tagastab dekoraatori.

            
function logMethodWithPrefix(prefix: string) {
  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value;

    descriptor.value = function (...args: any[]) {
      console.log(`${prefix} - Meetodi ${propertyKey} kutsumine argumentidega: ${JSON.stringify(args)}`);
      const result = originalMethod.apply(this, args);
      console.log(`${prefix} - Meetod ${propertyKey} tagastas: ${result}`);
      return result;
    };

    return descriptor;
  };
}

class MyClass {
  @logMethodWithPrefix("DEBUG")
  add(x: number, y: number): number {
    return x + y;
  }
}

const myInstance = new MyClass();
myInstance.add(5, 3);

            

              
                Copy
              
            
          

Selles näites on logMethodWithPrefix dekoraatorite tehas, mis võtab argumendina prefiksi. Tagastatud dekoraator logib meetodite kutsed määratud prefiksiga. See võimaldab teil logimise käitumist vastavalt kontekstile kohandada.

Metaandmete peegeldamine koos `reflect-metadata`

Teek reflect-metadata pakub standardset viisi klasside, meetodite, omaduste ja parameetritega seotud metaandmete salvestamiseks ja toomiseks. See täiendab dekoraatoreid, võimaldades teil oma koodile lisada suvalisi andmeid ja neid käitamise ajal (või kompileerimise ajal tüübi deklaratsioonide kaudu) kasutada.

Teek reflect-metadata kasutamiseks peate selle installima:

            
npm install reflect-metadata --save

            

              
                Copy
              
            
          

Ja lubage oma tsconfig.json failis kompilaatori suvand emitDecoratorMetadata:

            
{
  "compilerOptions": {
    "emitDecoratorMetadata": true
  }
}

            

              
                Copy
              
            
          

Näide: omaduste valideerimine

Loome dekoraatori, mis valideerib omaduste väärtused metaandmete põhjal:

            
import 'reflect-metadata';

const requiredMetadataKey = Symbol("required");

function required(target: Object, propertyKey: string | symbol, parameterIndex: number) {
  let existingRequiredParameters: number[] = Reflect.getOwnMetadata(requiredMetadataKey, target, propertyKey) || [];
  existingRequiredParameters.push(parameterIndex);
  Reflect.defineMetadata(requiredMetadataKey, existingRequiredParameters, target, propertyKey);
}

function validate(target: any, propertyName: string, descriptor: TypedPropertyDescriptor) {
  let method = descriptor.value!;

  descriptor.value = function () {
    let requiredParameters: number[] = Reflect.getOwnMetadata(requiredMetadataKey, target, propertyName);
    if (requiredParameters) {
      for (let parameterIndex of requiredParameters) {
        if (arguments.length <= parameterIndex || arguments[parameterIndex] === undefined) {
          throw new Error("Puuduv kohustuslik argument.");
        }
      }
    }
    return method.apply(this, arguments);
  };
}

class MyClass {
  myMethod(@required param1: string, param2: number) {
    console.log(param1, param2);
  }
}

            

              
                Copy
              
            
          

Selles näites tähistab dekoraator @required parameetrid kohustuslikena. Dekoraator validate peab kinni meetodi väljakutsed ja kontrollib, kas kõik nõutavad parameetrid on olemas. Kui mõni nõutav parameeter puudub, visatakse viga. See näitab, kuidas teeki reflect-metadata saab kasutada metaandmete põhjal valideerimise reeglite jõustamiseks.

Koodi genereerimine TypeScripti kompilaatori API-ga

TypeScripti kompilaatori API pakub programmilist juurdepääsu TypeScripti kompilaatorile, võimaldades teil TypeScripti koodi analüüsida, muuta ja genereerida. See avab metaprogrammeerimiseks võimsaid võimalusi, võimaldades teil luua kohandatud koodigeneraatoreid, lintereid ja muid arendustööriistu.

Abstraktse süntaksipuu (AST) mõistmine

Koodi genereerimise alus kompilaatori API-ga on abstraktne süntaksipuu (AST). AST on teie TypeScripti koodi puulaadne esitus, kus iga puu sõlm tähistab süntaksilist elementi, näiteks klassi, funktsiooni, muutujat või avaldist.

Kompilaatori API pakub funktsioone AST-i läbimiseks ja manipuleerimiseks, võimaldades teil oma koodi struktuuri analüüsida ja muuta. Saate AST-i kasutada:

• Teie koodi kohta teabe väljavõtmine (nt leidke kõik klassid, mis rakendavad konkreetset liidest).
• Teie koodi teisendamine (nt genereerige automaatselt dokumentatsiooni kommentaarid).
• Uue koodi genereerimine (nt andmele juurdepääsu objektide jaoks boilerplate koodi loomine).

Koodi genereerimise sammud

Koodi genereerimise tüüpiline töövoog kompilaatori API-ga hõlmab järgmisi samme:

1. TypeScripti koodi parsimine: Kasutage funktsiooni ts.createSourceFile, et luua SourceFile-i objekt, mis esindab parsit koodi.
2. AST-i läbimine: Kasutage funktsioone ts.visitNode ja ts.visitEachChild, et rekursiivselt läbida AST ja leida huvipakkuvad sõlmed.
3. AST-i teisendamine: Looge uusi AST-i sõlmi või muutke olemasolevaid sõlmi, et rakendada soovitud teisendused.
4. TypeScripti koodi genereerimine: Kasutage funktsiooni ts.createPrinter, et genereerida muudetud AST-ist TypeScripti kood.

Näide: andmeedastusobjekti (DTO) genereerimine

Loome lihtsa koodigeneraatori, mis genereerib andmeedastusobjekti (DTO) liidese klassi definitsiooni põhjal.

            
import * as ts from "typescript";
import * as fs from "fs";

function generateDTO(sourceFile: ts.SourceFile, className: string): string | undefined {
  let interfaceName = className + "DTO";
  let properties: string[] = [];

  function visit(node: ts.Node) {
    if (ts.isClassDeclaration(node) && node.name?.text === className) {
      node.members.forEach(member => {
        if (ts.isPropertyDeclaration(member) && member.name) {
          let propertyName = member.name.getText(sourceFile);
          let typeName = "any"; // Vaikimisi tüüp

          if (member.type) {
            typeName = member.type.getText(sourceFile);
          }

          properties.push(`  ${propertyName}: ${typeName};`);
        }
      });
    }
  }

  ts.visitNode(sourceFile, visit);

  if (properties.length > 0) {
    return `interface ${interfaceName} {\n${properties.join("\n")}\n}`;
  }

  return undefined;
}

// Näidisrakendus
const fileName = "./src/my_class.ts"; // Asendage oma failiteega
const classNameToGenerateDTO = "MyClass";

fs.readFile(fileName, (err, buffer) => {
  if (err) {
    console.error("Faili lugemise viga:", err);
    return;
  }

  const sourceCode = buffer.toString();

  const sourceFile = ts.createSourceFile(
    fileName,
    sourceCode,
    ts.ScriptTarget.ES2015,
    true
  );

  const dtoInterface = generateDTO(sourceFile, classNameToGenerateDTO);

  if (dtoInterface) {
    console.log(dtoInterface);
  } else {
    console.log(`Klassi ${classNameToGenerateDTO} ei leitud või DTO genereerimiseks pole omadusi.`);
  }
});

            

              
                Copy
              
            
          

my_class.ts:

            
class MyClass {
  name: string;
  age: number;
  isActive: boolean;
}

            

              
                Copy
              
            
          

See näide loeb TypeScripti faili, leiab määratud nimega klassi, eraldab selle omadused ja nende tüübid ning genereerib DTO liidese samade omadustega. Väljund on:

            
interface MyClassDTO {
  name: string;
  age: number;
  isActive: boolean;
}

            

              
                Copy
              
            
          

Selgitus:

• See loeb TypeScripti faili lähtekoodi, kasutades fs.readFile.
• See loob lähtekoodist ts.SourceFile kasutades ts.createSourceFile, mis esindab parsit koodi.
• Funktsioon generateDTO läbib AST-i. Kui leitakse määratud nimega klassi deklaratsioon, kordab see klassi liikmeid.
• Iga omaduse deklaratsiooni puhul eraldab see omaduse nime ja tüübi ning lisab selle massiivi properties.
• Lõpuks konstrueerib see ekstraheeritud omadusi kasutades DTO liidese stringi ja tagastab selle.

Koodi genereerimise praktilised rakendused

Koodi genereerimisel kompilaatori API-ga on palju praktilisi rakendusi, sealhulgas:

• Boilerplate koodi genereerimine: genereerige automaatselt andmele juurdepääsu objektide, API klientide või muude korduvate ülesannete kood.
• Kohandatud linterite loomine: jõustage kodeerimisstandardid ja parimad tavad, analüüsides AST-i ja tuvastades võimalikke probleeme.
• Dokumentatsiooni genereerimine: ekstraktige AST-ist teavet API dokumentatsiooni genereerimiseks.
• Refaktorimise automatiseerimine: refaktoreerige koodi automaatselt AST-i teisendades.
• Valdkonnaspetsiifiliste keelte (DSL-ide) loomine: looge kohandatud keeled, mis on kohandatud konkreetsetele domeenidele ja genereerige neist TypeScripti koodi.

Täpsemad metaprogrammeerimise tehnikad

Lisaks dekoraatoritele ja kompilaatori API-le saab TypeScriptis metaprogrammeerimiseks kasutada ka mitmeid teisi tehnikaid:

• Tingimustüübid: kasutage tingimustüüpe tüüpide määratlemiseks teiste tüüpide põhjal, võimaldades teil luua paindlikke ja kohandatavaid tüübi definitsioone. Näiteks saate luua tüübi, mis ekstraktib funktsiooni tagastustüübi.
• Kaardistatud tüübid: teisendage olemasolevaid tüüpe, kaardistades nende omadusi, võimaldades teil luua uusi tüüpe, mille omaduste tüübid või nimed on muudetud. Näiteks looge tüüp, mis muudab kõik teise tüübi omadused kirjutuskaitstud.
• Tüüpide järeldamine: kasutage TypeScripti tüüpide järeldamise võimalusi tüüpide automaatseks järeldamiseks koodi põhjal, vähendades vajadust otseste tüübi annotatsioonide järele.
• Malliliteraali tüübid: kasutage malliliteraali tüüpe stringipõhiste tüüpide loomiseks, mida saab kasutada koodi genereerimiseks või valideerimiseks. Näiteks konkreetsete võtmete genereerimine muude konstantide põhjal.

Metaprogrammeerimise eelised

Metaprogrammeerimine pakub TypeScripti arendamisel mitmeid eeliseid:

• Suurenenud koodi taaskasutatavus: looge taaskasutatavaid komponente ja abstraktsioone, mida saab rakendada teie rakenduse mitmele osale.
• Vähendatud boilerplate kood: genereerige automaatselt korduvaid koode, vähendades vajaliku käsitsi kodeerimise hulka.
• Parem koodi hooldatavus: muutke oma kood moodulimaks ja arusaadavamaks, eraldades mured ja kasutades metaprogrammeerimist ristlõikeliste murede käsitlemiseks.
• Suurenenud tüübiohutus: püüdke vead kompileerimise ajal, vältides ootamatut käitumist käitamise ajal.
• Suurenenud tootlikkus: automatiseerige ülesandeid ja sujuvamaks arenduse töövooge, mis viib suurema tootlikkuseni.

Metaprogrammeerimise väljakutsed

Kuigi metaprogrammeerimine pakub olulisi eeliseid, esitab see ka mõningaid väljakutseid:

• Suurenenud keerukus: metaprogrammeerimine võib muuta teie koodi keerulisemaks ja raskemini mõistetavaks, eriti arendajatele, kes pole seotud tehnikatega tuttavad.
• Silumise raskused: metaprogrammeerimiskoodi silumine võib olla keerulisem kui traditsioonilise koodi silumine, kuna kood, mis on täidetud, ei pruugi lähtekoodis otse nähtav olla.
• Jõudluse lisakulu: koodi genereerimine ja manipuleerimine võib tekitada jõudluse lisakulu, eriti kui seda ei tehta hoolikalt.
• Õppimiskõver: metaprogrammeerimistehnikate valdamine nõuab olulist aja ja vaeva investeerimist.

Järeldus

TypeScripti metaprogrammeerimine, peegelduse ja koodi genereerimise kaudu, pakub võimsaid tööriistu jõuliste, laiendatavate ja väga hooldatavate rakenduste loomiseks. Kasutades dekoraatoreid, TypeScripti kompilaatori API-t ja täiustatud tüübisüsteemi funktsioone, saate automatiseerida ülesandeid, vähendada boilerplate koodi ja parandada oma koodi üldist kvaliteeti. Kuigi metaprogrammeerimine esitab mõningaid väljakutseid, muudavad selle pakutavad eelised selle väärtuslikuks tehnikaks kogenud TypeScripti arendajatele.

Omaks metaprogrammeerimise jõud ja avage uusi võimalusi oma TypeScripti projektides. Uurige esitatud näiteid, katsetage erinevate tehnikatega ja avastage, kuidas metaprogrammeerimine aitab teil paremat tarkvara luua.