ജാവാസ്ക്രിപ്റ്റ് പ്രോക്സി എപിഐ: ഒബ്ജക്റ്റ് ബിഹേവിയർ മോഡിഫിക്കേഷനിലേക്ക് ഒരു ആഴത്തിലുള്ള പഠനം

ആധുനിക ജാവാസ്ക്രിപ്റ്റിന്റെ വികസിച്ചുകൊണ്ടിരിക്കുന്ന ലോകത്ത്, ഡാറ്റ കൈകാര്യം ചെയ്യുന്നതിനും സംവദിക്കുന്നതിനും കൂടുതൽ ശക്തവും ലളിതവുമായ മാർഗ്ഗങ്ങൾ ഡെവലപ്പർമാർ നിരന്തരം തേടുന്നു. ക്ലാസുകൾ, മൊഡ്യൂളുകൾ, async/await തുടങ്ങിയ ഫീച്ചറുകൾ നമ്മൾ കോഡ് എഴുതുന്ന രീതിയിൽ വിപ്ലവം സൃഷ്ടിച്ചെങ്കിലും, ECMAScript 2015-ൽ (ES6) അവതരിപ്പിച്ച ഒരു ശക്തമായ മെറ്റാപ്രോഗ്രാമിംഗ് ഫീച്ചർ പലപ്പോഴും വേണ്ടത്ര ഉപയോഗിക്കാതെ പോകുന്നു: അതാണ് പ്രോക്സി എപിഐ (Proxy API).

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

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

പ്രധാന ആശയങ്ങൾ മനസ്സിലാക്കാം: ടാർഗെറ്റ്, ഹാൻഡ്‌ലർ, ട്രാപ്പുകൾ

പ്രോക്സി എപിഐ മൂന്ന് അടിസ്ഥാന ഘടകങ്ങളെ ആശ്രയിച്ചാണ് നിർമ്മിച്ചിരിക്കുന്നത്. ഇവയുടെ പങ്കുകൾ മനസ്സിലാക്കുന്നത് പ്രോക്സികൾ മാസ്റ്റർ ചെയ്യുന്നതിനുള്ള താക്കോലാണ്.

• ടാർഗെറ്റ് (Target): ഇത് നിങ്ങൾ റാപ്പ് ചെയ്യാൻ ആഗ്രഹിക്കുന്ന യഥാർത്ഥ ഒബ്ജക്റ്റാണ്. ഇത് ഏത് തരത്തിലുള്ള ഒബ്ജക്റ്റും ആകാം, അറേകൾ, ഫംഗ്ഷനുകൾ, അല്ലെങ്കിൽ മറ്റൊരു പ്രോക്സി പോലും. പ്രോക്സി ഈ ടാർഗെറ്റിനെ വെർച്വലൈസ് ചെയ്യുന്നു, കൂടാതെ എല്ലാ പ്രവർത്തനങ്ങളും ആത്യന്തികമായി (നിർബന്ധമില്ലെങ്കിലും) അതിലേക്ക് കൈമാറുന്നു.
• ഹാൻഡ്‌ലർ (Handler): പ്രോക്സിയുടെ ലോജിക് അടങ്ങിയിരിക്കുന്ന ഒബ്ജക്റ്റാണിത്. ഇതിന്റെ പ്രോപ്പർട്ടികൾ 'ട്രാപ്പുകൾ' എന്നറിയപ്പെടുന്ന ഫംഗ്ഷനുകളാണ്. പ്രോക്സിയിൽ ഒരു പ്രവർത്തനം നടക്കുമ്പോൾ, അത് ഹാൻഡ്‌ലറിൽ അനുയോജ്യമായ ഒരു ട്രാപ്പിനായി തിരയുന്നു.
• ട്രാപ്പുകൾ (Traps): പ്രോപ്പർട്ടി ആക്‌സസ്സ് നൽകുന്ന ഹാൻഡ്‌ലറിലെ മെത്തേഡുകളാണ് ഇവ. ഓരോ ട്രാപ്പും ഒരു അടിസ്ഥാന ഒബ്ജക്റ്റ് പ്രവർത്തനവുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു. ഉദാഹരണത്തിന്, get ട്രാപ്പ് പ്രോപ്പർട്ടി റീഡിംഗിനെയും set ട്രാപ്പ് പ്രോപ്പർട്ടി റൈറ്റിംഗിനെയും തടസ്സപ്പെടുത്തുന്നു. ഹാൻഡ്‌ലറിൽ ഒരു ട്രാപ്പ് നിർവചിച്ചിട്ടില്ലെങ്കിൽ, പ്രോക്സി ഇല്ലാത്തതുപോലെ പ്രവർത്തനം ടാർഗെറ്റിലേക്ക് കൈമാറുന്നു.

ഒരു പ്രോക്സി ഉണ്ടാക്കുന്നതിനുള്ള സിന്റാക്സ് ലളിതമാണ്:

const proxy = new Proxy(target, handler);

