TypeScript Metadasturlash: Refleksiya va Kod Generatsiyasi

Metadasturlash, ya'ni boshqa kodlarni boshqaradigan kod yozish san'ati, TypeScript-da ajoyib imkoniyatlarni ochadi. Ushbu maqola refleksiya va kod generatsiyasi usullari yordamida metadasturlash olamiga sho'ng'iydi va kompilyatsiya vaqtida kodingizni qanday tahlil qilish va o'zgartirish mumkinligini o'rganadi. Biz dekoratorlar va TypeScript Kompilyator API kabi kuchli vositalarni ko'rib chiqamiz, bu sizga mustahkam, kengaytiriladigan va yuqori darajada qo'llab-quvvatlanadigan ilovalar yaratish imkonini beradi.

Metadasturlash nima?

Aslida, metadasturlash boshqa kod ustida ishlaydigan kod yozishni anglatadi. Bu sizga kompilyatsiya yoki ishga tushirish vaqtida kodni dinamik ravishda yaratish, tahlil qilish yoki o'zgartirish imkonini beradi. TypeScript-da metadasturlash asosan kompilyatsiya vaqtidagi amallarga qaratilgan bo'lib, kuchli abstraksiyalarga erishish uchun tiplar tizimi va kompilyatorning o'zidan foydalanadi.

Python yoki Ruby kabi tillarda mavjud bo'lgan ishga tushirish vaqtidagi metadasturlash yondashuvlari bilan taqqoslaganda, TypeScript-ning kompilyatsiya vaqtidagi yondashuvi quyidagi afzalliklarni taqdim etadi:

• Tiplar xavfsizligi: Xatolar kompilyatsiya vaqtida aniqlanadi, bu esa ishga tushirish vaqtidagi kutilmagan xatti-harakatlarning oldini oladi.
• Samaradorlik: Kod generatsiyasi va manipulyatsiyasi ishga tushirishdan oldin sodir bo'ladi, bu esa optimallashtirilgan kod bajarilishiga olib keladi.
• Intellisense va Avtoto'ldirish: Metadasturlash konstruksiyalari TypeScript til xizmati tomonidan tushunilishi mumkin, bu esa ishlab chiquvchilar uchun yaxshiroq vositalar bilan ta'minlaydi.

TypeScript-da Refleksiya

Metadasturlash kontekstida refleksiya - bu dasturning o'z tuzilishi va xatti-harakatlarini tekshirish va o'zgartirish qobiliyatidir. TypeScript-da bu asosan kompilyatsiya vaqtida tiplarni, klasslarni, xususiyatlarni va metodlarni o'rganishni o'z ichiga oladi. TypeScript Java yoki .NET kabi an'anaviy ishga tushirish vaqtidagi refleksiya tizimiga ega bo'lmasa-da, biz shunga o'xshash effektlarga erishish uchun tiplar tizimi va dekoratorlardan foydalanishimiz mumkin.

Dekoratorlar: Metadasturlash uchun annotatsiyalar

Dekoratorlar - bu TypeScript-dagi kuchli xususiyat bo'lib, ular klasslar, metodlar, xususiyatlar va parametrlarga annotatsiyalar qo'shish va ularning xatti-harakatlarini o'zgartirish usulini taqdim etadi. Ular kompilyatsiya vaqtidagi metadasturlash vositalari sifatida ishlaydi va kodingizga maxsus mantiq va metama'lumotlarni kiritish imkonini beradi.

Dekoratorlar @ belgisi va undan keyin dekorator nomi yordamida e'lon qilinadi. Ular quyidagi maqsadlarda ishlatilishi mumkin:

• Klasslar yoki a'zolarga metama'lumot qo'shish.
• Klass ta'riflarini o'zgartirish.
• Metodlarni o'rash yoki almashtirish.
• Klasslar yoki metodlarni markaziy ro'yxatga olish.

Misol: Jurnalga yozish dekoratori

