டைப்ஸ்கிரிப்ட் டெக்கரேட்டர்கள்: மெட்டாபுரோகிராமிங்கின் ஆற்றலை வெளிப்படுத்துதல்

டைப்ஸ்கிரிப்ட் டெக்கரேட்டர்கள் மெட்டாபுரோகிராமிங் திறன்களுடன் உங்கள் குறியீட்டை மேம்படுத்த ஒரு சக்திவாய்ந்த மற்றும் நேர்த்தியான வழியை வழங்குகின்றன. அவை வடிவமைப்பு நேரத்தில் வகுப்புகள், முறைகள், பண்புகள் மற்றும் அளவுருக்களை மாற்றியமைக்கவும் நீட்டிக்கவும் ஒரு வழிமுறையை வழங்குகின்றன, உங்கள் குறியீட்டின் முக்கிய தர்க்கத்தை மாற்றாமல் நடத்தைகள் மற்றும் குறிப்புகளைச் சேர்க்க உங்களை அனுமதிக்கின்றன. இந்த வலைப்பதிவு இடுகை டைப்ஸ்கிரிப்ட் டெக்கரேட்டர்களின் நுணுக்கங்களை ஆராய்ந்து, அனைத்து நிலை டெவலப்பர்களுக்கும் ஒரு விரிவான வழிகாட்டியை வழங்கும். டெக்கரேட்டர்கள் என்றால் என்ன, அவை எவ்வாறு செயல்படுகின்றன, கிடைக்கும் பல்வேறு வகைகள், நடைமுறை எடுத்துக்காட்டுகள் மற்றும் அவற்றின் பயனுள்ள பயன்பாட்டிற்கான சிறந்த நடைமுறைகளை நாங்கள் ஆராய்வோம். நீங்கள் டைப்ஸ்கிரிப்டுக்கு புதியவராக இருந்தாலும் சரி அல்லது அனுபவமிக்க டெவலப்பராக இருந்தாலும் சரி, இந்த வழிகாட்டி சுத்தமான, மேலும் பராமரிக்கக்கூடிய, மற்றும் மேலும் வெளிப்படையான குறியீட்டிற்காக டெக்கரேட்டர்களைப் பயன்படுத்துவதற்கான அறிவை உங்களுக்கு வழங்கும்.

டைப்ஸ்கிரிப்ட் டெக்கரேட்டர்கள் என்றால் என்ன?

அவற்றின் மையத்தில், டைப்ஸ்கிரிப்ட் டெக்கரேட்டர்கள் மெட்டாபுரோகிராமிங்கின் ஒரு வடிவம். அவை அடிப்படையில் ஒன்று அல்லது அதற்கு மேற்பட்ட வாதங்களை (வழக்கமாக அலங்கரிக்கப்படும் பொருள், அதாவது வகுப்பு, முறை, பண்பு அல்லது அளவுரு) எடுத்துக்கொள்ளும் செயல்பாடுகள் மற்றும் அதை மாற்றியமைக்கலாம் அல்லது புதிய செயல்பாட்டைச் சேர்க்கலாம். அவற்றை உங்கள் குறியீட்டில் நீங்கள் இணைக்கும் குறிப்புகள் அல்லது பண்புக்கூறுகளாக நினைத்துப் பாருங்கள். இந்த குறிப்புகளைப் பின்னர் குறியீட்டைப் பற்றிய மெட்டாடேட்டாவை வழங்க அல்லது அதன் நடத்தையை மாற்றப் பயன்படுத்தலாம்.

டெக்கரேட்டர்கள் `@` சின்னத்தைத் தொடர்ந்து ஒரு செயல்பாட்டு அழைப்பைப் பயன்படுத்தி வரையறுக்கப்படுகின்றன (எ.கா., `@decoratorName()`). டெக்கரேட்டர் செயல்பாடு பின்னர் உங்கள் பயன்பாட்டின் வடிவமைப்பு-நேர கட்டத்தில் செயல்படுத்தப்படும்.

டெக்கரேட்டர்கள் ஜாவா, சி#, மற்றும் பைத்தான் போன்ற மொழிகளில் உள்ள ஒத்த அம்சங்களால் ஈர்க்கப்பட்டுள்ளன. அவை உங்கள் முக்கிய தர்க்கத்தைச் சுத்தமாக வைத்து, உங்கள் மெட்டாடேட்டா அல்லது மாற்றியமைக்கும் அம்சங்களை ஒரு பிரத்யேக இடத்தில் கவனம் செலுத்துவதன் மூலம் கவலைகளைப் பிரிக்கவும் மற்றும் குறியீட்டின் மறுபயன்பாட்டை ஊக்குவிக்கவும் ஒரு வழியை வழங்குகின்றன.

டெக்கரேட்டர்கள் எவ்வாறு செயல்படுகின்றன

