ജാവാസ്ക്രിപ്റ്റ് ഡെക്കറേറ്ററുകൾ: മെറ്റാഡാറ്റാ പ്രോഗ്രാമിംഗിന്റെ ശക്തി അഴിച്ചുവിടുന്നു

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

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

അടിസ്ഥാനപരമായി, ഡെക്കറേറ്ററുകൾ അലങ്കരിച്ച ഘടകത്തെ മാറ്റം വരുത്തുകയോ മെച്ചപ്പെടുത്തുകയോ ചെയ്യുന്ന ഫംഗ്ഷനുകളാണ്. അവ ഡെക്കറേറ്റർ ഫംഗ്ഷന്റെ പേരിന് മുമ്പായി @ ചിഹ്നം ഉപയോഗിക്കുന്നു. അലങ്കരിച്ച എന്റിറ്റിയുടെ പ്രധാന ലോജിക്കിൽ നേരിട്ട് മാറ്റം വരുത്താതെ മെറ്റാഡാറ്റ ചേർക്കുകയോ അടിസ്ഥാന സ്വഭാവം മാറ്റുകയോ ചെയ്യുന്ന അനോട്ടേഷനുകളോ മോഡിഫയറുകളോ ആയി ഇവയെ കണക്കാക്കാം. അവ ഫലപ്രദമായി അലങ്കരിച്ച ഘടകത്തെ പൊതിഞ്ഞ്, ഇഷ്ടാനുസൃത പ്രവർത്തനങ്ങൾ ചേർക്കുന്നു.

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

ഡെക്കറേറ്ററുകളുടെ വാക്യഘടന (Syntax)

ഡെക്കറേറ്ററുകൾ അലങ്കരിക്കുന്ന ഘടകത്തിന് മുമ്പായി @ ചിഹ്നം ഉപയോഗിച്ച് പ്രയോഗിക്കുന്നു. ഓരോന്നും ഒരു പ്രത്യേക ഘടകത്തെ ലക്ഷ്യമിടുന്ന വിവിധതരം ഡെക്കറേറ്ററുകൾ ഉണ്ട്:

• ക്ലാസ് ഡെക്കറേറ്ററുകൾ: ക്ലാസുകളിൽ പ്രയോഗിക്കുന്നു.
• മെത്തേഡ് ഡെക്കറേറ്ററുകൾ: മെത്തേഡുകളിൽ പ്രയോഗിക്കുന്നു.
• പ്രോപ്പർട്ടി ഡെക്കറേറ്ററുകൾ: പ്രോപ്പർട്ടികളിൽ പ്രയോഗിക്കുന്നു.
• അക്സസർ ഡെക്കറേറ്ററുകൾ: ഗെറ്റർ, സെറ്റർ മെത്തേഡുകളിൽ പ്രയോഗിക്കുന്നു.
• പാരാമീറ്റർ ഡെക്കറേറ്ററുകൾ: മെത്തേഡ് പാരാമീറ്ററുകളിൽ പ്രയോഗിക്കുന്നു.

ഒരു ക്ലാസ് ഡെക്കറേറ്ററിന്റെ അടിസ്ഥാന ഉദാഹരണം ഇതാ:

            @logClass
class MyClass {
  constructor() {
    // ...
  }
}

function logClass(target) {
  console.log(`Class ${target.name} has been created.`);
}

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, logClass എന്നത് ക്ലാസ് കൺസ്ട്രക്ടറെ (target) ഒരു ആർഗ്യുമെന്റായി എടുക്കുന്ന ഒരു ഡെക്കറേറ്റർ ഫംഗ്ഷനാണ്. MyClass-ന്റെ ഒരു ഇൻസ്റ്റൻസ് ഉണ്ടാകുമ്പോഴെല്ലാം അത് കൺസോളിലേക്ക് ഒരു സന്ദേശം ലോഗ് ചെയ്യുന്നു.

മെറ്റാഡാറ്റാ പ്രോഗ്രാമിംഗ് മനസ്സിലാക്കുന്നു

