ജാവാസ്ക്രിപ്റ്റ് ഡെക്കറേറ്ററുകൾ: മെറ്റാഡാറ്റ പ്രോഗ്രാമിംഗും എഒപി പാറ്റേണുകളും

ജാവാസ്ക്രിപ്റ്റ് ഡെക്കറേറ്ററുകൾ ഒരു ശക്തവും പ്രകടിപ്പിക്കാൻ കഴിയുന്നതുമായ മെറ്റാപ്രോഗ്രാമിംഗ് സവിശേഷതയാണ്. ഇത് ക്ലാസുകൾ, മെത്തേഡുകൾ, പ്രോപ്പർട്ടികൾ, പാരാമീറ്ററുകൾ എന്നിവയുടെ സ്വഭാവം ഒരു പ്രഖ്യാപിതവും പുനരുപയോഗിക്കാവുന്നതുമായ രീതിയിൽ പരിഷ്കരിക്കാനോ മെച്ചപ്പെടുത്താനോ നിങ്ങളെ അനുവദിക്കുന്നു. മെറ്റാഡാറ്റ ചേർക്കുന്നതിനും ആസ്പെക്റ്റ്-ഓറിയന്റഡ് പ്രോഗ്രാമിംഗ് (AOP) തത്വങ്ങൾ നടപ്പിലാക്കുന്നതിനും ഇവ ഒരു സംക്ഷിപ്ത വാക്യഘടന നൽകുന്നു, ഇത് കോഡ് പുനരുപയോഗം, വായനാക്ഷമത, പരിപാലനം എന്നിവ മെച്ചപ്പെടുത്തുന്നു. ഈ സമഗ്രമായ ഗൈഡ് ജാവാസ്ക്രിപ്റ്റ് ഡെക്കറേറ്ററുകളെ വിശദമായി പരിശോധിക്കും, അവയുടെ വാക്യഘടന, ഉപയോഗം, വിവിധ സാഹചര്യങ്ങളിലെ പ്രയോഗങ്ങൾ എന്നിവ ഉൾക്കൊള്ളുന്നു. ഔദ്യോഗികമായി ഇപ്പോഴും വികസിച്ചുകൊണ്ടിരിക്കുന്ന ഒരു നിർദ്ദേശമാണെങ്കിലും, ആംഗുലർ, നെസ്റ്റ്ജെഎസ് പോലുള്ള ഫ്രെയിംവർക്കുകളിൽ ഡെക്കറേറ്ററുകൾ വ്യാപകമായി ഉപയോഗിക്കപ്പെടുന്നു, കൂടാതെ ജാവാസ്ക്രിപ്റ്റ് വികസനത്തിൽ അവയുടെ സ്വാധീനം നിഷേധിക്കാനാവാത്തതാണ്.

എന്താണ് ജാവാസ്ക്രിപ്റ്റ് ഡെക്കറേറ്ററുകൾ?

ക്ലാസ് പ്രഖ്യാപനം, മെത്തേഡ്, അക്സസ്സർ, പ്രോപ്പർട്ടി അല്ലെങ്കിൽ പാരാമീറ്റർ എന്നിവയിൽ ഘടിപ്പിക്കാൻ കഴിയുന്ന ഒരു പ്രത്യേക തരം പ്രഖ്യാപനമാണ് ഡെക്കറേറ്ററുകൾ. അവ @expression ഫോം ഉപയോഗിക്കുന്നു, ഇവിടെ expression എന്നത് ഡെക്കറേറ്റ് ചെയ്ത പ്രഖ്യാപനത്തെക്കുറിച്ചുള്ള വിവരങ്ങളോടെ റൺടൈമിൽ വിളിക്കപ്പെടുന്ന ഒരു ഫംഗ്‌ഷനായിരിക്കണം. പ്രധാനമായും, ഡെക്കറേറ്ററുകൾ ഡെക്കറേറ്റ് ചെയ്ത ഘടകത്തെ പൊതിയുകയോ പരിഷ്കരിക്കുകയോ ചെയ്യുന്ന ഫംഗ്ഷനുകളായി പ്രവർത്തിക്കുന്നു, യഥാർത്ഥ കോഡ് നേരിട്ട് പരിഷ്കരിക്കാതെ അധിക പ്രവർത്തനക്ഷമതയോ മെറ്റാഡാറ്റയോ ചേർക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

കോഡ് ഘടകങ്ങളിൽ ഘടിപ്പിക്കാൻ കഴിയുന്ന വ്യാഖ്യാനങ്ങളോ അടയാളങ്ങളോ ആയി ഡെക്കറേറ്ററുകളെക്കുറിച്ച് ചിന്തിക്കുക. ഈ അടയാളങ്ങൾ റൺടൈമിൽ ലോഗിംഗ്, വാലിഡേഷൻ, അംഗീകാരം അല്ലെങ്കിൽ ഡിപൻഡൻസി ഇൻജെക്ഷൻ പോലുള്ള വിവിധ ജോലികൾ നിർവഹിക്കുന്നതിനായി പ്രോസസ്സ് ചെയ്യാൻ കഴിയും. ആശങ്കകളെ വേർതിരിക്കുന്നതിലൂടെയും ബോയിലർ പ്ലേറ്റ് കുറയ്ക്കുന്നതിലൂടെയും ഡെക്കറേറ്ററുകൾ വൃത്തിയുള്ളതും കൂടുതൽ മോഡുലാറുമായ കോഡ് ഘടനയെ പ്രോത്സാഹിപ്പിക്കുന്നു.

ഡെക്കറേറ്ററുകൾ ഉപയോഗിക്കുന്നതിന്റെ പ്രയോജനങ്ങൾ