Keling, metod chaqiruvlarini jurnalga yozib boradigan oddiy dekorator yaratamiz:

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

  descriptor.value = function (...args: any[]) {
    console.log(`Calling method ${propertyKey} with arguments: ${JSON.stringify(args)}`);
    const result = originalMethod.apply(this, args);
    console.log(`Method ${propertyKey} returned: ${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
              
            
          

Ushbu misolda @logMethod dekoratori add metodiga qilingan chaqiruvlarni ushlab oladi, argumentlar va qaytarilgan qiymatni jurnalga yozadi va keyin asl metodni bajaradi. Bu dekoratorlardan klassning asosiy mantig'ini o'zgartirmasdan jurnalga yozish yoki samaradorlikni kuzatish kabi kesib o'tuvchi vazifalarni qo'shish uchun qanday foydalanish mumkinligini ko'rsatadi.

Dekorator Fabrikalari

Dekorator fabrikalari sizga parametrlashtirilgan dekoratorlar yaratish imkonini beradi, bu ularni yanada moslashuvchan va qayta ishlatiladigan qiladi. Dekorator fabrikasi - bu dekoratorni qaytaradigan funksiya.

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

    descriptor.value = function (...args: any[]) {
      console.log(`${prefix} - Calling method ${propertyKey} with arguments: ${JSON.stringify(args)}`);
      const result = originalMethod.apply(this, args);
      console.log(`${prefix} - Method ${propertyKey} returned: ${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
              
            
          

Ushbu misolda logMethodWithPrefix - bu prefiksni argument sifatida qabul qiladigan dekorator fabrikasi. Qaytarilgan dekorator metod chaqiruvlarini ko'rsatilgan prefiks bilan jurnalga yozadi. Bu sizga jurnalga yozish xatti-harakatini kontekstga qarab sozlash imkonini beradi.

`reflect-metadata` yordamida Metama'lumotlar Refleksiyasi

reflect-metadata kutubxonasi klasslar, metodlar, xususiyatlar va parametrlar bilan bog'liq metama'lumotlarni saqlash va olish uchun standart usulni taqdim etadi. U kodingizga ixtiyoriy ma'lumotlarni biriktirish va ularga ish vaqtida (yoki kompilyatsiya vaqtida tip e'lonlari orqali) kirish imkonini berib, dekoratorlarni to'ldiradi.

reflect-metadata-dan foydalanish uchun uni o'rnatishingiz kerak:

            
npm install reflect-metadata --save

            

              
                Copy
              
            
          

Va tsconfig.json faylingizda emitDecoratorMetadata kompilyator opsiyasini yoqishingiz kerak:

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

            

              
                Copy
              
            
          

Misol: Xususiyatni tekshirish

Keling, metama'lumotlarga asoslanib xususiyat qiymatlarini tekshiradigan dekorator yaratamiz:

            
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("Missing required argument.");
        }
      }
    }
    return method.apply(this, arguments);
  };
}

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

            

              
                Copy
              
            
          

Ushbu misolda @required dekoratori parametrlarni majburiy deb belgilaydi. validate dekoratori metod chaqiruvlarini ushlab oladi va barcha majburiy parametrlar mavjudligini tekshiradi. Agar majburiy parametr yetishmayotgan bo'lsa, xatolik yuzaga keladi. Bu reflect-metadata-dan metama'lumotlarga asoslangan tekshirish qoidalarini majburiy qilish uchun qanday foydalanish mumkinligini ko'rsatadi.

TypeScript Kompilyator API yordamida Kod Generatsiyasi

TypeScript Kompilyator API TypeScript kompilyatoriga dasturiy kirishni ta'minlaydi, bu sizga TypeScript kodini tahlil qilish, o'zgartirish va yaratish imkonini beradi. Bu metadasturlash uchun kuchli imkoniyatlarni ochadi, sizga maxsus kod generatorlari, linterlar va boshqa ishlab chiqish vositalarini yaratishga imkon beradi.

Abstrakt Sintaksis Daraxti (AST) ni tushunish

Kompilyator API yordamida kod generatsiyasining asosi Abstrakt Sintaksis Daraxti (AST) hisoblanadi. AST - bu sizning TypeScript kodingizning daraxtsimon tasviri bo'lib, daraxtdagi har bir tugun klass, funksiya, o'zgaruvchi yoki ifoda kabi sintaktik elementni ifodalaydi.

Kompilyator API AST bo'ylab harakatlanish va uni manipulyatsiya qilish uchun funksiyalarni taqdim etadi, bu sizga kodingizning tuzilishini tahlil qilish va o'zgartirish imkonini beradi. Siz AST-dan quyidagilar uchun foydalanishingiz mumkin:

• Kodingiz haqida ma'lumotlarni ajratib olish (masalan, ma'lum bir interfeysni amalga oshiradigan barcha klasslarni topish).
• Kodingizni o'zgartirish (masalan, hujjatlar sharhlarini avtomatik ravishda yaratish).
• Yangi kod yaratish (masalan, ma'lumotlarga kirish ob'ektlari uchun shablon kod yaratish).