നമുക്ക് വളരെ ലളിതമായ ഒരു ഉദാഹരണം നോക്കാം. ശൂന്യമായ ഒരു ഹാൻഡ്‌ലർ ഉപയോഗിച്ച് എല്ലാ പ്രവർത്തനങ്ങളെയും ടാർഗെറ്റ് ഒബ്ജക്റ്റിലേക്ക് കൈമാറുന്ന ഒരു പ്രോക്സി ഞങ്ങൾ നിർമ്മിക്കും.

// യഥാർത്ഥ ഒബ്ജക്റ്റ്
const target = {
  message: "Hello, World!"
};

// ഒരു ശൂന്യമായ ഹാൻഡ്‌ലർ. എല്ലാ പ്രവർത്തനങ്ങളും ടാർഗെറ്റിലേക്ക് കൈമാറും.
const handler = {};

// പ്രോക്സി ഒബ്ജക്റ്റ്
const proxy = new Proxy(target, handler);

// പ്രോക്സിയിലെ ഒരു പ്രോപ്പർട്ടി ആക്‌സസ് ചെയ്യുന്നു
console.log(proxy.message); // ഔട്ട്പുട്ട്: Hello, World!

// പ്രവർത്തനം ടാർഗെറ്റിലേക്ക് കൈമാറി
console.log(target.message); // ഔട്ട്പുട്ട്: Hello, World!

// പ്രോക്സിയിലൂടെ ഒരു പ്രോപ്പർട്ടി പരിഷ്കരിക്കുന്നു
proxy.anotherMessage = "Hello, Proxy!";

console.log(proxy.anotherMessage); // ഔട്ട്പുട്ട്: Hello, Proxy!
console.log(target.anotherMessage); // ഔട്ട്പുട്ട്: Hello, Proxy!

ഈ ഉദാഹരണത്തിൽ, പ്രോക്സി യഥാർത്ഥ ഒബ്ജക്റ്റിനെപ്പോലെ തന്നെ പ്രവർത്തിക്കുന്നു. ഹാൻഡ്‌ലറിൽ ട്രാപ്പുകൾ നിർവചിക്കാൻ തുടങ്ങുമ്പോഴാണ് ഇതിന്റെ യഥാർത്ഥ ശക്തി വെളിവാകുന്നത്.

ഒരു പ്രോക്സിയുടെ ഘടന: സാധാരണ ട്രാപ്പുകൾ പരിചയപ്പെടാം

ഹാൻഡ്‌ലർ ഒബ്ജക്റ്റിൽ 13 വ്യത്യസ്ത ട്രാപ്പുകൾ വരെ ഉണ്ടാകാം, ഓരോന്നും ജാവാസ്ക്രിപ്റ്റ് ഒബ്ജക്റ്റുകളുടെ അടിസ്ഥാനപരമായ ആന്തരിക രീതികളുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു. നമുക്ക് ഏറ്റവും സാധാരണവും ഉപയോഗപ്രദവുമായവ പരിചയപ്പെടാം.

പ്രോപ്പർട്ടി ആക്സസ് ട്രാപ്പുകൾ

1. `get(target, property, receiver)`

ഇതാണ് ഒരുപക്ഷേ ഏറ്റവും കൂടുതൽ ഉപയോഗിക്കുന്ന ട്രാപ്പ്. പ്രോക്സിയുടെ ഒരു പ്രോപ്പർട്ടി വായിക്കുമ്പോൾ ഇത് ട്രിഗർ ചെയ്യപ്പെടുന്നു.

• target: യഥാർത്ഥ ഒബ്ജക്റ്റ്.
• property: ആക്‌സസ് ചെയ്യുന്ന പ്രോപ്പർട്ടിയുടെ പേര്.
• receiver: പ്രോക്സി തന്നെ, അല്ലെങ്കിൽ അതിൽ നിന്ന് ഇൻഹെരിറ്റ് ചെയ്യുന്ന ഒരു ഒബ്ജക്റ്റ്.

ഉദാഹരണം: ഇല്ലാത്ത പ്രോപ്പർട്ടികൾക്കായി ഡിഫോൾട്ട് മൂല്യങ്ങൾ.

const user = {
  firstName: 'John',
  lastName: 'Doe',
  age: 30
};

const userHandler = {
  get(target, property) {
    // പ്രോപ്പർട്ടി ടാർഗെറ്റിൽ ഉണ്ടെങ്കിൽ, അത് റിട്ടേൺ ചെയ്യുക.
    // അല്ലെങ്കിൽ, ഒരു ഡിഫോൾട്ട് സന്ദേശം റിട്ടേൺ ചെയ്യുക.
    return property in target ? target[property] : `Property '${property}' does not exist.`;
  }
};

const userProxy = new Proxy(user, userHandler);

console.log(userProxy.firstName); // ഔട്ട്പുട്ട്: John
console.log(userProxy.age);       // ഔട്ട്പുട്ട്: 30
console.log(userProxy.country);   // ഔട്ട്പുട്ട്: Property 'country' does not exist.