• മെച്ചപ്പെട്ട കോഡ് പുനരുപയോഗം: നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ ഒന്നിലധികം ഭാഗങ്ങളിൽ പ്രയോഗിക്കാൻ കഴിയുന്ന പുനരുപയോഗിക്കാവുന്ന ഘടകങ്ങളിലേക്ക് പൊതുവായ സ്വഭാവം ഉൾക്കൊള്ളിക്കാൻ ഡെക്കറേറ്ററുകൾ നിങ്ങളെ അനുവദിക്കുന്നു. ഇത് കോഡ് ഡ്യൂപ്ലിക്കേഷൻ കുറയ്ക്കുകയും സ്ഥിരത പ്രോത്സാഹിപ്പിക്കുകയും ചെയ്യുന്നു.
• മെച്ചപ്പെട്ട വായനാക്ഷമത: ക്രോസ്-കട്ടിംഗ് ആശങ്കകളെ ഡെക്കറേറ്ററുകളിലേക്ക് വേർതിരിക്കുന്നതിലൂടെ, നിങ്ങളുടെ പ്രധാന ലോജിക് വൃത്തിയുള്ളതും എളുപ്പത്തിൽ മനസ്സിലാക്കാവുന്നതുമാക്കാൻ കഴിയും. ഡെക്കറേറ്ററുകൾ അധിക സ്വഭാവം പ്രകടിപ്പിക്കാൻ ഒരു പ്രഖ്യാപിത മാർഗ്ഗം നൽകുന്നു, ഇത് കോഡിനെ കൂടുതൽ സ്വയം-രേഖപ്പെടുത്തുന്നതാക്കുന്നു.
• വർദ്ധിച്ച പരിപാലനക്ഷമത: ഡെക്കറേറ്ററുകൾ മോഡുലാരിറ്റിയെയും ആശങ്കകളെ വേർതിരിക്കുന്നതിനെയും പ്രോത്സാഹിപ്പിക്കുന്നു, ഇത് കോഡ്ബേസിന്റെ മറ്റ് ഭാഗങ്ങളെ ബാധിക്കാതെ നിങ്ങളുടെ ആപ്ലിക്കേഷൻ പരിഷ്കരിക്കുന്നതിനോ വിപുലീകരിക്കുന്നതിനോ എളുപ്പമാക്കുന്നു. ഇത് ബഗുകൾ ഉണ്ടാകാനുള്ള സാധ്യത കുറയ്ക്കുകയും പരിപാലന പ്രക്രിയ ലളിതമാക്കുകയും ചെയ്യുന്നു.
• ആസ്പെക്റ്റ്-ഓറിയന്റഡ് പ്രോഗ്രാമിംഗ് (AOP): നിലവിലുള്ള കോഡിന്റെ സോഴ്സ് കോഡ് പരിഷ്കരിക്കാതെ തന്നെ അതിലേക്ക് സ്വഭാവം ഇൻജെക്റ്റ് ചെയ്യാൻ അനുവദിക്കുന്നതിലൂടെ AOP തത്വങ്ങൾ നടപ്പിലാക്കാൻ ഡെക്കറേറ്ററുകൾ നിങ്ങളെ പ്രാപ്തരാക്കുന്നു. ലോഗിംഗ്, സുരക്ഷ, ട്രാൻസാക്ഷൻ മാനേജ്മെന്റ് തുടങ്ങിയ ക്രോസ്-കട്ടിംഗ് ആശങ്കകൾ കൈകാര്യം ചെയ്യുന്നതിന് ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്.

ഡെക്കറേറ്റർ തരങ്ങൾ

ജാവാസ്ക്രിപ്റ്റ് ഡെക്കറേറ്ററുകൾ വിവിധ തരം പ്രഖ്യാപനങ്ങളിൽ പ്രയോഗിക്കാൻ കഴിയും, ഓരോന്നിനും അതിന്റേതായ നിർദ്ദിഷ്ട ഉദ്ദേശ്യവും വാക്യഘടനയുമുണ്ട്:

ക്ലാസ് ഡെക്കറേറ്ററുകൾ

ക്ലാസ് ഡെക്കറേറ്ററുകൾ ക്ലാസ് കൺസ്ട്രക്റ്ററിൽ പ്രയോഗിക്കുന്നു, അവ ക്ലാസ് നിർവചനം പരിഷ്കരിക്കുന്നതിനോ മെറ്റാഡാറ്റ ചേർക്കുന്നതിനോ ഉപയോഗിക്കാം. ഒരു ക്ലാസ് ഡെക്കറേറ്ററിന് അതിന്റെ ഏക ആർഗ്യുമെന്റായി ക്ലാസ് കൺസ്ട്രക്റ്റർ ലഭിക്കുന്നു.

ഉദാഹരണം: ഒരു ക്ലാസിലേക്ക് മെറ്റാഡാറ്റ ചേർക്കുന്നു.

            
function Component(options: { selector: string, template: string }) {
  return function (constructor: T) {
    return class extends constructor {
      selector = options.selector;
      template = options.template;
    }
  }
}