டைப்ஸ்கிரிப்ட் கம்பைலர் டெக்கரேட்டர்களை வடிவமைப்பு நேரத்தில் அழைக்கப்படும் செயல்பாடுகளாக மாற்றுகிறது. டெக்கரேட்டர் செயல்பாட்டிற்கு அனுப்பப்படும் துல்லியமான வாதங்கள் பயன்படுத்தப்படும் டெக்கரேட்டரின் வகையைப் (வகுப்பு, முறை, பண்பு அல்லது அளவுரு) பொறுத்தது. வெவ்வேறு வகையான டெக்கரேட்டர்களையும் அவற்றின் அந்தந்த வாதங்களையும் ஆராய்வோம்:

• வகுப்பு டெக்கரேட்டர்கள்: ஒரு வகுப்பு அறிவிப்புக்கு பயன்படுத்தப்படுகிறது. அவை வகுப்பின் கன்ஸ்ட்ரக்டர் செயல்பாட்டை ஒரு வாதமாக எடுத்துக்கொள்கின்றன, மேலும் வகுப்பை மாற்றியமைக்க, நிலையான பண்புகளைச் சேர்க்க அல்லது சில வெளிப்புற அமைப்புடன் வகுப்பைப் பதிவு செய்யப் பயன்படுத்தப்படலாம்.
• முறை டெக்கரேட்டர்கள்: ஒரு முறை அறிவிப்புக்கு பயன்படுத்தப்படுகிறது. அவை மூன்று வாதங்களைப் பெறுகின்றன: வகுப்பின் புரோட்டோடைப், முறையின் பெயர் மற்றும் முறைக்கான ஒரு பண்பு விவரிப்பு. முறை டெக்கரேட்டர்கள் முறையையே மாற்றியமைக்க, முறை செயல்படுத்தப்படுவதற்கு முன்னும் பின்னும் செயல்பாட்டைச் சேர்க்க அல்லது முறையை முழுவதுமாக மாற்றவும் உங்களை அனுமதிக்கின்றன.
• பண்பு டெக்கரேட்டர்கள்: ஒரு பண்பு அறிவிப்புக்கு பயன்படுத்தப்படுகிறது. அவை இரண்டு வாதங்களைப் பெறுகின்றன: வகுப்பின் புரோட்டோடைப் மற்றும் பண்பின் பெயர். அவை சரிபார்ப்பு அல்லது இயல்புநிலை மதிப்புகளைச் சேர்ப்பது போன்ற பண்பின் நடத்தையை மாற்றியமைக்க உதவுகின்றன.
• அளவுரு டெக்கரேட்டர்கள்: ஒரு முறை அறிவிப்பில் உள்ள ஒரு அளவுருவுக்குப் பயன்படுத்தப்படுகிறது. அவை மூன்று வாதங்களைப் பெறுகின்றன: வகுப்பின் புரோட்டோடைப், முறையின் பெயர் மற்றும் அளவுரு பட்டியலில் அளவுருவின் குறியீட்டெண். அளவுரு டெக்கரேட்டர்கள் பெரும்பாலும் சார்புநிலை உட்செலுத்தலுக்காக அல்லது அளவுரு மதிப்புகளைச் சரிபார்க்கப் பயன்படுத்தப்படுகின்றன.

இந்த வாதங்களின் கையொப்பங்களைப் புரிந்துகொள்வது பயனுள்ள டெக்கரேட்டர்களை எழுதுவதற்கு முக்கியமானது.

டெக்கரேட்டர்களின் வகைகள்

டைப்ஸ்கிரிப்ட் பல வகையான டெக்கரேட்டர்களை ஆதரிக்கிறது, ஒவ்வொன்றும் ஒரு குறிப்பிட்ட நோக்கத்திற்காகச் செயல்படுகின்றன:

• வகுப்பு டெக்கரேட்டர்கள்: வகுப்புகளை அலங்கரிக்கப் பயன்படுகிறது, இது வகுப்பையே மாற்றியமைக்க அல்லது மெட்டாடேட்டாவைச் சேர்க்க உங்களை அனுமதிக்கிறது.
• முறை டெக்கரேட்டர்கள்: முறைகளை அலங்கரிக்கப் பயன்படுகிறது, இது முறை அழைப்புக்கு முன்னும் பின்னும் நடத்தையைச் சேர்க்க அல்லது முறை செயலாக்கத்தையே மாற்றவும் உதவுகிறது.
• பண்பு டெக்கரேட்டர்கள்: பண்புகளை அலங்கரிக்கப் பயன்படுகிறது, இது சரிபார்ப்பு, இயல்புநிலை மதிப்புகள் அல்லது பண்பின் நடத்தையை மாற்றியமைக்க உங்களை அனுமதிக்கிறது.
• அளவுரு டெக்கரேட்டர்கள்: ஒரு முறையின் அளவுருக்களை அலங்கரிக்கப் பயன்படுகிறது, பெரும்பாலும் சார்புநிலை உட்செலுத்தல் அல்லது அளவுரு சரிபார்ப்புக்காகப் பயன்படுத்தப்படுகிறது.
• அணுகல் டெக்கரேட்டர்கள்: கெட்டர்கள் மற்றும் செட்டர்களை அலங்கரிக்கின்றன. இந்த டெக்கரேட்டர்கள் செயல்பாட்டு ரீதியாக பண்பு டெக்கரேட்டர்களைப் போலவே இருக்கின்றன, ஆனால் குறிப்பாக அணுகல்களை இலக்காகக் கொண்டுள்ளன. அவை முறை டெக்கரேட்டர்களைப் போன்ற வாதங்களைப் பெறுகின்றன, ஆனால் கெட்டர் அல்லது செட்டரைக் குறிக்கின்றன.