2. `set(target, property, value, receiver)`

പ്രോക്സിയുടെ ഒരു പ്രോപ്പർട്ടിക്ക് ഒരു മൂല്യം നൽകുമ്പോൾ set ട്രാപ്പ് വിളിക്കപ്പെടുന്നു. വാലിഡേഷൻ, ലോഗിംഗ്, അല്ലെങ്കിൽ റീഡ്-ഒൺലി ഒബ്ജക്റ്റുകൾ നിർമ്മിക്കാൻ ഇത് വളരെ അനുയോജ്യമാണ്.

• value: പ്രോപ്പർട്ടിക്ക് നൽകുന്ന പുതിയ മൂല്യം.
• ട്രാപ്പ് ഒരു ബൂളിയൻ റിട്ടേൺ ചെയ്യണം: അസൈൻമെന്റ് വിജയകരമാണെങ്കിൽ true, അല്ലെങ്കിൽ false (ഇത് സ്ട്രിക്റ്റ് മോഡിൽ ഒരു TypeError ത്രോ ചെയ്യും).

ഉദാഹരണം: ഡാറ്റാ വാലിഡേഷൻ.

const person = {
  name: 'Jane Doe',
  age: 25
};

const validationHandler = {
  set(target, property, value) {
    if (property === 'age') {
      if (typeof value !== 'number' || !Number.isInteger(value)) {
        throw new TypeError('പ്രായം ഒരു പൂർണ്ണസംഖ്യ ആയിരിക്കണം.');
      }
      if (value <= 0) {
        throw new RangeError('പ്രായം ഒരു പോസിറ്റീവ് സംഖ്യ ആയിരിക്കണം.');
      }
    }

    // വാലിഡേഷൻ പാസായാൽ, ടാർഗെറ്റ് ഒബ്ജക്റ്റിൽ മൂല്യം സെറ്റ് ചെയ്യുക.
    target[property] = value;

    // വിജയം സൂചിപ്പിക്കുക.
    return true;
  }
};

const personProxy = new Proxy(person, validationHandler);

personProxy.age = 30; // ഇത് സാധുവാണ്
console.log(personProxy.age); // ഔട്ട്പുട്ട്: 30

try {
  personProxy.age = 'thirty'; // TypeError ത്രോ ചെയ്യും
} catch (e) {
  console.error(e.message); // ഔട്ട്പുട്ട്: പ്രായം ഒരു പൂർണ്ണസംഖ്യ ആയിരിക്കണം.
}

try {
  personProxy.age = -5; // RangeError ത്രോ ചെയ്യും
} catch (e) {
  console.error(e.message); // ഔട്ട്പുട്ട്: പ്രായം ഒരു പോസിറ്റീവ് സംഖ്യ ആയിരിക്കണം.
}

3. `has(target, property)`

ഈ ട്രാപ്പ് in ഓപ്പറേറ്ററിനെ തടസ്സപ്പെടുത്തുന്നു. ഒരു ഒബ്ജക്റ്റിൽ ഏതൊക്കെ പ്രോപ്പർട്ടികൾ നിലവിലുണ്ടെന്ന് തോന്നണമെന്ന് നിയന്ത്രിക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

ഉദാഹരണം: 'പ്രൈവറ്റ്' പ്രോപ്പർട്ടികൾ മറയ്ക്കുന്നു.

ജാവാസ്ക്രിപ്റ്റിൽ, പ്രൈവറ്റ് പ്രോപ്പർട്ടികൾക്ക് ഒരു അണ്ടർസ്കോർ (_) പ്രിഫിക്സ് ചെയ്യുന്നത് ഒരു സാധാരണ രീതിയാണ്. in ഓപ്പറേറ്ററിൽ നിന്ന് ഇവയെ മറയ്ക്കാൻ നമുക്ക് has ട്രാപ്പ് ഉപയോഗിക്കാം.

const secretData = {
  _apiKey: 'xyz123abc',
  publicKey: 'pub456def',
  id: 1
};

const hidingHandler = {
  has(target, property) {
    if (property.startsWith('_')) {
      return false; // അത് നിലവിലില്ലെന്ന് നടിക്കുക
    }
    return property in target;
  }
};

const dataProxy = new Proxy(secretData, hidingHandler);

console.log('publicKey' in dataProxy); // ഔട്ട്പുട്ട്: true
console.log('_apiKey' in dataProxy);   // ഔട്ട്പുട്ട്: false (ടാർഗെറ്റിൽ ഉണ്ടെങ്കിലും)
console.log('id' in dataProxy);        // ഔട്ട്പുട്ട്: true