Kod Generatsiyasi uchun Qadamlar

Kompilyator API yordamida kod generatsiyasi uchun odatiy ish jarayoni quyidagi qadamlarni o'z ichiga oladi:

1. TypeScript kodini tahlil qilish: Tahlil qilingan TypeScript kodini ifodalovchi SourceFile ob'ektini yaratish uchun ts.createSourceFile funksiyasidan foydalaning.
2. AST bo'ylab harakatlanish: AST bo'ylab rekursiv ravishda harakatlanish va sizni qiziqtirgan tugunlarni topish uchun ts.visitNode va ts.visitEachChild funksiyalaridan foydalaning.
3. AST-ni o'zgartirish: Istalgan o'zgartirishlarni amalga oshirish uchun yangi AST tugunlarini yarating yoki mavjudlarini o'zgartiring.
4. TypeScript kodini yaratish: O'zgartirilgan AST-dan TypeScript kodini yaratish uchun ts.createPrinter funksiyasidan foydalaning.

Misol: Ma'lumotlar Uzatish Ob'ekti (DTO) yaratish

Keling, klass ta'rifiga asoslanib Ma'lumotlar Uzatish Ob'ekti (DTO) interfeysini yaratadigan oddiy kod generatorini yaratamiz.

            
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"; // Standart tip

          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;
}

// Foydalanish misoli
const fileName = "./src/my_class.ts"; // O'zingizning fayl yo'lingiz bilan almashtiring
const classNameToGenerateDTO = "MyClass";