நடைமுறை எடுத்துக்காட்டுகள்

டைப்ஸ்கிரிப்டில் டெக்கரேட்டர்களை எவ்வாறு பயன்படுத்துவது என்பதை விளக்க சில நடைமுறை எடுத்துக்காட்டுகளை ஆராய்வோம்.

வகுப்பு டெக்கரேட்டர் எடுத்துக்காட்டு: நேரமுத்திரை சேர்த்தல்

ஒரு வகுப்பின் ஒவ்வொரு நிகழ்விற்கும் ஒரு நேரமுத்திரையைச் சேர்க்க விரும்புகிறீர்கள் என்று கற்பனை செய்து பாருங்கள். இதைச் செய்ய நீங்கள் ஒரு வகுப்பு டெக்கரேட்டரைப் பயன்படுத்தலாம்:

            
function addTimestamp<T extends { new(...args: any[]): {} }>(constructor: T) {
  return class extends constructor {
    timestamp = Date.now();
  };
}

@addTimestamp
class MyClass {
  constructor() {
    console.log('MyClass created');
  }
}

const instance = new MyClass();
console.log(instance.timestamp); // Output: a timestamp

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், `addTimestamp` டெக்கரேட்டர் வகுப்பு நிகழ்விற்கு ஒரு `timestamp` பண்பைச் சேர்க்கிறது. இது அசல் வகுப்பு வரையறையை நேரடியாக மாற்றாமல் மதிப்புமிக்க பிழைத்திருத்த அல்லது தணிக்கைத் தடம் தகவல்களை வழங்குகிறது.

முறை டெக்கரேட்டர் எடுத்துக்காட்டு: முறை அழைப்புகளை பதிவு செய்தல்

முறை அழைப்புகளையும் அவற்றின் வாதங்களையும் பதிவு செய்ய நீங்கள் ஒரு முறை டெக்கரேட்டரைப் பயன்படுத்தலாம்:

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

  descriptor.value = function (...args: any[]) {
    console.log(`[LOG] Method ${key} called with arguments:`, args);
    const result = originalMethod.apply(this, args);
    console.log(`[LOG] Method ${key} returned:`, result);
    return result;
  };

  return descriptor;
}

class Greeter {
  @logMethod
  greet(message: string): string {
    return `Hello, ${message}!`;
  }
}

const greeter = new Greeter();
 greeter.greet('World');
// Output:
// [LOG] Method greet called with arguments: [ 'World' ]
// [LOG] Method greet returned: Hello, World!

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டு `greet` முறை ஒவ்வொரு முறை அழைக்கப்படும்போதும், அதன் வாதங்கள் மற்றும் திரும்பும் மதிப்புடன் பதிவு செய்கிறது. இது மிகவும் சிக்கலான பயன்பாடுகளில் பிழைத்திருத்தம் மற்றும் கண்காணிப்புக்கு மிகவும் பயனுள்ளதாக இருக்கும்.

பண்பு டெக்கரேட்டர் எடுத்துக்காட்டு: சரிபார்ப்பைச் சேர்த்தல்

அடிப்படை சரிபார்ப்பைச் சேர்க்கும் ஒரு பண்பு டெக்கரேட்டரின் எடுத்துக்காட்டு இங்கே:

            
function validate(target: any, key: string) {
  let value: any;

  const getter = function () {
    return value;
  };

  const setter = function (newValue: any) {
    if (typeof newValue !== 'number') {
      console.warn(`[WARN] Invalid property value: ${key}. Expected a number.`);
      return;
    }
    value = newValue;
  };

  Object.defineProperty(target, key, {
    get: getter,
    set: setter,
    enumerable: true,
    configurable: true,
  });
}

class Person {
  @validate
  age: number; //  <- Property with validation
}

const person = new Person();
person.age = 'abc'; // Logs a warning
person.age = 30;   // Sets the value
console.log(person.age); // Output: 30

            

              
                Copy
              
            
          