ഡെക്കറേറ്ററുകൾ മെറ്റാഡാറ്റാ പ്രോഗ്രാമിംഗ് എന്ന ആശയവുമായി അടുത്ത ബന്ധം പുലർത്തുന്നു. മെറ്റാഡാറ്റ എന്നാൽ "ഡാറ്റയെക്കുറിച്ചുള്ള ഡാറ്റ" എന്നാണ്. പ്രോഗ്രാമിംഗിന്റെ പശ്ചാത്തലത്തിൽ, ക്ലാസുകൾ, മെത്തേഡുകൾ, പ്രോപ്പർട്ടികൾ തുടങ്ങിയ കോഡ് ഘടകങ്ങളുടെ സവിശേഷതകളെയും ഗുണങ്ങളെയും മെറ്റാഡാറ്റ വിവരിക്കുന്നു. ഈ ഘടകങ്ങളുമായി മെറ്റാഡാറ്റ ബന്ധപ്പെടുത്താൻ ഡെക്കറേറ്ററുകൾ നിങ്ങളെ അനുവദിക്കുന്നു, അതുവഴി ആ മെറ്റാഡാറ്റയെ അടിസ്ഥാനമാക്കി റൺടൈമിൽ സ്വഭാവം പരിശോധിക്കാനും മാറ്റം വരുത്താനും സാധിക്കുന്നു.

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

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

ഡെക്കറേറ്ററുകളുടെ തരങ്ങളും ഉദാഹരണങ്ങളും

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

ക്ലാസ് ഡെക്കറേറ്ററുകൾ ക്ലാസ് കൺസ്ട്രക്ടറിലാണ് പ്രയോഗിക്കുന്നത്. ക്ലാസ് നിർവചനം മാറ്റം വരുത്താനും പുതിയ പ്രോപ്പർട്ടികളോ മെത്തേഡുകളോ ചേർക്കാനും അല്ലെങ്കിൽ ക്ലാസ്സിനെ പൂർണ്ണമായും മറ്റൊന്നുമായി മാറ്റിസ്ഥാപിക്കാനും ഇവ ഉപയോഗിക്കാം.

ഉദാഹരണം: സിംഗിൾട്ടൺ പാറ്റേൺ നടപ്പിലാക്കുന്നു

ഒരു ക്ലാസ്സിന്റെ ഒരൊറ്റ ഇൻസ്റ്റൻസ് മാത്രമേ എപ്പോഴും ഉണ്ടാകുന്നുള്ളൂ എന്ന് സിംഗിൾട്ടൺ പാറ്റേൺ ഉറപ്പാക്കുന്നു. ഒരു ക്ലാസ് ഡെക്കറേറ്റർ ഉപയോഗിച്ച് ഇത് എങ്ങനെ നടപ്പിലാക്കാമെന്ന് താഴെ നൽകുന്നു:

            function Singleton(target) {
  let instance = null;

  return function (...args) {
    if (!instance) {
      instance = new target(...args);
    }
    return instance;
  };
}

@Singleton
class DatabaseConnection {
  constructor(connectionString) {
    this.connectionString = connectionString;
    console.log(`Connecting to ${connectionString}`);
  }

  query(sql) {
    console.log(`Executing query: ${sql}`);
  }
}

const db1 = new DatabaseConnection('mongodb://localhost:27017');
const db2 = new DatabaseConnection('mongodb://localhost:27017');

console.log(db1 === db2); // Output: true

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, Singleton ഡെക്കറേറ്റർ DatabaseConnection ക്ലാസ്സിനെ പൊതിയുന്നു. കൺസ്ട്രക്ടർ എത്ര തവണ വിളിച്ചാലും ക്ലാസ്സിന്റെ ഒരൊറ്റ ഇൻസ്റ്റൻസ് മാത്രമേ ഉണ്ടാകുന്നുള്ളൂ എന്ന് ഇത് ഉറപ്പാക്കുന്നു.

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

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