@Component({ selector: 'my-component', template: '
Hello
' })
class MyComponent {
  constructor() {
    // ...
  }
}

console.log(new MyComponent().selector); // Output: my-component

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, Component ഡെക്കറേറ്റർ MyComponent ക്ലാസിലേക്ക് selector, template എന്നീ പ്രോപ്പർട്ടികൾ ചേർക്കുന്നു, ഇത് ഒരു പ്രഖ്യാപിത രീതിയിൽ കമ്പോണന്റിന്റെ മെറ്റാഡാറ്റ കോൺഫിഗർ ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ആംഗുലർ കമ്പോണന്റുകൾ നിർവചിച്ചിരിക്കുന്നതിന് സമാനമാണിത്.

മെത്തേഡ് ഡെക്കറേറ്ററുകൾ

മെത്തേഡ് ഡെക്കറേറ്ററുകൾ ഒരു ക്ലാസിലെ മെത്തേഡുകളിൽ പ്രയോഗിക്കുന്നു, അവ മെത്തേഡിന്റെ സ്വഭാവം പരിഷ്കരിക്കുന്നതിനോ മെറ്റാഡാറ്റ ചേർക്കുന്നതിനോ ഉപയോഗിക്കാം. ഒരു മെത്തേഡ് ഡെക്കറേറ്ററിന് മൂന്ന് ആർഗ്യുമെന്റുകൾ ലഭിക്കുന്നു:

• ടാർഗെറ്റ് ഒബ്ജക്റ്റ് (മെത്തേഡ് സ്റ്റാറ്റിക് ആണോ എന്നതിനെ ആശ്രയിച്ച് ക്ലാസ് പ്രോട്ടോടൈപ്പ് അല്ലെങ്കിൽ ക്ലാസ് കൺസ്ട്രക്റ്റർ).
• മെത്തേഡിന്റെ പേര്.
• മെത്തേഡിനായുള്ള പ്രോപ്പർട്ടി ഡിസ്ക്രിപ്റ്റർ.

ഉദാഹരണം: മെത്തേഡ് കോളുകൾ ലോഗ് ചെയ്യുന്നു.

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

  descriptor.value = function (...args: any[]) {
    console.log(`Calling ${propertyKey} with arguments: ${JSON.stringify(args)}`);
    const result = originalMethod.apply(this, args);
    console.log(`${propertyKey} returned: ${result}`);
    return result;
  }

  return descriptor;
}

class Calculator {
  @Log
  add(a: number, b: number) {
    return a + b;
  }
}

const calculator = new Calculator();
calculator.add(2, 3); // Output: Calling add with arguments: [2,3]
                     //         add returned: 5

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, Log ഡെക്കറേറ്റർ യഥാർത്ഥ മെത്തേഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിന് മുമ്പ് മെത്തേഡ് കോളിനെയും അതിന്റെ ആർഗ്യുമെന്റുകളെയും ലോഗ് ചെയ്യുന്നു, എക്സിക്യൂഷന് ശേഷം റിട്ടേൺ മൂല്യം ലോഗ് ചെയ്യുന്നു. മെത്തേഡിന്റെ പ്രധാന ലോജിക് പരിഷ്കരിക്കാതെ ലോഗിംഗ് അല്ലെങ്കിൽ ഓഡിറ്റിംഗ് പ്രവർത്തനം നടപ്പിലാക്കാൻ ഡെക്കറേറ്ററുകൾ എങ്ങനെ ഉപയോഗിക്കാം എന്നതിന്റെ ലളിതമായ ഉദാഹരണമാണിത്.

പ്രോപ്പർട്ടി ഡെക്കറേറ്ററുകൾ

പ്രോപ്പർട്ടി ഡെക്കറേറ്ററുകൾ ഒരു ക്ലാസിലെ പ്രോപ്പർട്ടികളിൽ പ്രയോഗിക്കുന്നു, അവ പ്രോപ്പർട്ടിയുടെ സ്വഭാവം പരിഷ്കരിക്കുന്നതിനോ മെറ്റാഡാറ്റ ചേർക്കുന്നതിനോ ഉപയോഗിക്കാം. ഒരു പ്രോപ്പർട്ടി ഡെക്കറേറ്ററിന് രണ്ട് ആർഗ്യുമെന്റുകൾ ലഭിക്കുന്നു:

• ടാർഗെറ്റ് ഒബ്ജക്റ്റ് (പ്രോപ്പർട്ടി സ്റ്റാറ്റിക് ആണോ എന്നതിനെ ആശ്രയിച്ച് ക്ലാസ് പ്രോട്ടോടൈപ്പ് അല്ലെങ്കിൽ ക്ലാസ് കൺസ്ട്രക്റ്റർ).
• പ്രോപ്പർട്ടിയുടെ പേര്.

ഉദാഹരണം: പ്രോപ്പർട്ടി മൂല്യങ്ങൾ സാധൂകരിക്കുന്നു.

            
function Validate(target: any, propertyKey: string) {
  let value: any;

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

  const setter = function (newVal: any) {
    if (typeof newVal !== 'number' || newVal < 0) {
      throw new Error(`Invalid value for ${propertyKey}. Must be a non-negative number.`);
    }
    value = newVal;
  };

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

class Product {
  @Validate
  price: number;

  constructor(price: number) {
    this.price = price;
  }
}

const product = new Product(10);
console.log(product.price); // Output: 10

try {
  product.price = -5; // Throws an error
} catch (e) {
  console.error(e.message);
}

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, Validate ഡെക്കറേറ്റർ price പ്രോപ്പർട്ടി ഒരു നോൺ-നെഗറ്റീവ് സംഖ്യയാണെന്ന് ഉറപ്പാക്കാൻ സാധൂകരിക്കുന്നു. ഒരു അസാധുവായ മൂല്യം നൽകിയാൽ, ഒരു പിശക് സംഭവിക്കുന്നു. ഡാറ്റാ വാലിഡേഷൻ നടപ്പിലാക്കാൻ ഡെക്കറേറ്ററുകൾ എങ്ങനെ ഉപയോഗിക്കാം എന്നതിന്റെ ലളിതമായ ഉദാഹരണമാണിത്.

പാരാമീറ്റർ ഡെക്കറേറ്ററുകൾ

പാരാമീറ്റർ ഡെക്കറേറ്ററുകൾ ഒരു മെത്തേഡിന്റെ പാരാമീറ്ററുകളിൽ പ്രയോഗിക്കുന്നു, അവ മെറ്റാഡാറ്റ ചേർക്കുന്നതിനോ പാരാമീറ്ററിന്റെ സ്വഭാവം പരിഷ്കരിക്കുന്നതിനോ ഉപയോഗിക്കാം. ഒരു പാരാമീറ്റർ ഡെക്കറേറ്ററിന് മൂന്ന് ആർഗ്യുമെന്റുകൾ ലഭിക്കുന്നു:

• ടാർഗെറ്റ് ഒബ്ജക്റ്റ് (മെത്തേഡ് സ്റ്റാറ്റിക് ആണോ എന്നതിനെ ആശ്രയിച്ച് ക്ലാസ് പ്രോട്ടോടൈപ്പ് അല്ലെങ്കിൽ ക്ലാസ് കൺസ്ട്രക്റ്റർ).
• മെത്തേഡിന്റെ പേര്.
• മെത്തേഡിന്റെ പാരാമീറ്റർ ലിസ്റ്റിലെ പാരാമീറ്ററിന്റെ സൂചിക.

ഉദാഹരണം: ഡിപൻഡൻസികൾ ഇൻജെക്റ്റ് ചെയ്യുന്നു.

            
import 'reflect-metadata';

const Injectable = (): ClassDecorator => {
    return (target: any) => {
        Reflect.defineMetadata('injectable', true, target);
    };
};

const Inject = (token: string): ParameterDecorator => {
    return (target: any, propertyKey: string | symbol, parameterIndex: number) => {
        let existingParameters: string[] = Reflect.getOwnMetadata('parameters', target, propertyKey) || [];
        existingParameters[parameterIndex] = token;
        Reflect.defineMetadata('parameters', existingParameters, target, propertyKey);
    };
};

@Injectable()
class Logger {
    log(message: string) {
        console.log(`Logger: ${message}`);
    }
}

class Greeter {
    private logger: Logger;

    constructor(@Inject('Logger') logger: Logger) {
        this.logger = logger;
    }

    greet(name: string) {
        this.logger.log(`Hello, ${name}!`);
    }
}

// Simple dependency injection container
class Container {
    private dependencies: Map = new Map();

    register(token: string, dependency: any) {
        this.dependencies.set(token, dependency);
    }

    resolve(target: any): T {
        const parameters: string[] = Reflect.getMetadata('parameters', target) || [];
        const resolvedDependencies = parameters.map(token => this.dependencies.get(token));
        return new target(...resolvedDependencies);
    }
}

const container = new Container();
container.register('Logger', new Logger());

const greeter = container.resolve(Greeter);
greeter.greet('World'); // Output: Logger: Hello, World!

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, Inject ഡെക്കറേറ്റർ Greeter ക്ലാസിന്റെ കൺസ്ട്രക്റ്ററിലേക്ക് ഡിപൻഡൻസികൾ ഇൻജെക്റ്റ് ചെയ്യാൻ ഉപയോഗിക്കുന്നു. ഡെക്കറേറ്റർ പാരാമീറ്ററുമായി ഒരു ടോക്കൺ ബന്ധപ്പെടുത്തുന്നു, ഇത് ഒരു ഡിപൻഡൻസി ഇൻജെക്ഷൻ കണ്ടെയ്നർ ഉപയോഗിച്ച് ഡിപൻഡൻസി പരിഹരിക്കാൻ ഉപയോഗിക്കാം. ഈ ഉദാഹരണം ഡെക്കറേറ്ററുകളും reflect-metadata ലൈബ്രറിയും ഉപയോഗിച്ച് ഡിപൻഡൻസി ഇൻജെക്ഷന്റെ ഒരു അടിസ്ഥാനപരമായ നിർവഹണം കാണിക്കുന്നു.

പ്രായോഗിക ഉദാഹരണങ്ങളും ഉപയോഗങ്ങളും

കോഡിന്റെ ഗുണമേന്മ മെച്ചപ്പെടുത്തുന്നതിനും വികസനം ലളിതമാക്കുന്നതിനും ജാവാസ്ക്രിപ്റ്റ് ഡെക്കറേറ്ററുകൾ വിവിധ സാഹചര്യങ്ങളിൽ ഉപയോഗിക്കാം. ചില പ്രായോഗിക ഉദാഹരണങ്ങളും ഉപയോഗങ്ങളും ഇതാ:

ലോഗിംഗും ഓഡിറ്റിംഗും

മെത്തേഡ് കോളുകൾ, ആർഗ്യുമെന്റുകൾ, റിട്ടേൺ മൂല്യങ്ങൾ എന്നിവ സ്വയമേവ ലോഗ് ചെയ്യാൻ ഡെക്കറേറ്ററുകൾ ഉപയോഗിക്കാം, ഇത് ആപ്ലിക്കേഷൻ സ്വഭാവത്തെയും പ്രകടനത്തെയും കുറിച്ചുള്ള വിലപ്പെട്ട ഉൾക്കാഴ്ചകൾ നൽകുന്നു. പ്രശ്നങ്ങൾ ഡീബഗ് ചെയ്യുന്നതിനും പരിഹരിക്കുന്നതിനും ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാകും.

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

    descriptor.value = function (...args: any[]) {
        const startTime = performance.now();
        console.log(`[${new Date().toISOString()}] Calling method: ${propertyKey} with arguments: ${JSON.stringify(args)}`);
        const result = originalMethod.apply(this, args);
        const endTime = performance.now();
        const executionTime = endTime - startTime;
        console.log(`[${new Date().toISOString()}] Method ${propertyKey} returned: ${result}. Execution time: ${executionTime.toFixed(2)}ms`);
        return result;
    };

    return descriptor;
}

class ExampleClass {
    @LogMethod
    complexOperation(a: number, b: number): number {
        // Simulate a time-consuming operation
        let sum = 0;
        for (let i = 0; i < 1000000; i++) {
            sum += a + b + i;
        }
        return sum;
    }
}

const example = new ExampleClass();
example.complexOperation(5, 10);

            

              
                Copy
              
            
          

ഈ വിപുലീകരിച്ച ഉദാഹരണം മെത്തേഡിന്റെ നിർവ്വഹണ സമയം അളക്കുകയും അത് ലോഗ് ചെയ്യുകയും ചെയ്യുന്നു, ഒപ്പം നിലവിലെ ടൈംസ്റ്റാമ്പും നൽകുന്നു, ഇത് പ്രകടന വിശകലനത്തിനായി കൂടുതൽ വിശദമായ വിവരങ്ങൾ നൽകുന്നു.

അംഗീകാരവും ആധികാരികതയും

ഒരു മെത്തേഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിന് മുമ്പ് ഉപയോക്താവിന്റെ റോളുകളും അനുമതികളും പരിശോധിച്ച് സുരക്ഷാ നയങ്ങൾ നടപ്പിലാക്കാൻ ഡെക്കറേറ്ററുകൾ ഉപയോഗിക്കാം. ഇത് സെൻസിറ്റീവായ ഡാറ്റയിലേക്കും പ്രവർത്തനങ്ങളിലേക്കുമുള്ള അനധികൃത പ്രവേശനം തടയാൻ സഹായിക്കും.

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

        descriptor.value = function (...args: any[]) {
            const userRole = getCurrentUserRole(); // Function to retrieve the current user's role

            if (userRole !== role) {
                throw new Error(`Unauthorized: User does not have the required role (${role}) to access this method.`);
            }

            return originalMethod.apply(this, args);
        };

        return descriptor;
    };
}