ശ്രദ്ധിക്കുക: ഇത് in ഓപ്പറേറ്ററിനെ മാത്രമേ ബാധിക്കുകയുള്ളൂ. അനുയോജ്യമായ ഒരു get ട്രാപ്പ് കൂടി നടപ്പിലാക്കിയില്ലെങ്കിൽ dataProxy._apiKey പോലുള്ള നേരിട്ടുള്ള ആക്‌സസ്സ് ഇപ്പോഴും പ്രവർത്തിക്കും.

4. `deleteProperty(target, property)`

delete ഓപ്പറേറ്റർ ഉപയോഗിച്ച് ഒരു പ്രോപ്പർട്ടി ഇല്ലാതാക്കുമ്പോൾ ഈ ട്രാപ്പ് എക്സിക്യൂട്ട് ചെയ്യപ്പെടുന്നു. പ്രധാനപ്പെട്ട പ്രോപ്പർട്ടികൾ ഇല്ലാതാക്കുന്നത് തടയാൻ ഇത് ഉപയോഗപ്രദമാണ്.

ട്രാപ്പ് വിജയകരമായ ഡിലീറ്റിന് true അല്ലെങ്കിൽ പരാജയപ്പെട്ടതിന് false റിട്ടേൺ ചെയ്യണം.

ഉദാഹരണം: പ്രോപ്പർട്ടികൾ ഇല്ലാതാക്കുന്നത് തടയുന്നു.

const immutableConfig = {
  databaseUrl: 'prod.db.server',
  port: 8080
};

const deletionGuardHandler = {
  deleteProperty(target, property) {
    if (property in target) {
      console.warn(`സംരക്ഷിത പ്രോപ്പർട്ടി '${property}' ഇല്ലാതാക്കാൻ ശ്രമിച്ചു. പ്രവർത്തനം നിരസിച്ചു.`);
      return false;
    }
    return true; // പ്രോപ്പർട്ടി എന്തായാലും നിലവിലില്ല
  }
};

const configProxy = new Proxy(immutableConfig, deletionGuardHandler);

delete configProxy.port;
// കൺസോൾ ഔട്ട്പുട്ട്: സംരക്ഷിത പ്രോപ്പർട്ടി 'port' ഇല്ലാതാക്കാൻ ശ്രമിച്ചു. പ്രവർത്തനം നിരസിച്ചു.

console.log(configProxy.port); // ഔട്ട്പുട്ട്: 8080 (ഇത് ഇല്ലാതാക്കിയിട്ടില്ല)

ഒബ്ജക്റ്റ് എന്യൂമറേഷൻ, ഡിസ്ക്രിപ്ഷൻ ട്രാപ്പുകൾ

5. `ownKeys(target)`

Object.keys(), Object.getOwnPropertyNames(), Object.getOwnPropertySymbols(), Reflect.ownKeys() പോലുള്ള, ഒരു ഒബ്ജക്റ്റിന്റെ സ്വന്തം പ്രോപ്പർട്ടികളുടെ ലിസ്റ്റ് ലഭിക്കുന്ന പ്രവർത്തനങ്ങൾ നടക്കുമ്പോൾ ഈ ട്രാപ്പ് ട്രിഗർ ചെയ്യപ്പെടുന്നു.

ഉദാഹരണം: കീകൾ ഫിൽട്ടർ ചെയ്യുന്നു.

നമ്മുടെ മുൻപത്തെ 'പ്രൈവറ്റ്' പ്രോപ്പർട്ടി ഉദാഹരണവുമായി ഇത് സംയോജിപ്പിച്ച് അവയെ പൂർണ്ണമായും മറയ്ക്കാം.

const secretData = {
  _apiKey: 'xyz123abc',
  publicKey: 'pub456def',
  id: 1
};

const keyHidingHandler = {
  has(target, property) {
    return !property.startsWith('_') && property in target;
  },
  ownKeys(target) {
    return Reflect.ownKeys(target).filter(key => !key.startsWith('_'));
  },
  get(target, property, receiver) {
    // നേരിട്ടുള്ള ആക്‌സസ്സും തടയുക
    if (property.startsWith('_')) {
      return undefined;
    }
    return Reflect.get(target, property, receiver);
  }
};

const fullProxy = new Proxy(secretData, keyHidingHandler);

console.log(Object.keys(fullProxy)); // ഔട്ട്പുട്ട്: ['publicKey', 'id']
console.log('publicKey' in fullProxy); // ഔട്ട്പുട്ട്: true
console.log('_apiKey' in fullProxy);   // ഔട്ട്പുട്ട്: false
console.log(fullProxy._apiKey);      // ഔട്ട്പുട്ട്: undefined

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

ഫംഗ്ഷൻ, കൺസ്ട്രക്റ്റർ ട്രാപ്പുകൾ

പ്രോക്സികൾ പ്ലെയിൻ ഒബ്ജക്റ്റുകളിൽ മാത്രം ഒതുങ്ങുന്നില്ല. ടാർഗെറ്റ് ഒരു ഫംഗ്ഷനായിരിക്കുമ്പോൾ, കോളുകളും കൺസ്ട്രക്ഷനുകളും നിങ്ങൾക്ക് തടസ്സപ്പെടുത്താൻ കഴിയും.