இந்த `validate` டெக்கரேட்டரில், ஒதுக்கப்பட்ட மதிப்பு ஒரு எண்ணா என்பதைச் சரிபார்க்கிறோம். இல்லையென்றால், நாங்கள் ஒரு எச்சரிக்கையைப் பதிவு செய்கிறோம். இது ஒரு எளிய எடுத்துக்காட்டு, ஆனால் தரவு ஒருமைப்பாட்டைச் செயல்படுத்த டெக்கரேட்டர்கள் எவ்வாறு பயன்படுத்தப்படலாம் என்பதைக் காட்டுகிறது.

அளவுரு டெக்கரேட்டர் எடுத்துக்காட்டு: சார்புநிலை உட்செலுத்துதல் (எளிமைப்படுத்தப்பட்டது)

முழுமையான சார்புநிலை உட்செலுத்துதல் கட்டமைப்புகள் பெரும்பாலும் மிகவும் அதிநவீன வழிமுறைகளைப் பயன்படுத்தினாலும், உட்செலுத்தலுக்காக அளவுருக்களைக் குறிக்க டெக்கரேட்டர்களும் பயன்படுத்தப்படலாம். இந்த எடுத்துக்காட்டு ஒரு எளிமைப்படுத்தப்பட்ட விளக்கமாகும்:

            
// This is a simplification and doesn't handle actual injection.  Real DI is more complex.
function Inject(service: any) {
  return function (target: any, propertyKey: string | symbol, parameterIndex: number) {
    // Store the service somewhere (e.g., in a static property or a map)
    if (!target.injectedServices) {
      target.injectedServices = {};
    }
    target.injectedServices[parameterIndex] = service;
  };
}

class MyService {
  doSomething() { /* ... */ }
}

class MyComponent {
  constructor(@Inject(MyService) private myService: MyService) {
    // In a real system, the DI container would resolve 'myService' here.
    console.log('MyComponent constructed with:', myService.constructor.name); //Example
  }
}

const component = new MyComponent(new MyService());  // Injecting the service (simplified).

            

              
                Copy
              
            
          

`Inject` டெக்கரேட்டர் ஒரு அளவுருவுக்கு ஒரு சேவை தேவை என்பதைக் குறிக்கிறது. இந்த எடுத்துக்காட்டு, ஒரு டெக்கரேட்டர் சார்புநிலை உட்செலுத்தல் தேவைப்படும் அளவுருக்களை எவ்வாறு அடையாளம் காணலாம் என்பதைக் காட்டுகிறது (ஆனால் ஒரு உண்மையான கட்டமைப்பு சேவைத் தீர்வை நிர்வகிக்க வேண்டும்).

டெக்கரேட்டர்களைப் பயன்படுத்துவதன் நன்மைகள்

• குறியீடு மறுபயன்பாடு: டெக்கரேட்டர்கள் பொதுவான செயல்பாடுகளை (பதிவு செய்தல், சரிபார்ப்பு மற்றும் அங்கீகாரம் போன்றவை) மீண்டும் பயன்படுத்தக்கூடிய கூறுகளாக இணைக்க உங்களை அனுமதிக்கின்றன.
• கவலைகளைப் பிரித்தல்: டெக்கரேட்டர்கள் உங்கள் வகுப்புகள் மற்றும் முறைகளின் முக்கிய தர்க்கத்தைச் சுத்தமாகவும் கவனம் செலுத்தியும் வைத்திருப்பதன் மூலம் கவலைகளைப் பிரிக்க உதவுகின்றன.
• மேம்பட்ட வாசிப்புத்திறன்: டெக்கரேட்டர்கள் ஒரு வகுப்பு, முறை அல்லது பண்பின் நோக்கத்தைத் தெளிவாகக் குறிப்பிடுவதன் மூலம் உங்கள் குறியீட்டை மேலும் வாசிக்கக்கூடியதாக மாற்றும்.
• குறைக்கப்பட்ட கொதிகலன் குறியீடு: டெக்கரேட்டர்கள் குறுக்கு வெட்டு கவலைகளைச் செயல்படுத்தத் தேவையான கொதிகலன் குறியீட்டின் அளவைக் குறைக்கின்றன.
• விரிவாக்கத்தன்மை: டெக்கரேட்டர்கள் அசல் மூலக் கோப்புகளை மாற்றாமல் உங்கள் குறியீட்டை விரிவுபடுத்துவதை எளிதாக்குகின்றன.
• மெட்டாடேட்டா-இயக்கப்படும் கட்டமைப்பு: டெக்கரேட்டர்கள் மெட்டாடேட்டா-இயக்கப்படும் கட்டமைப்புகளை உருவாக்க உங்களை அனுமதிக்கின்றன, அங்கு உங்கள் குறியீட்டின் நடத்தை குறிப்புகளால் கட்டுப்படுத்தப்படுகிறது.

டெக்கரேட்டர்களைப் பயன்படுத்துவதற்கான சிறந்த நடைமுறைகள்