function getCurrentUserRole(): string {
    // In a real application, this would retrieve the user's role from authentication context
    return 'admin'; // Example: Hardcoded role for demonstration
}

class AdminPanel {
    @Authorize('admin')
    deleteUser(userId: number) {
        console.log(`User ${userId} deleted successfully.`);
    }

    @Authorize('editor')
    editArticle(articleId: number) {
        console.log(`Article ${articleId} edited successfully.`);
    }
}

const adminPanel = new AdminPanel();

try {
    adminPanel.deleteUser(123);
    adminPanel.editArticle(456); // This will throw an error because the user role is 'admin'
} catch (error) {
    console.error(error.message);
}

            

              
                Copy
              
            
          

ഈ വിപുലീകരിച്ച ഉദാഹരണത്തിൽ, Authorize ഡെക്കറേറ്റർ മെത്തേഡിലേക്ക് പ്രവേശനം അനുവദിക്കുന്നതിന് മുമ്പ് നിലവിലെ ഉപയോക്താവിന് നിർദ്ദിഷ്ട റോൾ ഉണ്ടോയെന്ന് പരിശോധിക്കുന്നു. ഉപയോക്താവിന്റെ നിലവിലെ റോൾ നിർണ്ണയിക്കാൻ getCurrentUserRole ഫംഗ്ഷൻ (യഥാർത്ഥ ആപ്ലിക്കേഷനിൽ യഥാർത്ഥ ഉപയോക്തൃ റോൾ ലഭ്യമാക്കും) ഉപയോഗിക്കുന്നു. ഉപയോക്താവിന് ആവശ്യമായ റോൾ ഇല്ലെങ്കിൽ, ഒരു പിശക് സംഭവിക്കുന്നു, ഇത് മെത്തേഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നത് തടയുന്നു.