ഉദാഹരണം: മെത്തേഡ് കോളുകൾ ലോഗ് ചെയ്യുന്നുഈ ഡെക്കറേറ്റർ മെത്തേഡ് വിളിക്കുമ്പോഴെല്ലാം അതിന്റെ പേരും ആർഗ്യുമെന്റുകളും ലോഗ് ചെയ്യുന്നു.

            function logMethod(target, propertyKey, descriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function (...args) {
    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 Calculator {
  @logMethod
  add(x, y) {
    return x + y;
  }

  @logMethod
  subtract(x, y) {
    return x - y;
  }
}

const calc = new Calculator();
calc.add(5, 3); // Logs: Calling method: add with arguments: [5,3]
                //       Method add returned: 8
calc.subtract(10, 4); // Logs: Calling method: subtract with arguments: [10,4]
                  //       Method subtract returned: 6

            

              
                Copy
              
            
          

ഇവിടെ, logMethod ഡെക്കറേറ്റർ യഥാർത്ഥ മെത്തേഡിനെ പൊതിയുന്നു. യഥാർത്ഥ മെത്തേഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിന് മുമ്പ്, അത് മെത്തേഡിന്റെ പേരും അതിന്റെ ആർഗ്യുമെന്റുകളും ലോഗ് ചെയ്യുന്നു. എക്സിക്യൂഷന് ശേഷം, അത് റിട്ടേൺ മൂല്യം ലോഗ് ചെയ്യുന്നു.

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

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

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

            function validate(target, propertyKey) {
  let value;

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

  const setter = function (newValue) {
    if (typeof newValue !== 'string' || newValue.length < 3) {
      throw new Error(`Property ${propertyKey} must be a string with at least 3 characters.`);
    }
    value = newValue;
  };

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

class User {
  @validate
  name;
}

const user = new User();

try {
  user.name = 'Jo'; // Throws an error
} catch (error) {
  console.error(error.message);
}

user.name = 'John Doe'; // Works fine
console.log(user.name);

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, validate ഡെക്കറേറ്റർ name പ്രോപ്പർട്ടിയിലേക്കുള്ള ആക്സസ് തടസ്സപ്പെടുത്തുന്നു. ഒരു പുതിയ മൂല്യം നൽകുമ്പോൾ, അത് ഒരു സ്ട്രിംഗ് ആണോ എന്നും അതിന്റെ നീളം കുറഞ്ഞത് 3 അക്ഷരങ്ങളുണ്ടോ എന്നും പരിശോധിക്കുന്നു. ഇല്ലെങ്കിൽ, അത് ഒരു എറർ കാണിക്കുന്നു.

4. അക്സസർ ഡെക്കറേറ്ററുകൾ

ഗെറ്റർ, സെറ്റർ മെത്തേഡുകളിലാണ് അക്സസർ ഡെക്കറേറ്ററുകൾ പ്രയോഗിക്കുന്നത്. ഇവ മെത്തേഡ് ഡെക്കറേറ്ററുകൾക്ക് സമാനമാണ്, പക്ഷേ ഇവ പ്രത്യേകമായി അക്സസറുകളെ (ഗെറ്ററുകളും സെറ്ററുകളും) ലക്ഷ്യമിടുന്നു.

ഉദാഹരണം: ഗെറ്റർ ഫലങ്ങൾ കാഷ് ചെയ്യുന്നു

            function cached(target, propertyKey, descriptor) {
  const originalGetter = descriptor.get;
  let cacheValue;
  let cacheSet = false;

  descriptor.get = function () {
    if (cacheSet) {
      console.log(`Returning cached value for ${propertyKey}`);
      return cacheValue;
    } else {
      console.log(`Calculating and caching value for ${propertyKey}`);
      cacheValue = originalGetter.call(this);
      cacheSet = true;
      return cacheValue;
    }
  };
  return descriptor;
}

class Circle {
  constructor(radius) {
    this.radius = radius;
  }

  @cached
  get area() {
    console.log('Calculating area...');
    return Math.PI * this.radius * this.radius;
  }
}

const circle = new Circle(5);
console.log(circle.area); // Calculates and caches the area
console.log(circle.area); // Returns the cached area

            

              
                Copy
              
            
          

cached ഡെക്കറേറ്റർ area പ്രോപ്പർട്ടിയുടെ ഗെറ്ററിനെ പൊതിയുന്നു. ആദ്യമായി area ആക്സസ് ചെയ്യുമ്പോൾ, ഗെറ്റർ പ്രവർത്തിക്കുകയും ഫലം കാഷ് ചെയ്യുകയും ചെയ്യുന്നു. തുടർന്നുള്ള ആക്സസ്സുകൾ വീണ്ടും കണക്കുകൂട്ടാതെ കാഷ് ചെയ്ത മൂല്യം തിരികെ നൽകുന്നു.

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

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

ഉദാഹരണം: ഇമെയിൽ പാരാമീറ്റർ സാധൂകരിക്കുന്നു

            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 validateEmail(email: string) {
  const emailRegex = /^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/g;
  return emailRegex.test(email);
}

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){
             throw new Error("Missing required argument.");
          }

          const email = arguments[parameterIndex];
          if (!validateEmail(email)) {
              throw new Error(`Invalid email format for argument #${parameterIndex + 1}.`);
          }
      }
    }

    return method.apply(this, arguments);
  }
}