• டெக்கரேட்டர்களை எளிமையாக வைத்திருங்கள்: டெக்கரேட்டர்கள் பொதுவாகச் சுருக்கமாகவும் ஒரு குறிப்பிட்ட பணியில் கவனம் செலுத்தியும் இருக்க வேண்டும். சிக்கலான தர்க்கம் அவற்றைப் புரிந்துகொள்வதையும் பராமரிப்பதையும் கடினமாக்கும்.
• இணைப்பைக் கருத்தில் கொள்ளுங்கள்: ஒரே உறுப்பில் பல டெக்கரேட்டர்களை நீங்கள் இணைக்கலாம், ஆனால் பயன்பாட்டு வரிசை சரியானது என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள். (குறிப்பு: ஒரே உறுப்பு வகையிலான டெக்கரேட்டர்களுக்கு பயன்பாட்டு வரிசை கீழிருந்து மேலாக உள்ளது).
• சோதனை: உங்கள் டெக்கரேட்டர்கள் எதிர்பார்த்தபடி செயல்படுகின்றனவா மற்றும் எதிர்பாராத பக்க விளைவுகளை அறிமுகப்படுத்தவில்லையா என்பதை உறுதிப்படுத்த அவற்றை முழுமையாகச் சோதிக்கவும். உங்கள் டெக்கரேட்டர்களால் உருவாக்கப்படும் செயல்பாடுகளுக்கு யூனிட் சோதனைகளை எழுதுங்கள்.
• ஆவணப்படுத்தல்: உங்கள் டெக்கரேட்டர்களை அவற்றின் நோக்கம், வாதங்கள் மற்றும் ஏதேனும் பக்க விளைவுகள் உட்பட தெளிவாக ஆவணப்படுத்துங்கள்.
• பொருத்தமான பெயர்களைத் தேர்வு செய்யவும்: குறியீட்டின் வாசிப்புத்திறனை மேம்படுத்த உங்கள் டெக்கரேட்டர்களுக்கு விளக்கமான மற்றும் தகவல் தரும் பெயர்களைக் கொடுங்கள்.
• அதிகப்படியான பயன்பாட்டைத் தவிர்க்கவும்: டெக்கரேட்டர்கள் சக்திவாய்ந்தவை என்றாலும், அவற்றை அதிகமாகப் பயன்படுத்துவதைத் தவிர்க்கவும். அவற்றின் நன்மைகளை சாத்தியமான சிக்கலுடன் சமநிலைப்படுத்துங்கள்.
• செயல்படுத்தும் வரிசையைப் புரிந்து கொள்ளுங்கள்: டெக்கரேட்டர்களின் செயல்படுத்தும் வரிசையைக் கவனத்தில் கொள்ளுங்கள். வகுப்பு டெக்கரேட்டர்கள் முதலில் பயன்படுத்தப்படுகின்றன, அதைத் தொடர்ந்து பண்பு டெக்கரேட்டர்கள், பின்னர் முறை டெக்கரேட்டர்கள், இறுதியாக அளவுரு டெக்கரேட்டர்கள். ஒரு வகைக்குள், பயன்பாடு கீழிருந்து மேலாக நிகழ்கிறது.
• வகை பாதுகாப்பு: உங்கள் டெக்கரேட்டர்களுக்குள் வகை பாதுகாப்பை உறுதிப்படுத்த டைப்ஸ்கிரிப்டின் வகை அமைப்பை எப்போதும் திறம்படப் பயன்படுத்துங்கள். உங்கள் டெக்கரேட்டர்கள் எதிர்பார்க்கப்படும் வகைகளுடன் சரியாகச் செயல்படுவதை உறுதிசெய்ய ஜெனரிக்குகள் மற்றும் வகை குறிப்புகளைப் பயன்படுத்தவும்.
• இணக்கத்தன்மை: நீங்கள் பயன்படுத்தும் டைப்ஸ்கிரிப்ட் பதிப்பைப் பற்றி எச்சரிக்கையாக இருங்கள். டெக்கரேட்டர்கள் ஒரு டைப்ஸ்கிரிப்ட் அம்சம் மற்றும் அவற்றின் கிடைக்கும் தன்மை மற்றும் நடத்தை பதிப்போடு பிணைக்கப்பட்டுள்ளது. நீங்கள் ஒரு இணக்கமான டைப்ஸ்கிரிப்ட் பதிப்பைப் பயன்படுத்துகிறீர்கள் என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள்.

மேம்பட்ட கருத்துக்கள்

டெக்கரேட்டர் ஃபேக்டரிகள்