കാഷിംഗ്

ചെലവേറിയ പ്രവർത്തനങ്ങളുടെ ഫലങ്ങൾ കാഷ് ചെയ്യാൻ ഡെക്കറേറ്ററുകൾ ഉപയോഗിക്കാം, ഇത് ആപ്ലിക്കേഷൻ പ്രകടനം മെച്ചപ്പെടുത്തുകയും സെർവർ ലോഡ് കുറയ്ക്കുകയും ചെയ്യുന്നു. ഇടയ്ക്കിടെ ആക്സസ് ചെയ്യുന്നതും എന്നാൽ അധികം മാറ്റം വരാത്തതുമായ ഡാറ്റയ്ക്ക് ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാകും.

            
function Cache(ttl: number = 60) { // ttl in seconds, default to 60 seconds
    const cache = new Map();

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

        descriptor.value = async function (...args: any[]) {
            const cacheKey = `${propertyKey}-${JSON.stringify(args)}`;
            const cachedData = cache.get(cacheKey);

            if (cachedData && Date.now() < cachedData.expiry) {
                console.log(`Retrieving from cache: ${propertyKey} with arguments: ${JSON.stringify(args)}`);
                return cachedData.data;
            }

            console.log(`Executing and caching: ${propertyKey} with arguments: ${JSON.stringify(args)}`);
            const result = await originalMethod.apply(this, args);

            cache.set(cacheKey, {
                data: result,
                expiry: Date.now() + ttl * 1000, // Calculate expiry time
            });

            return result;
        };

        return descriptor;
    };
}

class DataService {
    @Cache(120) // Cache for 120 seconds
    async fetchData(id: number): Promise {
        // Simulate fetching data from a database or API
        return new Promise((resolve) => {
            setTimeout(() => {
                resolve(`Data for ID ${id} fetched from source.`);
            }, 1000); // Simulate a 1-second delay
        });
    }
}

const dataService = new DataService();

(async () => {
    console.log(await dataService.fetchData(1)); // Executes the method
    console.log(await dataService.fetchData(1)); // Retrieves from cache
    await new Promise(resolve => setTimeout(resolve, 121000)); // Wait for 121 seconds to allow the cache to expire
    console.log(await dataService.fetchData(1)); // Executes the method again after cache expiry
})();

            

              
                Copy
              
            
          