6. `apply(target, thisArg, argumentsList)`

ഒരു ഫംഗ്ഷന്റെ പ്രോക്സി എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ ഈ ട്രാപ്പ് വിളിക്കപ്പെടുന്നു. ഇത് ഫംഗ്ഷൻ കോളിനെ തടസ്സപ്പെടുത്തുന്നു.

• target: യഥാർത്ഥ ഫംഗ്ഷൻ.
• thisArg: കോളിനുള്ള this കോൺടെക്സ്റ്റ്.
• argumentsList: ഫംഗ്ഷനിലേക്ക് പാസ് ചെയ്ത ആർഗ്യുമെന്റുകളുടെ ലിസ്റ്റ്.

ഉദാഹരണം: ഫംഗ്ഷൻ കോളുകളും അവയുടെ ആർഗ്യുമെന്റുകളും ലോഗ് ചെയ്യുന്നു.

function sum(a, b) {
  return a + b;
}

const loggingHandler = {
  apply(target, thisArg, argumentsList) {
    console.log(`'${target.name}' എന്ന ഫംഗ്ഷൻ ആർഗ്യുമെന്റുകളോടൊപ്പം വിളിക്കുന്നു: ${argumentsList}`);
    // ശരിയായ കോൺടെക്സ്റ്റും ആർഗ്യുമെന്റുകളുമായി യഥാർത്ഥ ഫംഗ്ഷൻ എക്സിക്യൂട്ട് ചെയ്യുക
    const result = Reflect.apply(target, thisArg, argumentsList);
    console.log(`'${target.name}' എന്ന ഫംഗ്ഷൻ റിട്ടേൺ ചെയ്തത്: ${result}`);
    return result;
  }
};

const proxiedSum = new Proxy(sum, loggingHandler);

proxiedSum(5, 10);
// കൺസോൾ ഔട്ട്പുട്ട്:
// 'sum' എന്ന ഫംഗ്ഷൻ ആർഗ്യുമെന്റുകളോടൊപ്പം വിളിക്കുന്നു: 5,10
// 'sum' എന്ന ഫംഗ്ഷൻ റിട്ടേൺ ചെയ്തത്: 15

7. `construct(target, argumentsList, newTarget)`

ഒരു ക്ലാസ്സിന്റെയോ ഫംഗ്ഷന്റെയോ പ്രോക്സിയിൽ new ഓപ്പറേറ്റർ ഉപയോഗിക്കുമ്പോൾ ഈ ട്രാപ്പ് തടസ്സപ്പെടുത്തുന്നു.

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

class MyDatabaseConnection {
  constructor(url) {
    this.url = url;
    console.log(`${this.url}-ലേക്ക് കണക്റ്റുചെയ്യുന്നു...`);
  }
}

let instance;

const singletonHandler = {
  construct(target, argumentsList) {
    if (!instance) {
      console.log('പുതിയ ഇൻസ്റ്റൻസ് ഉണ്ടാക്കുന്നു.');
      instance = Reflect.construct(target, argumentsList);
    }
    console.log('നിലവിലുള്ള ഇൻസ്റ്റൻസ് റിട്ടേൺ ചെയ്യുന്നു.');
    return instance;
  }
};

const ProxiedConnection = new Proxy(MyDatabaseConnection, singletonHandler);

const conn1 = new ProxiedConnection('db://primary');
// കൺസോൾ ഔട്ട്പുട്ട്:
// പുതിയ ഇൻസ്റ്റൻസ് ഉണ്ടാക്കുന്നു.
// db://primary-ലേക്ക് കണക്റ്റുചെയ്യുന്നു...
// നിലവിലുള്ള ഇൻസ്റ്റൻസ് റിട്ടേൺ ചെയ്യുന്നു.

const conn2 = new ProxiedConnection('db://secondary'); // URL അവഗണിക്കപ്പെടും
// കൺസോൾ ഔട്ട്പുട്ട്:
// നിലവിലുള്ള ഇൻസ്റ്റൻസ് റിട്ടേൺ ചെയ്യുന്നു.

console.log(conn1 === conn2); // ഔട്ട്പുട്ട്: true
console.log(conn1.url); // ഔട്ട്പുട്ട്: db://primary
console.log(conn2.url); // ഔട്ട്പുട്ട്: db://primary

പ്രായോഗിക ഉപയോഗങ്ങളും അഡ്വാൻസ്ഡ് പാറ്റേണുകളും

ഇപ്പോൾ നമ്മൾ ഓരോ ട്രാപ്പുകളെയും കുറിച്ച് പഠിച്ചുകഴിഞ്ഞു, യഥാർത്ഥ ലോകത്തിലെ പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ അവ എങ്ങനെ സംയോജിപ്പിക്കാമെന്ന് നോക്കാം.