டெக்கரேட்டர் ஃபேக்டரிகள் என்பது டெக்கரேட்டர் செயல்பாடுகளைத் தரும் செயல்பாடுகள் ஆகும். இது உங்கள் டெக்கரேட்டர்களுக்கு வாதங்களை அனுப்ப உங்களை அனுமதிக்கிறது, அவற்றை மேலும் நெகிழ்வானதாகவும் கட்டமைக்கக்கூடியதாகவும் ஆக்குகிறது. எடுத்துக்காட்டாக, சரிபார்ப்பு விதிகளைக் குறிப்பிட உங்களை அனுமதிக்கும் ஒரு சரிபார்ப்பு டெக்கரேட்டர் ஃபேக்டரியை நீங்கள் உருவாக்கலாம்:

            
function validate(minLength: number) {
  return function (target: any, key: string) {
    let value: string;

    const getter = function () {
      return value;
    };

    const setter = function (newValue: string) {
      if (typeof newValue !== 'string') {
        console.warn(`[WARN] Invalid property value: ${key}. Expected a string.`);
        return;
      }
      if (newValue.length < minLength) {
        console.warn(`[WARN] ${key} must be at least ${minLength} characters long.`);
        return;
      }
      value = newValue;
    };

    Object.defineProperty(target, key, {
      get: getter,
      set: setter,
      enumerable: true,
      configurable: true,
    });
  };
}

class Person {
  @validate(3) // Validate with minimum length of 3
  name: string;
}

const person = new Person();
person.name = 'Jo';
console.log(person.name); // Logs a warning, sets value.
person.name = 'John';
console.log(person.name); // Output: John

            

              
                Copy
              
            
          

டெக்கரேட்டர் ஃபேக்டரிகள் டெக்கரேட்டர்களை மிகவும் மாற்றியமைக்கக்கூடியதாக ஆக்குகின்றன.

டெக்கரேட்டர்களை இணைத்தல்

ஒரே உறுப்பில் பல டெக்கரேட்டர்களைப் பயன்படுத்தலாம். அவை பயன்படுத்தப்படும் வரிசை சில நேரங்களில் முக்கியமானதாக இருக்கலாம். வரிசை கீழிருந்து மேலாக (எழுதப்பட்டபடி) உள்ளது. எடுத்துக்காட்டாக:

            
function first() {
  console.log('first(): factory evaluated');
  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    console.log('first(): called');
  }
}

function second() {
  console.log('second(): factory evaluated');
  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    console.log('second(): called');
  }
}

class ExampleClass {
  @first()
  @second()
  method() {}
}

// Output:
// second(): factory evaluated
// first(): factory evaluated
// second(): called
// first(): called

            

              
                Copy
              
            
          

ஃபேக்டரி செயல்பாடுகள் அவை தோன்றும் வரிசையில் மதிப்பீடு செய்யப்படுகின்றன, ஆனால் டெக்கரேட்டர் செயல்பாடுகள் தலைகீழ் வரிசையில் அழைக்கப்படுகின்றன என்பதை கவனியுங்கள். உங்கள் டெக்கரேட்டர்கள் ஒன்றையொன்று சார்ந்து இருந்தால் இந்த வரிசையைப் புரிந்து கொள்ளுங்கள்.

டெக்கரேட்டர்கள் மற்றும் மெட்டாடேட்டா பிரதிபலிப்பு

டெக்கரேட்டர்கள் மெட்டாடேட்டா பிரதிபலிப்புடன் (எ.கா., `reflect-metadata` போன்ற நூலகங்களைப் பயன்படுத்தி) கைகோர்த்து மேலும் ஆற்றல்மிக்க நடத்தையைப் பெறலாம். இது, எடுத்துக்காட்டாக, அலங்கரிக்கப்பட்ட கூறுகளைப் பற்றிய தகவல்களை இயக்க நேரத்தில் சேமித்து மீட்டெடுக்க உங்களை அனுமதிக்கிறது. இது குறிப்பாக கட்டமைப்புகள் மற்றும் சார்புநிலை உட்செலுத்துதல் அமைப்புகளில் உதவியாக இருக்கும். டெக்கரேட்டர்கள் வகுப்புகள் அல்லது முறைகளை மெட்டாடேட்டாவுடன் குறிக்கலாம், பின்னர் அந்த மெட்டாடேட்டாவைக் கண்டறிந்து பயன்படுத்த பிரதிபலிப்பைப் பயன்படுத்தலாம்.

பிரபலமான கட்டமைப்புகள் மற்றும் நூலகங்களில் டெக்கரேட்டர்கள்

டெக்கரேட்டர்கள் பல நவீன ஜாவாஸ்கிரிப்ட் கட்டமைப்புகள் மற்றும் நூலகங்களின் ஒருங்கிணைந்த பகுதிகளாக மாறியுள்ளன. அவற்றின் பயன்பாட்டை அறிந்துகொள்வது கட்டமைப்பின் கட்டடக்கலை மற்றும் அது பல்வேறு பணிகளை எவ்வாறு நெறிப்படுத்துகிறது என்பதைப் புரிந்துகொள்ள உதவுகிறது.