class EmailService {
  @validate
  sendEmail(@required to: string, subject: string, body: string) {
    console.log(`Sending email to ${to} with subject: ${subject}`);
  }
}

const emailService = new EmailService();

try {
  emailService.sendEmail('invalid-email', 'Hello', 'This is a test email.'); // Throws an error
} catch (error) {
  console.error(error.message);
}

emailService.sendEmail('valid@email.com', 'Hello', 'This is a test email.'); // Works fine

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, @required ഡെക്കറേറ്റർ to പാരാമീറ്ററിനെ ആവശ്യമുള്ളതായി അടയാളപ്പെടുത്തുകയും അതൊരു സാധുവായ ഇമെയിൽ ഫോർമാറ്റ് ആയിരിക്കണമെന്ന് സൂചിപ്പിക്കുകയും ചെയ്യുന്നു. തുടർന്ന് validate ഡെക്കറേറ്റർ ഈ വിവരം വീണ്ടെടുക്കാനും റൺടൈമിൽ പാരാമീറ്റർ സാധൂകരിക്കാനും Reflect Metadata ഉപയോഗിക്കുന്നു.

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

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

ഡെക്കറേറ്ററുകളുടെ ഉപയോഗ സാഹചര്യങ്ങൾ

താഴെ പറയുന്നവ ഉൾപ്പെടെ നിരവധി സാഹചര്യങ്ങളിൽ ഡെക്കറേറ്ററുകൾ ഉപയോഗിക്കാം:

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

ഡെക്കറേറ്റർ ഫാക്ടറികൾ

ഒരു ഡെക്കറേറ്റർ ഫാക്ടറി എന്നത് ഒരു ഡെക്കറേറ്റർ തിരികെ നൽകുന്ന ഒരു ഫംഗ്ഷനാണ്. ഫാക്ടറി ഫംഗ്ഷനിലേക്ക് ആർഗ്യുമെന്റുകൾ നൽകി ഡെക്കറേറ്ററിന്റെ സ്വഭാവം ഇഷ്ടാനുസൃതമാക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