ഈ വിപുലീകരിച്ച ഉദാഹരണം ഒരു Map ഉപയോഗിച്ച് ഒരു അടിസ്ഥാന കാഷിംഗ് സംവിധാനം നടപ്പിലാക്കുന്നു. Cache ഡെക്കറേറ്റർ ഡെക്കറേറ്റ് ചെയ്ത മെത്തേഡിന്റെ ഫലങ്ങൾ ഒരു നിശ്ചിത ടൈം-ടു-ലിവ് (TTL) സമയത്തേക്ക് സംഭരിക്കുന്നു. ഒരേ ആർഗ്യുമെന്റുകളുമായി മെത്തേഡ് വീണ്ടും വിളിക്കുമ്പോൾ, മെത്തേഡ് വീണ്ടും എക്സിക്യൂട്ട് ചെയ്യുന്നതിന് പകരം കാഷ് ചെയ്ത ഫലം തിരികെ നൽകുന്നു. TTL കാലഹരണപ്പെട്ട ശേഷം, മെത്തേഡ് വീണ്ടും എക്സിക്യൂട്ട് ചെയ്യുകയും ഫലം കാഷ് ചെയ്യുകയും ചെയ്യുന്നു.

വാലിഡേഷൻ

ഡാറ്റ പ്രോസസ്സ് ചെയ്യുന്നതിന് മുമ്പ് അത് സാധൂകരിക്കാനും, ഡാറ്റയുടെ സമഗ്രത ഉറപ്പാക്കാനും പിശകുകൾ തടയാനും ഡെക്കറേറ്ററുകൾ ഉപയോഗിക്കാം. ഉപയോക്തൃ ഇൻപുട്ട് അല്ലെങ്കിൽ ബാഹ്യ ഉറവിടങ്ങളിൽ നിന്ന് ലഭിക്കുന്ന ഡാറ്റ സാധൂകരിക്കുന്നതിന് ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാകും.

            
function Required() {
    return function (target: any, propertyKey: string) {
        if (!target.constructor.requiredFields) {
            target.constructor.requiredFields = [];
        }
        target.constructor.requiredFields.push(propertyKey);
    };
}

function ValidateClass(target: any) {
    const originalConstructor = target;

    function construct(constructor: any, args: any[]) {
        const instance: any = new constructor(...args);
        if (constructor.requiredFields) {
            constructor.requiredFields.forEach((field: string) => {
                if (!instance[field]) {
                    throw new Error(`Missing required field: ${field}`);
                }
            });
        }
        return instance;
    }

    const newConstructor: any = function (...args: any[]) {
        return construct(originalConstructor, args);
    };

    newConstructor.prototype = originalConstructor.prototype;
    return newConstructor;
}

@ValidateClass
class User {
    @Required()
    name: string;

    @Required()
    email: string;

    constructor(name: string, email: string) {
        this.name = name;
        this.email = email;
    }
}

try {
    const validUser = new User('John Doe', 'john.doe@example.com');
    console.log('Valid user created:', validUser);

    const invalidUser = new User('Jane Doe', ''); // Missing email
} catch (error) {
    console.error('Validation error:', error.message);
}


            

              
                Copy
              
            
          

ഈ ഉദാഹരണം രണ്ട് ഡെക്കറേറ്ററുകൾ ഉപയോഗിക്കുന്നു: Required, ValidateClass. Required ഡെക്കറേറ്റർ പ്രോപ്പർട്ടികളെ ആവശ്യമാണെന്ന് അടയാളപ്പെടുത്തുന്നു. ValidateClass ഡെക്കറേറ്റർ ക്ലാസ് കൺസ്ട്രക്റ്ററിനെ തടസ്സപ്പെടുത്തുകയും ആവശ്യമായ എല്ലാ ഫീൽഡുകൾക്കും മൂല്യങ്ങളുണ്ടോയെന്ന് പരിശോധിക്കുകയും ചെയ്യുന്നു. ഏതെങ്കിലും ആവശ്യമായ ഫീൽഡ് നഷ്ടപ്പെട്ടാൽ, ഒരു പിശക് സംഭവിക്കുന്നു.

ഡിപൻഡൻസി ഇൻജെക്ഷൻ

പാരാമീറ്റർ ഡെക്കറേറ്റർ ഉദാഹരണത്തിൽ കാണിച്ചിരിക്കുന്നതുപോലെ, ഡെക്കറേറ്ററുകൾക്ക് അടിസ്ഥാനപരമായ ഡിപൻഡൻസി ഇൻജെക്ഷൻ സുഗമമാക്കാൻ കഴിയും, ഇത് ഡിപൻഡൻസികൾ നിയന്ത്രിക്കുന്നതും ഘടകങ്ങളെ വേർപെടുത്തുന്നതും എളുപ്പമാക്കുന്നു. കൂടുതൽ സങ്കീർണ്ണമായ ഡിപൻഡൻസി ഇൻജെക്ഷൻ ഫ്രെയിംവർക്കുകൾ നിലവിലുണ്ടെങ്കിലും, ലളിതമായ ഡിപൻഡൻസി ഇൻജെക്ഷൻ സാഹചര്യങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിന് ഡെക്കറേറ്ററുകൾക്ക് ലളിതവും സൗകര്യപ്രദവുമായ ഒരു മാർഗ്ഗം നൽകാൻ കഴിയും.

പരിഗണനകളും മികച്ച രീതികളും