• ஆங்குலர் (Angular): ஆங்குலர் சார்புநிலை உட்செலுத்தல், கூறு வரையறை (எ.கா., `@Component`), பண்பு பிணைப்பு (`@Input`, `@Output`), மற்றும் பலவற்றிற்காக டெக்கரேட்டர்களை பெரிதும் பயன்படுத்துகிறது. இந்த டெக்கரேட்டர்களைப் புரிந்துகொள்வது ஆங்குலருடன் வேலை செய்வதற்கு அவசியமானது.
• நெஸ்ட்ஜேஎஸ் (NestJS): நெஸ்ட்ஜேஎஸ், ஒரு முற்போக்கான நோட்.ஜேஎஸ் கட்டமைப்பு, மட்டு மற்றும் பராமரிக்கக்கூடிய பயன்பாடுகளை உருவாக்குவதற்கு டெக்கரேட்டர்களை விரிவாகப் பயன்படுத்துகிறது. கட்டுப்படுத்திகள், சேவைகள், தொகுதிகள் மற்றும் பிற முக்கிய கூறுகளை வரையறுக்க டெக்கரேட்டர்கள் பயன்படுத்தப்படுகின்றன. இது பாதை வரையறை, சார்புநிலை உட்செலுத்தல் மற்றும் கோரிக்கை சரிபார்ப்பு (எ.கா., `@Controller`, `@Get`, `@Post`, `@Injectable`) ஆகியவற்றிற்கு டெக்கரேட்டர்களை விரிவாகப் பயன்படுத்துகிறது.
• டைப்ஓஆர்எம் (TypeORM): டைப்ஓஆர்எம், டைப்ஸ்கிரிப்ட்டுக்கான ஒரு ஓஆர்எம் (பொருள்-தொடர்பு மேப்பர்), வகுப்புகளை தரவுத்தள அட்டவணைகளுடன் மேப்பிங் செய்ய, நெடுவரிசைகளை வரையறுக்க, மற்றும் உறவுகளை (எ.கா., `@Entity`, `@Column`, `@PrimaryGeneratedColumn`, `@OneToMany`) வரையறுக்க டெக்கரேட்டர்களைப் பயன்படுத்துகிறது.
• மாப்எக்ஸ் (MobX): மாப்எக்ஸ், ஒரு நிலை மேலாண்மை நூலகம், பண்புகளை கவனிக்கத்தக்கதாக (எ.கா., `@observable`) மற்றும் முறைகளை செயல்களாக (எ.கா., `@action`) குறிக்க டெக்கரேட்டர்களைப் பயன்படுத்துகிறது, இது பயன்பாட்டு நிலை மாற்றங்களை நிர்வகிப்பதையும் ಪ್ರತிக்ரியையாற்றுவதையும் எளிதாக்குகிறது.

இந்த கட்டமைப்புகள் மற்றும் நூலகங்கள் டெக்கரேட்டர்கள் குறியீடு அமைப்பை எவ்வாறு மேம்படுத்துகின்றன, பொதுவான பணிகளை எளிதாக்குகின்றன, மற்றும் நிஜ-உலக பயன்பாடுகளில் பராமரிப்பை ஊக்குவிக்கின்றன என்பதைக் காட்டுகின்றன.

சவால்கள் மற்றும் கருத்தில் கொள்ள வேண்டியவை

• கற்றல் வளைவு: டெக்கரேட்டர்கள் மேம்பாட்டை எளிதாக்கினாலும், அவற்றுக்கு ஒரு கற்றல் வளைவு உள்ளது. அவை எவ்வாறு செயல்படுகின்றன மற்றும் அவற்றை எவ்வாறு திறம்படப் பயன்படுத்துவது என்பதைப் புரிந்துகொள்ள நேரம் எடுக்கும்.
• பிழைத்திருத்தம்: டெக்கரேட்டர்களை பிழைத்திருத்தம் செய்வது சில நேரங்களில் சவாலானது, ஏனெனில் அவை வடிவமைப்பு நேரத்தில் குறியீட்டை மாற்றியமைக்கின்றன. உங்கள் குறியீட்டை திறம்பட பிழைத்திருத்தம் செய்ய உங்கள் இடைநிறுத்த புள்ளிகளை எங்கே வைக்க வேண்டும் என்பதைப் புரிந்துகொள்வதை உறுதிப்படுத்திக் கொள்ளுங்கள்.
• பதிப்பு இணக்கத்தன்மை: டெக்கரேட்டர்கள் ஒரு டைப்ஸ்கிரிப்ட் அம்சம். பயன்பாட்டில் உள்ள டைப்ஸ்கிரிப்ட் பதிப்போடு டெக்கரேட்டர் இணக்கத்தன்மையை எப்போதும் சரிபார்க்கவும்.
• அதிகப்படியான பயன்பாடு: டெக்கரேட்டர்களை அதிகமாகப் பயன்படுத்துவது குறியீட்டைப் புரிந்துகொள்வதைக் கடினமாக்கும். அவற்றை நியாயமாகப் பயன்படுத்துங்கள், மேலும் அவற்றின் நன்மைகளை அதிகரித்த சிக்கலுக்கான சாத்தியக்கூறுடன் சமநிலைப்படுத்துங்கள். ஒரு எளிய செயல்பாடு அல்லது பயன்பாட்டுக் கருவி வேலையைச் செய்ய முடிந்தால், அதைத் தேர்ந்தெடுக்கவும்.
• வடிவமைப்பு நேரம் மற்றும் இயக்க நேரம்: டெக்கரேட்டர்கள் வடிவமைப்பு நேரத்தில் (குறியீடு தொகுக்கப்படும்போது) இயங்குகின்றன என்பதை நினைவில் கொள்ளுங்கள், எனவே அவை பொதுவாக இயக்க நேரத்தில் செய்யப்பட வேண்டிய தர்க்கத்திற்கு பயன்படுத்தப்படுவதில்லை.
• கம்பைலர் வெளியீடு: கம்பைலர் வெளியீட்டைப் பற்றி எச்சரிக்கையாக இருங்கள். டைப்ஸ்கிரிப்ட் கம்பைலர் டெக்கரேட்டர்களை சமமான ஜாவாஸ்கிரிப்ட் குறியீடாக மாற்றுகிறது. டெக்கரேட்டர்கள் எவ்வாறு செயல்படுகின்றன என்பதைப் பற்றிய ஆழமான புரிதலைப் பெற உருவாக்கப்பட்ட ஜாவாஸ்கிரிப்ட் குறியீட்டை ஆராயுங்கள்.