fs.readFile(fileName, (err, buffer) => {
  if (err) {
    console.error("Error reading file:", 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(`Class ${classNameToGenerateDTO} not found or no properties to generate DTO from.`);
  }
});

            

              
                Copy
              
            
          

my_class.ts:

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

            

              
                Copy
              
            
          

Ushbu misol TypeScript faylini o'qiydi, ko'rsatilgan nomdagi klassni topadi, uning xususiyatlari va tiplarini ajratib oladi va xuddi shu xususiyatlarga ega DTO interfeysini yaratadi. Natija quyidagicha bo'ladi:

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

            

              
                Copy
              
            
          

Tushuntirish:

• U fs.readFile yordamida TypeScript faylining manba kodini o'qiydi.
• U ts.createSourceFile yordamida manba kodidan ts.SourceFile yaratadi, bu tahlil qilingan kodni ifodalaydi.
• generateDTO funksiyasi AST bo'ylab harakatlanadi. Agar ko'rsatilgan nomdagi klass e'loni topilsa, u klass a'zolari bo'ylab takrorlanadi.
• Har bir xususiyat e'loni uchun u xususiyat nomi va tipini ajratib oladi va uni properties massiviga qo'shadi.
• Nihoyat, u ajratib olingan xususiyatlardan foydalanib DTO interfeysi satrini tuzadi va uni qaytaradi.

Kod Generatsiyasining Amaliy Qo'llanilishi

Kompilyator API yordamida kod generatsiyasining ko'plab amaliy qo'llanilishlari mavjud, jumladan:

• Shablon kod generatsiyasi: Ma'lumotlarga kirish ob'ektlari, API mijozlari yoki boshqa takrorlanuvchi vazifalar uchun kodni avtomatik ravishda yaratish.
• Maxsus linterlar yaratish: AST-ni tahlil qilish va potentsial muammolarni aniqlash orqali kodlash standartlari va eng yaxshi amaliyotlarni joriy etish.
• Hujjatlar generatsiyasi: API hujjatlarini yaratish uchun AST-dan ma'lumotlarni ajratib olish.
• Refaktoringni avtomatlashtirish: AST-ni o'zgartirish orqali kodni avtomatik ravishda refaktoring qilish.
• Domen-maxsus Tillar (DSLs) yaratish: Muayyan domenlarga moslashtirilgan maxsus tillarni yaratish va ulardan TypeScript kodini generatsiya qilish.

Ilg'or Metadasturlash Texnikalari

Dekoratorlar va Kompilyator API-dan tashqari, TypeScript-da metadasturlash uchun bir nechta boshqa usullardan foydalanish mumkin:

• Shartli Tiplar: Boshqa tiplarga asoslangan tiplarni aniqlash uchun shartli tiplardan foydalaning, bu sizga moslashuvchan va o'zgaruvchan tip ta'riflarini yaratish imkonini beradi. Masalan, funksiyaning qaytariladigan tipini ajratib oladigan tip yaratishingiz mumkin.
• Xaritalangan Tiplar: Mavjud tiplarni ularning xususiyatlari bo'yicha xaritalash orqali o'zgartiring, bu sizga o'zgartirilgan xususiyat tiplari yoki nomlari bilan yangi tiplar yaratish imkonini beradi. Masalan, boshqa tipning barcha xususiyatlarini faqat o'qish uchun mo'ljallangan qiladigan tip yarating.
• Tiplarni Avtomatik Aniqlash: Kodga asoslanib tiplarni avtomatik aniqlash uchun TypeScript-ning tipni avtomatik aniqlash imkoniyatlaridan foydalaning, bu esa aniq tip annotatsiyalariga bo'lgan ehtiyojni kamaytiradi.
• Shablonli Literal Tiplar: Kod generatsiyasi yoki tekshirish uchun ishlatilishi mumkin bo'lgan satrga asoslangan tiplarni yaratish uchun shablonli literal tiplardan foydalaning. Masalan, boshqa konstantalarga asoslangan maxsus kalitlarni yaratish.

Metadasturlashning Afzalliklari

Metadasturlash TypeScript ishlab chiqishda bir qator afzalliklarni taqdim etadi:

• Kodning qayta ishlatiluvchanligini oshirish: Ilovangizning bir nechta qismlariga qo'llanilishi mumkin bo'lgan qayta ishlatiladigan komponentlar va abstraksiyalarni yarating.
• Shablon kodni kamaytirish: Takrorlanuvchi kodni avtomatik ravishda yarating, bu esa qo'lda kodlash hajmini kamaytiradi.
• Kodning qo'llab-quvvatlanishini yaxshilash: Vazifalarni ajratish va kesib o'tuvchi vazifalarni boshqarish uchun metadasturlashdan foydalanish orqali kodingizni yanada modulli va tushunarli qiling.
• Tiplar xavfsizligini kuchaytirish: Kompilyatsiya vaqtida xatolarni aniqlang, bu esa ishga tushirish vaqtidagi kutilmagan xatti-harakatlarning oldini oladi.
• Hosildorlikni oshirish: Vazifalarni avtomatlashtirish va ishlab chiqish jarayonlarini soddalashtirish, bu esa hosildorlikni oshirishga olib keladi.

Metadasturlashning Qiyinchiliklari

Metadasturlash muhim afzalliklarni taqdim etsa-da, u ba'zi qiyinchiliklarni ham keltirib chiqaradi:

• Murakkablikning ortishi: Metadasturlash kodingizni murakkablashtirishi va tushunishni qiyinlashtirishi mumkin, ayniqsa bu usullar bilan tanish bo'lmagan dasturchilar uchun.
• Nosozliklarni tuzatishdagi qiyinchiliklar: Metadasturlash kodini nosozliklarni tuzatish an'anaviy kodga qaraganda qiyinroq bo'lishi mumkin, chunki bajarilayotgan kod manba kodida to'g'ridan-to'g'ri ko'rinmasligi mumkin.
• Samaradorlikka qo'shimcha yuk: Kod generatsiyasi va manipulyatsiyasi samaradorlikka qo'shimcha yuk keltirishi mumkin, ayniqsa ehtiyotkorlik bilan bajarilmasa.
• O'rganish jarayoni: Metadasturlash usullarini o'zlashtirish sezilarli vaqt va kuch talab qiladi.

Xulosa

TypeScript metadasturlashi, refleksiya va kod generatsiyasi orqali mustahkam, kengaytiriladigan va yuqori darajada qo'llab-quvvatlanadigan ilovalar yaratish uchun kuchli vositalarni taklif etadi. Dekoratorlar, TypeScript Kompilyator API va ilg'or tiplar tizimi xususiyatlaridan foydalanib, siz vazifalarni avtomatlashtirishingiz, shablon kodni kamaytirishingiz va kodingizning umumiy sifatini oshirishingiz mumkin. Metadasturlash ba'zi qiyinchiliklarni keltirib chiqarsa-da, u taqdim etadigan afzalliklar uni tajribali TypeScript dasturchilari uchun qimmatli texnikaga aylantiradi.

Metadasturlash kuchini qabul qiling va TypeScript loyihalaringizda yangi imkoniyatlarni oching. Taqdim etilgan misollarni o'rganing, turli usullar bilan tajriba o'tkazing va metadasturlash sizga yaxshiroq dasturiy ta'minot yaratishga qanday yordam berishini kashf eting.