• നിർവ്വഹണ സാഹചര്യം മനസ്സിലാക്കുക: ഡെക്കറേറ്റർ ഫംഗ്ഷനിലേക്ക് കൈമാറുന്ന target, propertyKey, descriptor ആർഗ്യുമെന്റുകളെക്കുറിച്ച് അറിഞ്ഞിരിക്കുക. ഈ ആർഗ്യുമെന്റുകൾ ഡെക്കറേറ്റ് ചെയ്ത പ്രഖ്യാപനത്തെക്കുറിച്ച് വിലപ്പെട്ട വിവരങ്ങൾ നൽകുകയും അതിന്റെ സ്വഭാവം അതനുസരിച്ച് പരിഷ്കരിക്കാൻ നിങ്ങളെ അനുവദിക്കുകയും ചെയ്യുന്നു.
• ഡെക്കറേറ്ററുകൾ മിതമായി ഉപയോഗിക്കുക: ഡെക്കറേറ്ററുകൾക്ക് ശക്തമാകാൻ കഴിയുമെങ്കിലും, അമിതമായ ഉപയോഗം സങ്കീർണ്ണവും മനസ്സിലാക്കാൻ പ്രയാസമുള്ളതുമായ കോഡിലേക്ക് നയിച്ചേക്കാം. ഡെക്കറേറ്ററുകൾ വിവേകത്തോടെ ഉപയോഗിക്കുക, കോഡ് പുനരുപയോഗം, വായനാക്ഷമത അല്ലെങ്കിൽ പരിപാലനക്ഷമത എന്നിവയിൽ വ്യക്തമായ പ്രയോജനം നൽകുമ്പോൾ മാത്രം ഉപയോഗിക്കുക.
• നാമകരണ കൺവെൻഷനുകൾ പാലിക്കുക: നിങ്ങളുടെ ഡെക്കറേറ്ററുകളുടെ ഉദ്ദേശ്യം വ്യക്തമായി സൂചിപ്പിക്കുന്നതിന് വിവരണാത്മക പേരുകൾ ഉപയോഗിക്കുക. ഇത് നിങ്ങളുടെ കോഡിനെ കൂടുതൽ സ്വയം-രേഖപ്പെടുത്തുന്നതും മനസ്സിലാക്കാൻ എളുപ്പമുള്ളതുമാക്കും.
• ആശങ്കകളെ വേർതിരിക്കുക: ഡെക്കറേറ്ററുകൾ നിർദ്ദിഷ്ട ക്രോസ്-കട്ടിംഗ് ആശങ്കകളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കണം, ബന്ധമില്ലാത്ത പ്രവർത്തനക്ഷമത കൂട്ടിക്കലർത്തുന്നത് ഒഴിവാക്കണം. ഇത് നിങ്ങളുടെ കോഡിന്റെ മോഡുലാരിറ്റിയും പരിപാലനക്ഷമതയും മെച്ചപ്പെടുത്തും.
• നിങ്ങളുടെ ഡെക്കറേറ്ററുകൾ സമഗ്രമായി പരീക്ഷിക്കുക: മറ്റേതൊരു കോഡിനെയും പോലെ, ഡെക്കറേറ്ററുകൾ ശരിയായി പ്രവർത്തിക്കുന്നുവെന്നും ഉദ്ദേശിക്കാത്ത പാർശ്വഫലങ്ങൾ ഉണ്ടാക്കുന്നില്ലെന്നും ഉറപ്പാക്കാൻ സമഗ്രമായി പരീക്ഷിക്കണം.
• പാർശ്വഫലങ്ങളെക്കുറിച്ച് അറിഞ്ഞിരിക്കുക: ഡെക്കറേറ്ററുകൾ റൺടൈമിൽ എക്സിക്യൂട്ട് ചെയ്യുന്നു. ഡെക്കറേറ്റർ ഫംഗ്ഷനുകൾക്കുള്ളിൽ സങ്കീർണ്ണമോ ദീർഘനേരം പ്രവർത്തിക്കുന്നതോ ആയ പ്രവർത്തനങ്ങൾ ഒഴിവാക്കുക, കാരണം ഇത് ആപ്ലിക്കേഷൻ പ്രകടനത്തെ ബാധിച്ചേക്കാം.
• ടൈപ്പ്സ്ക്രിപ്റ്റ് ശുപാർശ ചെയ്യുന്നു: ജാവാസ്ക്രിപ്റ്റ് ഡെക്കറേറ്ററുകൾ സാങ്കേതികമായി പ്ലെയിൻ ജാവാസ്ക്രിപ്റ്റിൽ ബാബേൽ ട്രാൻസ്പൈലേഷൻ ഉപയോഗിച്ച് ഉപയോഗിക്കാമെങ്കിലും, അവ സാധാരണയായി ടൈപ്പ്സ്ക്രിപ്റ്റിനൊപ്പം ഉപയോഗിക്കുന്നു. ടൈപ്പ്സ്ക്രിപ്റ്റ് ഡെക്കറേറ്ററുകൾക്ക് മികച്ച ടൈപ്പ് സുരക്ഷയും ഡിസൈൻ-ടൈം പരിശോധനയും നൽകുന്നു.

ആഗോള കാഴ്ചപ്പാടുകളും ഉദാഹരണങ്ങളും

ഡെക്കറേറ്ററുകൾ സുഗമമാക്കുന്ന കോഡ് പുനരുപയോഗം, പരിപാലനക്ഷമത, ആശങ്കകളെ വേർതിരിക്കൽ എന്നിവയുടെ തത്വങ്ങൾ ആഗോളതലത്തിൽ വൈവിധ്യമാർന്ന സോഫ്റ്റ്‌വെയർ വികസന സാഹചര്യങ്ങളിൽ സാർവത്രികമായി ബാധകമാണ്. എന്നിരുന്നാലും, സാങ്കേതികവിദ്യ, പ്രോജക്റ്റ് ആവശ്യകതകൾ, വിവിധ പ്രദേശങ്ങളിൽ നിലവിലുള്ള വികസന രീതികൾ എന്നിവയെ ആശ്രയിച്ച് നിർദ്ദിഷ്ട നിർവ്വഹണങ്ങളും ഉപയോഗങ്ങളും വ്യത്യാസപ്പെടാം.