முடிவுரை

டைப்ஸ்கிரிப்ட் டெக்கரேட்டர்கள் ஒரு சக்திவாய்ந்த மெட்டாபுரோகிராமிங் அம்சம், இது உங்கள் குறியீட்டின் கட்டமைப்பு, மறுபயன்பாடு மற்றும் பராமரிப்பை கணிசமாக மேம்படுத்தும். வெவ்வேறு வகையான டெக்கரேட்டர்கள், அவை எவ்வாறு செயல்படுகின்றன, மற்றும் அவற்றின் பயன்பாட்டிற்கான சிறந்த நடைமுறைகளைப் புரிந்துகொள்வதன் மூலம், நீங்கள் அவற்றை சுத்தமான, மேலும் வெளிப்படையான, மற்றும் மேலும் திறமையான பயன்பாடுகளை உருவாக்கப் பயன்படுத்தலாம். நீங்கள் ஒரு எளிய பயன்பாட்டை அல்லது ஒரு சிக்கலான நிறுவன-நிலை அமைப்பை உருவாக்கினாலும், டெக்கரேட்டர்கள் உங்கள் மேம்பாட்டு பணிப்பாய்வை மேம்படுத்த ஒரு மதிப்புமிக்க கருவியை வழங்குகின்றன. டெக்கரேட்டர்களை ஏற்றுக்கொள்வது குறியீட்டின் தரத்தில் குறிப்பிடத்தக்க முன்னேற்றத்தை அனுமதிக்கிறது. ஆங்குலர் மற்றும் நெஸ்ட்ஜேஎஸ் போன்ற பிரபலமான கட்டமைப்புகளுக்குள் டெக்கரேட்டர்கள் எவ்வாறு ஒருங்கிணைக்கப்படுகின்றன என்பதைப் புரிந்துகொள்வதன் மூலம், டெவலப்பர்கள் அளவிடக்கூடிய, பராமரிக்கக்கூடிய மற்றும் வலுவான பயன்பாடுகளை உருவாக்க அவற்றின் முழு திறனையும் பயன்படுத்த முடியும். அவற்றின் நோக்கத்தைப் புரிந்துகொள்வதும், பொருத்தமான சூழல்களில் அவற்றை எவ்வாறு பயன்படுத்துவது என்பதும் முக்கியம், இது நன்மைகள் எந்தவொரு சாத்தியமான குறைபாடுகளையும் விட அதிகமாக இருப்பதை உறுதிசெய்கிறது.

டெக்கரேட்டர்களை திறம்பட செயல்படுத்துவதன் மூலம், உங்கள் குறியீட்டை அதிக கட்டமைப்பு, பராமரிப்புத்திறன் மற்றும் செயல்திறனுடன் மேம்படுத்தலாம். இந்த வழிகாட்டி டைப்ஸ்கிரிப்ட் டெக்கரேட்டர்களை எவ்வாறு பயன்படுத்துவது என்பது பற்றிய ஒரு விரிவான கண்ணோட்டத்தை வழங்குகிறது. இந்த அறிவுடன், நீங்கள் சிறந்த மற்றும் மேலும் பராமரிக்கக்கூடிய டைப்ஸ்கிரிப்ட் குறியீட்டை உருவாக்க அதிகாரம் பெற்றுள்ளீர்கள். முன்னேறிச் சென்று அலங்கரியுங்கள்!