1. എപിഐ അബ്സ്ട്രാക്ഷനും ഡാറ്റാ ട്രാൻസ്ഫോർമേഷനും

എപിഐകൾ പലപ്പോഴും നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ രീതികളുമായി പൊരുത്തപ്പെടാത്ത ഫോർമാറ്റിൽ ഡാറ്റ റിട്ടേൺ ചെയ്യാറുണ്ട് (ഉദാഹരണത്തിന്, snake_case vs. camelCase). ഒരു പ്രോക്സിക്ക് ഈ പരിവർത്തനം സുതാര്യമായി കൈകാര്യം ചെയ്യാൻ കഴിയും.

function snakeToCamel(s) {
  return s.replace(/(_\w)/g, (m) => m[1].toUpperCase());
}

// ഇത് ഒരു എപിഐയിൽ നിന്നുള്ള റോ ഡാറ്റയാണെന്ന് സങ്കൽപ്പിക്കുക
const apiResponse = {
  user_id: 123,
  first_name: 'Alice',
  last_name: 'Wonderland',
  account_status: 'active'
};

const camelCaseHandler = {
  get(target, property) {
    const camelCaseProperty = snakeToCamel(property);
    // camelCase പതിപ്പ് നേരിട്ട് നിലവിലുണ്ടോയെന്ന് പരിശോധിക്കുക
    if (camelCaseProperty in target) {
      return target[camelCaseProperty];
    }
    // യഥാർത്ഥ പ്രോപ്പർട്ടി നാമത്തിലേക്ക് മടങ്ങുക
    if (property in target) {
      return target[property];
    }
    return undefined;
  }
};

const userModel = new Proxy(apiResponse, camelCaseHandler);

// പ്രോപ്പർട്ടികൾ snake_case ആയി സംഭരിച്ചിട്ടുണ്ടെങ്കിലും നമുക്ക് ഇപ്പോൾ camelCase ഉപയോഗിച്ച് ആക്സസ് ചെയ്യാം
console.log(userModel.userId);        // ഔട്ട്പുട്ട്: 123
console.log(userModel.firstName);     // ഔട്ട്പുട്ട്: Alice
console.log(userModel.accountStatus); // ഔട്ട്പുട്ട്: active

2. ഒബ്സർവബിൾസും ഡാറ്റാ ബൈൻഡിംഗും (ആധുനിക ഫ്രെയിംവർക്കുകളുടെ കാതൽ)

Vue 3 പോലുള്ള ആധുനിക ഫ്രെയിംവർക്കുകളിലെ റിയാക്റ്റിവിറ്റി സിസ്റ്റങ്ങളുടെ പിന്നിലെ എഞ്ചിൻ പ്രോക്സികളാണ്. ഒരു പ്രോക്സി ചെയ്ത സ്റ്റേറ്റ് ഒബ്ജക്റ്റിലെ ഒരു പ്രോപ്പർട്ടി നിങ്ങൾ മാറ്റുമ്പോൾ, യുഐയിലോ ആപ്ലിക്കേഷന്റെ മറ്റ് ഭാഗങ്ങളിലോ അപ്‌ഡേറ്റുകൾ ട്രിഗർ ചെയ്യാൻ set ട്രാപ്പ് ഉപയോഗിക്കാം.

ഇവിടെ വളരെ ലളിതമായ ഒരു ഉദാഹരണം നൽകുന്നു:

function createObservable(target, callback) {
  const handler = {
    set(obj, prop, value) {
      const result = Reflect.set(obj, prop, value);
      callback(prop, value); // മാറ്റം വരുമ്പോൾ കോൾബാക്ക് ട്രിഗർ ചെയ്യുക
      return result;
    }
  };
  return new Proxy(target, handler);
}

const state = {
  count: 0,
  message: 'Hello'
};

function render(prop, value) {
  console.log(`മാറ്റം കണ്ടെത്തി: '${prop}' എന്ന പ്രോപ്പർട്ടി '${value}' ആയി സജ്ജമാക്കി. യുഐ വീണ്ടും റെൻഡർ ചെയ്യുന്നു...`);
}

const observableState = createObservable(state, render);

observableState.count = 1;
// കൺസോൾ ഔട്ട്പുട്ട്: മാറ്റം കണ്ടെത്തി: 'count' എന്ന പ്രോപ്പർട്ടി '1' ആയി സജ്ജമാക്കി. യുഐ വീണ്ടും റെൻഡർ ചെയ്യുന്നു...

observableState.message = 'Goodbye';
// കൺസോൾ ഔട്ട്പുട്ട്: മാറ്റം കണ്ടെത്തി: 'message' എന്ന പ്രോപ്പർട്ടി 'Goodbye' ആയി സജ്ജമാക്കി. യുഐ വീണ്ടും റെൻഡർ ചെയ്യുന്നു...

3. നെഗറ്റീവ് അറേ ഇൻഡെക്സുകൾ