ഉദാഹരണം: പാരാമീറ്ററുകളുള്ള ഒരു ലോഗർ

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

    descriptor.value = function (...args) {
      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 Calculator {
  @logMethodWithPrefix('[CALCULATION]')
  add(x, y) {
    return x + y;
  }

  @logMethodWithPrefix('[CALCULATION]')
  subtract(x, y) {
    return x - y;
  }
}

const calc = new Calculator();
calc.add(5, 3); // Logs: [CALCULATION]: Calling method: add with arguments: [5,3]
                //       [CALCULATION]: Method add returned: 8
calc.subtract(10, 4); // Logs: [CALCULATION]: Calling method: subtract with arguments: [10,4]
                  //       [CALCULATION]: Method subtract returned: 6

            

              
                Copy
              
            
          

logMethodWithPrefix ഫംഗ്ഷൻ ഒരു ഡെക്കറേറ്റർ ഫാക്ടറിയാണ്. ഇത് ഒരു prefix ആർഗ്യുമെന്റ് എടുത്ത് ഒരു ഡെക്കറേറ്റർ ഫംഗ്ഷൻ തിരികെ നൽകുന്നു. തുടർന്ന് ഡെക്കറേറ്റർ ഫംഗ്ഷൻ നിർദ്ദിഷ്ട പ്രിഫിക്സ് ഉപയോഗിച്ച് മെത്തേഡ് കോളുകൾ ലോഗ് ചെയ്യുന്നു.

യഥാർത്ഥ ലോക ഉദാഹരണങ്ങളും കേസ് സ്റ്റഡികളും

ഒരു ആഗോള ഇ-കൊമേഴ്‌സ് പ്ലാറ്റ്‌ഫോം പരിഗണിക്കുക. അവർക്ക് ഡെക്കറേറ്ററുകൾ ഇതിനായി ഉപയോഗിക്കാം:

• അന്താരാഷ്ട്രവൽക്കരണം (i18n): ഉപയോക്താവിന്റെ ലൊക്കേൽ അടിസ്ഥാനമാക്കി ഡെക്കറേറ്ററുകൾക്ക് സ്വയമേവ ടെക്സ്റ്റ് വിവർത്തനം ചെയ്യാൻ കഴിയും. ഒരു @translate ഡെക്കറേറ്ററിന് വിവർത്തനം ചെയ്യേണ്ട പ്രോപ്പർട്ടികളെയോ മെത്തേഡുകളെയോ അടയാളപ്പെടുത്താൻ കഴിയും. തുടർന്ന് ഡെക്കറേറ്റർ ഉപയോക്താവ് തിരഞ്ഞെടുത്ത ഭാഷയെ അടിസ്ഥാനമാക്കി ഒരു റിസോഴ്സ് ബണ്ടിലിൽ നിന്ന് ഉചിതമായ വിവർത്തനം ലഭ്യമാക്കും.
• കറൻസി പരിവർത്തനം: വിലകൾ പ്രദർശിപ്പിക്കുമ്പോൾ, ഒരു @currency ഡെക്കറേറ്ററിന് വില ഉപയോക്താവിന്റെ പ്രാദേശിക കറൻസിയിലേക്ക് സ്വയമേവ പരിവർത്തനം ചെയ്യാൻ കഴിയും. ഈ ഡെക്കറേറ്ററിന് ഒരു ബാഹ്യ കറൻസി പരിവർത്തന API ആക്‌സസ് ചെയ്യുകയും പരിവർത്തന നിരക്കുകൾ സംഭരിക്കുകയും ചെയ്യേണ്ടതുണ്ട്.
• നികുതി കണക്കുകൂട്ടൽ: രാജ്യങ്ങളും പ്രദേശങ്ങളും അനുസരിച്ച് നികുതി നിയമങ്ങൾ കാര്യമായി വ്യത്യാസപ്പെട്ടിരിക്കുന്നു. ഉപയോക്താവിന്റെ ലൊക്കേഷനും വാങ്ങുന്ന ഉൽപ്പന്നവും അടിസ്ഥാനമാക്കി ശരിയായ നികുതി നിരക്ക് പ്രയോഗിക്കാൻ ഡെക്കറേറ്ററുകൾ ഉപയോഗിക്കാം. ഉചിതമായ നികുതി നിരക്ക് നിർണ്ണയിക്കാൻ ഒരു @tax ഡെക്കറേറ്ററിന് ജിയോലൊക്കേഷൻ വിവരങ്ങൾ ഉപയോഗിക്കാം.
• തട്ടിപ്പ് കണ്ടെത്തൽ: സെൻസിറ്റീവായ പ്രവർത്തനങ്ങളിൽ (ചെക്ക്ഔട്ട് പോലുള്ളവ) ഒരു @fraudCheck ഡെക്കറേറ്റർ തട്ടിപ്പ് കണ്ടെത്തൽ അൽഗോരിതങ്ങളെ പ്രവർത്തനക്ഷമമാക്കും.

മറ്റൊരു ഉദാഹരണം ഒരു ആഗോള ലോജിസ്റ്റിക്സ് കമ്പനിയാണ്:

• ജിയോലൊക്കേഷൻ ട്രാക്കിംഗ്: ലൊക്കേഷൻ ഡാറ്റ കൈകാര്യം ചെയ്യുന്ന മെത്തേഡുകളെ മെച്ചപ്പെടുത്താൻ ഡെക്കറേറ്ററുകൾക്ക് കഴിയും, GPS റീഡിംഗുകളുടെ കൃത്യത ലോഗ് ചെയ്യുകയോ വിവിധ പ്രദേശങ്ങൾക്കായുള്ള ലൊക്കേഷൻ ഫോർമാറ്റുകൾ (അക്ഷാംശം/രേഖാംശം) സാധൂകരിക്കുകയോ ചെയ്യാം. ഒരു @validateLocation ഡെക്കറേറ്ററിന് കോർഡിനേറ്റുകൾ പ്രോസസ്സ് ചെയ്യുന്നതിന് മുമ്പ് ഒരു പ്രത്യേക മാനദണ്ഡം (ഉദാഹരണത്തിന്, ISO 6709) പാലിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കാൻ കഴിയും.
• സമയ മേഖല കൈകാര്യം ചെയ്യൽ: ഡെലിവറികൾ ഷെഡ്യൂൾ ചെയ്യുമ്പോൾ, ഡെക്കറേറ്ററുകൾക്ക് സമയങ്ങളെ ഉപയോക്താവിന്റെ പ്രാദേശിക സമയ മേഖലയിലേക്ക് സ്വയമേവ പരിവർത്തനം ചെയ്യാൻ കഴിയും. ഒരു @timeZone ഡെക്കറേറ്റർ പരിവർത്തനം നടത്താൻ ഒരു ടൈം സോൺ ഡാറ്റാബേസ് ഉപയോഗിക്കും, ഇത് ഉപയോക്താവിന്റെ ലൊക്കേഷൻ പരിഗണിക്കാതെ ഡെലിവറി ഷെഡ്യൂളുകൾ കൃത്യമാണെന്ന് ഉറപ്പാക്കുന്നു.
• റൂട്ട് ഒപ്റ്റിമൈസേഷൻ: ഡെലിവറി അഭ്യർത്ഥനകളുടെ ഉറവിടവും ലക്ഷ്യസ്ഥാന വിലാസങ്ങളും വിശകലനം ചെയ്യാൻ ഡെക്കറേറ്ററുകൾ ഉപയോഗിക്കാം. വിവിധ രാജ്യങ്ങളിലെ ട്രാഫിക് സാഹചര്യങ്ങളും റോഡ് അടയ്ക്കലുകളും പോലുള്ള ഘടകങ്ങൾ പരിഗണിച്ച് ഏറ്റവും കാര്യക്ഷമമായ റൂട്ട് കണ്ടെത്താൻ ഒരു @routeOptimize ഡെക്കറേറ്ററിന് ഒരു ബാഹ്യ റൂട്ട് ഒപ്റ്റിമൈസേഷൻ API-യെ വിളിക്കാൻ കഴിയും.

ഡെക്കറേറ്ററുകളും ടൈപ്പ്സ്ക്രിപ്റ്റും

ടൈപ്പ്സ്ക്രിപ്റ്റിന് ഡെക്കറേറ്ററുകൾക്ക് മികച്ച പിന്തുണയുണ്ട്. ടൈപ്പ്സ്ക്രിപ്റ്റിൽ ഡെക്കറേറ്ററുകൾ ഉപയോഗിക്കുന്നതിന്, നിങ്ങളുടെ tsconfig.json ഫയലിൽ experimentalDecorators കംപൈലർ ഓപ്ഷൻ പ്രവർത്തനക്ഷമമാക്കേണ്ടതുണ്ട്:

            {
  "compilerOptions": {
    "target": "es6",
    "experimentalDecorators": true,
    // ... other options
  }
}

            

              
                Copy
              
            
          

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

ഡെക്കറേറ്ററുകളുടെ ഭാവി

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

വെല്ലുവിളികളും പരിഗണനകളും

• സങ്കീർണ്ണത: ഡെക്കറേറ്ററുകളുടെ അമിതമായ ഉപയോഗം മനസ്സിലാക്കാൻ പ്രയാസമുള്ള സങ്കീർണ്ണമായ കോഡിലേക്ക് നയിച്ചേക്കാം. അവ വിവേകത്തോടെ ഉപയോഗിക്കുകയും സമഗ്രമായി ഡോക്യുമെന്റ് ചെയ്യുകയും ചെയ്യേണ്ടത് അത്യാവശ്യമാണ്.
• പ്രകടനം: ഡെക്കറേറ്ററുകൾ ഓവർഹെഡ് ഉണ്ടാക്കിയേക്കാം, പ്രത്യേകിച്ചും അവ റൺടൈമിൽ സങ്കീർണ്ണമായ പ്രവർത്തനങ്ങൾ നടത്തുകയാണെങ്കിൽ. ഡെക്കറേറ്ററുകൾ ഉപയോഗിക്കുന്നതിന്റെ പ്രകടനപരമായ പ്രത്യാഘാതങ്ങൾ പരിഗണിക്കേണ്ടത് പ്രധാനമാണ്.
• ഡീബഗ്ഗിംഗ്: ഡെക്കറേറ്ററുകൾ ഉപയോഗിക്കുന്ന കോഡ് ഡീബഗ് ചെയ്യുന്നത് വെല്ലുവിളി നിറഞ്ഞതാകാം, കാരണം എക്സിക്യൂഷൻ ഫ്ലോ അത്ര നേർരേഖയിലായിരിക്കില്ല. നല്ല ലോഗിംഗ് രീതികളും ഡീബഗ്ഗിംഗ് ടൂളുകളും അത്യാവശ്യമാണ്.
• പഠന കാലയളവ്: ഡെക്കറേറ്ററുകളുമായി പരിചയമില്ലാത്ത ഡെവലപ്പർമാർക്ക് അവ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് പഠിക്കാൻ സമയം നിക്ഷേപിക്കേണ്ടി വന്നേക്കാം.

ഡെക്കറേറ്ററുകൾ ഉപയോഗിക്കുന്നതിനുള്ള മികച്ച രീതികൾ

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

ഉപസംഹാരം

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