M

MLOG

தமிழ்

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

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

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

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

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

டெக்கரேட்டர்கள் `@` சின்னத்தைத் தொடர்ந்து ஒரு செயல்பாட்டு அழைப்பைப் பயன்படுத்தி வரையறுக்கப்படுகின்றன (எ.கா., `@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

இந்த எடுத்துக்காட்டில், `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!

இந்த எடுத்துக்காட்டு `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

இந்த `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).

`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

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

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

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


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

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

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

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

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

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

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

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

முடிவுரை

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

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