ഉദാഹരണത്തിന്, എന്റർപ്രൈസ് ജാവ വികസനത്തിൽ, കോൺഫിഗറേഷനും ഡിപൻഡൻസി ഇൻജെക്ഷനും (ഉദാഹരണത്തിന്, സ്പ്രിംഗ് ഫ്രെയിംവർക്ക്) വേണ്ടി വ്യാഖ്യാനങ്ങൾ (ഡെക്കറേറ്ററുകൾക്ക് സമാനമായ ആശയം) വ്യാപകമായി ഉപയോഗിക്കുന്നു. വാക്യഘടനയും അടിസ്ഥാന സംവിധാനങ്ങളും ജാവാസ്ക്രിപ്റ്റ് ഡെക്കറേറ്ററുകളിൽ നിന്ന് വ്യത്യസ്തമാണെങ്കിലും, മെറ്റാപ്രോഗ്രാമിംഗിന്റെയും എഒപി-യുടെയും അടിസ്ഥാന തത്വങ്ങൾ ഒന്നുതന്നെയാണ്. അതുപോലെ, പൈത്തണിൽ, ഡെക്കറേറ്ററുകൾ ഒരു ഫസ്റ്റ്-ക്ലാസ് ഭാഷാ സവിശേഷതയാണ്, ലോഗിംഗ്, ഓതന്റിക്കേഷൻ, കാഷിംഗ് തുടങ്ങിയ ജോലികൾക്കായി അവ പതിവായി ഉപയോഗിക്കുന്നു.

അന്താരാഷ്ട്ര ടീമുകളിൽ പ്രവർത്തിക്കുമ്പോഴോ ആഗോള പ്രേക്ഷകരുള്ള ഓപ്പൺ സോഴ്‌സ് പ്രോജക്റ്റുകളിൽ സംഭാവന നൽകുമ്പോഴോ, വ്യക്തതയും പരിപാലനക്ഷമതയും പ്രോത്സാഹിപ്പിക്കുന്ന കോഡിംഗ് മാനദണ്ഡങ്ങളും മികച്ച രീതികളും പാലിക്കേണ്ടത് അത്യാവശ്യമാണ്. ഡെക്കറേറ്ററുകൾ ഫലപ്രദമായി ഉപയോഗിക്കുന്നത് കൂടുതൽ മോഡുലാറും നന്നായി ചിട്ടപ്പെടുത്തിയതുമായ ഒരു കോഡ്ബേസിലേക്ക് സംഭാവന ചെയ്യാൻ കഴിയും, ഇത് വിവിധ പശ്ചാത്തലങ്ങളിൽ നിന്നുള്ള ഡെവലപ്പർമാർക്ക് സഹകരിക്കാനും സംഭാവന നൽകാനും എളുപ്പമാക്കുന്നു.

ഉപസംഹാരം

ജാവാസ്ക്രിപ്റ്റ് ഡെക്കറേറ്ററുകൾ ശക്തവും വൈവിധ്യപൂർണ്ണവുമായ ഒരു മെറ്റാപ്രോഗ്രാമിംഗ് സവിശേഷതയാണ്, ഇത് കോഡ് പുനരുപയോഗം, വായനാക്ഷമത, പരിപാലനം എന്നിവ ഗണ്യമായി മെച്ചപ്പെടുത്താൻ കഴിയും. മെറ്റാഡാറ്റ ചേർക്കുന്നതിനും എഒപി തത്വങ്ങൾ നടപ്പിലാക്കുന്നതിനും ഒരു പ്രഖ്യാപിത മാർഗ്ഗം നൽകുന്നതിലൂടെ, പൊതുവായ സ്വഭാവം ഉൾക്കൊള്ളാനും ആശങ്കകളെ വേർതിരിക്കാനും കൂടുതൽ മോഡുലാറും നന്നായി ചിട്ടപ്പെടുത്തിയതുമായ ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കാനും ഡെക്കറേറ്ററുകൾ നിങ്ങളെ പ്രാപ്തരാക്കുന്നു. ഇപ്പോഴും സജീവമായി വികസിച്ചുകൊണ്ടിരിക്കുന്ന ഒരു നിർദ്ദേശമാണെങ്കിലും, ആംഗുലർ, നെസ്റ്റ്ജെഎസ് പോലുള്ള ഫ്രെയിംവർക്കുകളിൽ ഡെക്കറേറ്ററുകൾ ഇതിനകം തന്നെ വ്യാപകമായ സ്വീകാര്യത നേടിയിട്ടുണ്ട്, കൂടാതെ ജാവാസ്ക്രിപ്റ്റ് ഇക്കോസിസ്റ്റത്തിന്റെ കൂടുതൽ പ്രാധാന്യമുള്ള ഭാഗമായി മാറാൻ ഒരുങ്ങുകയാണ്. ഡെക്കറേറ്ററുകളുടെ വാക്യഘടന, ഉപയോഗം, മികച്ച രീതികൾ എന്നിവ മനസ്സിലാക്കുന്നതിലൂടെ, കൂടുതൽ കരുത്തുറ്റതും അളക്കാവുന്നതും പരിപാലിക്കാവുന്നതുമായ ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കാൻ നിങ്ങൾക്ക് അവയുടെ ശക്തി പ്രയോജനപ്പെടുത്താം.

ജാവാസ്ക്രിപ്റ്റ് ഇക്കോസിസ്റ്റം വികസിക്കുന്നത് തുടരുമ്പോൾ, ലോകമെമ്പാടുമുള്ള ഉപയോക്താക്കളുടെ ആവശ്യങ്ങൾ നിറവേറ്റുന്ന ഉയർന്ന നിലവാരമുള്ള സോഫ്റ്റ്‌വെയർ നിർമ്മിക്കുന്നതിന് പുതിയ സവിശേഷതകളെയും മികച്ച രീതികളെയും കുറിച്ച് അറിഞ്ഞിരിക്കേണ്ടത് നിർണായകമാണ്. ജാവാസ്ക്രിപ്റ്റ് ഡെക്കറേറ്ററുകളിൽ വൈദഗ്ദ്ധ്യം നേടുന്നത് കൂടുതൽ ഫലപ്രദവും ഉൽപ്പാദനക്ഷമവുമായ ഒരു ഡെവലപ്പറാകാൻ നിങ്ങളെ സഹായിക്കുന്ന ഒരു വിലയേറിയ വൈദഗ്ധ്യമാണ്.