പൈത്തൺ പോലുള്ള ഭാഷകളിലേതുപോലെ, -1 അവസാനത്തെ എലമെന്റിനെ സൂചിപ്പിക്കുന്ന നെഗറ്റീവ് ഇൻഡെക്സുകളെ പിന്തുണയ്ക്കുന്നതിനായി നേറ്റീവ് അറേ സ്വഭാവം വികസിപ്പിക്കുന്നത് ഒരു ക്ലാസിക്, രസകരമായ ഉദാഹരണമാണ്.

function createNegativeArrayProxy(arr) {
  const handler = {
    get(target, property) {
      const index = Number(property);
      if (!Number.isNaN(index) && index < 0) {
        // നെഗറ്റീവ് ഇൻഡെക്സിനെ അവസാനം മുതൽ ഒരു പോസിറ്റീവ് ഒന്നാക്കി മാറ്റുക
        property = String(target.length + index);
      }
      return Reflect.get(target, property);
    }
  };
  return new Proxy(arr, handler);
}

const originalArray = ['a', 'b', 'c', 'd', 'e'];
const proxiedArray = createNegativeArrayProxy(originalArray);

console.log(proxiedArray[0]);  // ഔട്ട്പുട്ട്: a
console.log(proxiedArray[-1]); // ഔട്ട്പുട്ട്: e
console.log(proxiedArray[-2]); // ഔട്ട്പുട്ട്: d
console.log(proxiedArray.length); // ഔട്ട്പുട്ട്: 5

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

പ്രോക്സികൾ അവിശ്വസനീയമാംവിധം ശക്തമാണെങ്കിലും, അവ ഒരു മാന്ത്രിക വിദ്യയല്ല. അവയുടെ പ്രത്യാഘാതങ്ങൾ മനസ്സിലാക്കേണ്ടത് അത്യാവശ്യമാണ്.

പ്രകടനത്തിലെ ഓവർഹെഡ്

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

പ്രോക്സി ഇൻവേരിയന്റുകൾ

ഒരു ട്രാപ്പിന് ടാർഗെറ്റ് ഒബ്ജക്റ്റിന്റെ സ്വഭാവത്തെക്കുറിച്ച് പൂർണ്ണമായി കള്ളം പറയാൻ കഴിയില്ല. പ്രോക്സി ട്രാപ്പുകൾ അനുസരിക്കേണ്ട 'ഇൻവേരിയന്റുകൾ' എന്ന് വിളിക്കപ്പെടുന്ന ഒരു കൂട്ടം നിയമങ്ങൾ ജാവാസ്ക്രിപ്റ്റ് നടപ്പിലാക്കുന്നു. ഒരു ഇൻവേരിയന്റ് ലംഘിക്കുന്നത് ഒരു TypeError-ന് കാരണമാകും.

ഉദാഹരണത്തിന്, deleteProperty ട്രാപ്പിനായുള്ള ഒരു ഇൻവേരിയന്റ്, ടാർഗെറ്റ് ഒബ്ജക്റ്റിലെ അനുബന്ധ പ്രോപ്പർട്ടി കോൺഫിഗർ ചെയ്യാൻ കഴിയാത്തതാണെങ്കിൽ (non-configurable), അത് true (വിജയം സൂചിപ്പിക്കുന്നു) റിട്ടേൺ ചെയ്യാൻ കഴിയില്ല എന്നതാണ്. ഇത് ഇല്ലാതാക്കാൻ കഴിയാത്ത ഒരു പ്രോപ്പർട്ടി ഇല്ലാതാക്കിയെന്ന് പ്രോക്സി അവകാശപ്പെടുന്നത് തടയുന്നു.

const target = {};
Object.defineProperty(target, 'unbreakable', { value: 10, configurable: false });

const handler = {
  deleteProperty(target, prop) {
    // ഇത് ഇൻവേരിയന്റ് ലംഘിക്കും
    return true;
  }
};

const proxy = new Proxy(target, handler);

try {
  delete proxy.unbreakable; // ഇത് ഒരു പിശക് ത്രോ ചെയ്യും
} catch (e) {
  console.error(e.message);
  // ഔട്ട്പുട്ട്: 'deleteProperty' on proxy: returned true for non-configurable property 'unbreakable'
}

എപ്പോൾ പ്രോക്സികൾ ഉപയോഗിക്കാം (എപ്പോൾ ഉപയോഗിക്കരുത്)

• ഇവയ്ക്ക് നല്ലതാണ്: ഫ്രെയിംവർക്കുകളും ലൈബ്രറികളും നിർമ്മിക്കുന്നതിന് (ഉദാ. സ്റ്റേറ്റ് മാനേജ്മെന്റ്, ORM-കൾ), ഡീബഗ്ഗിംഗിനും ലോഗിംഗിനും, കരുത്തുറ്റ വാലിഡേഷൻ സിസ്റ്റങ്ങൾ നടപ്പിലാക്കുന്നതിന്, കൂടാതെ അടിസ്ഥാന ഡാറ്റാ സ്ട്രക്ച്ചറുകളെ അബ്സ്ട്രാക്ട് ചെയ്യുന്ന ശക്തമായ എപിഐകൾ നിർമ്മിക്കുന്നതിന്.
• ഇവയ്ക്ക് ബദലുകൾ പരിഗണിക്കുക: പ്രകടനം നിർണ്ണായകമായ അൽഗോരിതങ്ങൾ, ഒരു ക്ലാസ്സോ ഫാക്ടറി ഫംഗ്ഷനോ മതിയാകുന്ന ലളിതമായ ഒബ്ജക്റ്റ് എക്സ്റ്റൻഷനുകൾ, അല്ലെങ്കിൽ ES6 പിന്തുണയില്ലാത്ത വളരെ പഴയ ബ്രൗസറുകളെ പിന്തുണയ്ക്കേണ്ടി വരുമ്പോൾ.

റദ്ദാക്കാവുന്ന പ്രോക്സികൾ (Revocable Proxies)

ഒരു പ്രോക്സി 'ഓഫ്' ചെയ്യേണ്ട സാഹചര്യങ്ങളിൽ (ഉദാഹരണത്തിന്, സുരക്ഷാ കാരണങ്ങൾക്കോ മെമ്മറി മാനേജ്മെന്റിനോ വേണ്ടി), ജാവാസ്ക്രിപ്റ്റ് Proxy.revocable() നൽകുന്നു. ഇത് പ്രോക്സിയും ഒരു revoke ഫംഗ്ഷനും അടങ്ങുന്ന ഒരു ഒബ്ജക്റ്റ് റിട്ടേൺ ചെയ്യുന്നു.

const target = { data: 'sensitive' };
const handler = {};

const { proxy, revoke } = Proxy.revocable(target, handler);

console.log(proxy.data); // ഔട്ട്പുട്ട്: sensitive

// ഇപ്പോൾ, നമ്മൾ പ്രോക്സിയുടെ ആക്‌സസ്സ് റദ്ദാക്കുന്നു
revoke();

try {
  console.log(proxy.data); // ഇത് ഒരു പിശക് ത്രോ ചെയ്യും
} catch (e) {
  console.error(e.message);
  // ഔട്ട്പുട്ട്: Cannot perform 'get' on a proxy that has been revoked
}

പ്രോക്സികളും മറ്റ് മെറ്റാപ്രോഗ്രാമിംഗ് ടെക്നിക്കുകളും

പ്രോക്സികൾക്ക് മുമ്പ്, സമാനമായ ലക്ഷ്യങ്ങൾ നേടാൻ ഡെവലപ്പർമാർ മറ്റ് രീതികൾ ഉപയോഗിച്ചിരുന്നു. പ്രോക്സികൾ എങ്ങനെ താരതമ്യം ചെയ്യുന്നുവെന്ന് മനസ്സിലാക്കുന്നത് ഉപയോഗപ്രദമാണ്.

`Object.defineProperty()`

Object.defineProperty() നിർദ്ദിഷ്ട പ്രോപ്പർട്ടികൾക്കായി ഗെറ്ററുകളും സെറ്ററുകളും നിർവചിച്ച് ഒരു ഒബ്ജക്റ്റിനെ നേരിട്ട് പരിഷ്കരിക്കുന്നു. മറുവശത്ത്, പ്രോക്സികൾ യഥാർത്ഥ ഒബ്ജക്റ്റിനെ ഒട്ടും പരിഷ്കരിക്കുന്നില്ല; അവ അതിനെ പൊതിയുന്നു (wrap).

• പരിധി (Scope): `defineProperty` ഓരോ പ്രോപ്പർട്ടിയുടെ അടിസ്ഥാനത്തിൽ പ്രവർത്തിക്കുന്നു. നിങ്ങൾ നിരീക്ഷിക്കാൻ ആഗ്രഹിക്കുന്ന ഓരോ പ്രോപ്പർട്ടിക്കും ഒരു ഗെറ്റർ/സെറ്റർ നിർവചിക്കണം. ഒരു പ്രോക്സിയുടെ get, set ട്രാപ്പുകൾ ഗ്ലോബലാണ്, പിന്നീട് ചേർത്ത പുതിയവ ഉൾപ്പെടെ ഏത് പ്രോപ്പർട്ടിയിലെയും പ്രവർത്തനങ്ങളെ പിടികൂടുന്നു.
• കഴിവുകൾ (Capabilities): `deleteProperty`, in ഓപ്പറേറ്റർ, ഫംഗ്ഷൻ കോളുകൾ എന്നിവ പോലുള്ള വിപുലമായ പ്രവർത്തനങ്ങളെ പ്രോക്സികൾക്ക് തടസ്സപ്പെടുത്താൻ കഴിയും, ഇത് `defineProperty`-ന് കഴിയില്ല.

ഉപസംഹാരം: വെർച്വലൈസേഷന്റെ ശക്തി

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

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