జావాస్క్రిప్ట్ ప్రాక్సీ ప్యాటర్న్స్: ఆబ్జెక్ట్ ప్రవర్తన మార్పులో నైపుణ్యం

జావాస్క్రిప్ట్ ప్రాక్సీ ఆబ్జెక్ట్, ఆబ్జెక్టులపై ప్రాథమిక కార్యకలాపాలను అడ్డగించడానికి మరియు అనుకూలీకరించడానికి ఒక శక్తివంతమైన యంత్రాంగాన్ని అందిస్తుంది. ఈ సామర్థ్యం ఆబ్జెక్ట్ ప్రవర్తనను నియంత్రించడానికి అనేక రకాల డిజైన్ ప్యాటర్న్స్ మరియు అధునాతన టెక్నిక్స్ కు తలుపులు తెరుస్తుంది. ఈ సమగ్ర గైడ్ ప్రాక్సీ ప్యాటర్న్స్‌ను వివరిస్తుంది, వాటి ఉపయోగాలను ఆచరణాత్మక కోడ్ ఉదాహరణలతో వివరిస్తుంది.

జావాస్క్రిప్ట్ ప్రాక్సీ అంటే ఏమిటి?

ఒక ప్రాక్సీ ఆబ్జెక్ట్ మరొక ఆబ్జెక్ట్ (టార్గెట్)ను చుట్టి, దాని కార్యకలాపాలను అడ్డగిస్తుంది. ఈ కార్యకలాపాలను 'ట్రాప్స్' అని అంటారు, వీటిలో ప్రాపర్టీ లూకప్, అసైన్‌మెంట్, ఎన్యుమరేషన్, మరియు ఫంక్షన్ ఇన్వొకేషన్ ఉంటాయి. ఈ కార్యకలాపాలకు ముందు, తర్వాత, లేదా వాటికి బదులుగా అమలు చేయడానికి ప్రాక్సీ మీకు అనుకూల లాజిక్‌ను నిర్వచించడానికి అనుమతిస్తుంది. ప్రాక్సీ యొక్క ముఖ్య భావన "మెటాప్రోగ్రామింగ్"తో ముడిపడి ఉంది, ఇది జావాస్క్రిప్ట్ భాష యొక్క ప్రవర్తనను మార్చడానికి మీకు సహాయపడుతుంది.

ప్రాక్సీని సృష్టించడానికి ప్రాథమిక సింటాక్స్:

const proxy = new Proxy(target, handler);

• టార్గెట్: మీరు ప్రాక్సీ చేయాలనుకుంటున్న అసలు ఆబ్జెక్ట్.
• హ్యాండ్లర్: టార్గెట్‌పై కార్యకలాపాలను ప్రాక్సీ ఎలా అడ్డగిస్తుందో నిర్వచించే మెథడ్స్ (ట్రాప్స్) ఉన్న ఆబ్జెక్ట్.

సాధారణ ప్రాక్సీ ట్రాప్స్

హ్యాండ్లర్ ఆబ్జెక్ట్ అనేక ట్రాప్స్‌ను నిర్వచించగలదు. ఇక్కడ కొన్ని ఎక్కువగా ఉపయోగించేవి:

• get(target, property, receiver): ప్రాపర్టీ యాక్సెస్ (ఉదా., obj.property)ను అడ్డగిస్తుంది.
• set(target, property, value, receiver): ప్రాపర్టీ అసైన్‌మెంట్ (ఉదా., obj.property = value)ను అడ్డగిస్తుంది.
• has(target, property): in ఆపరేటర్ (ఉదా., 'property' in obj)ను అడ్డగిస్తుంది.
• deleteProperty(target, property): delete ఆపరేటర్ (ఉదా., delete obj.property)ను అడ్డగిస్తుంది.
• apply(target, thisArg, argumentsList): ఫంక్షన్ కాల్స్ (టార్గెట్ ఒక ఫంక్షన్ అయినప్పుడు)ను అడ్డగిస్తుంది.
• construct(target, argumentsList, newTarget): new ఆపరేటర్ (టార్గెట్ ఒక కన్స్ట్రక్టర్ ఫంక్షన్ అయినప్పుడు)ను అడ్డగిస్తుంది.
• getPrototypeOf(target): Object.getPrototypeOf() కాల్స్‌ను అడ్డగిస్తుంది.
• setPrototypeOf(target, prototype): Object.setPrototypeOf() కాల్స్‌ను అడ్డగిస్తుంది.
• isExtensible(target): Object.isExtensible() కాల్స్‌ను అడ్డగిస్తుంది.
• preventExtensions(target): Object.preventExtensions() కాల్స్‌ను అడ్డగిస్తుంది.
• getOwnPropertyDescriptor(target, property): Object.getOwnPropertyDescriptor() కాల్స్‌ను అడ్డగిస్తుంది.
• defineProperty(target, property, descriptor): Object.defineProperty() కాల్స్‌ను అడ్డగిస్తుంది.
• ownKeys(target): Object.getOwnPropertyNames() మరియు Object.getOwnPropertySymbols() కాల్స్‌ను అడ్డగిస్తుంది.

ప్రాక్సీ ప్యాటర్న్స్ మరియు వినియోగ సందర్భాలు

కొన్ని సాధారణ ప్రాక్సీ ప్యాటర్న్స్‌ను మరియు వాస్తవ-ప్రపంచ దృశ్యాలలో వాటిని ఎలా అన్వయించవచ్చో చూద్దాం:

1. ధృవీకరణ (Validation)

ధృవీకరణ ప్యాటర్న్ ప్రాపర్టీ అసైన్‌మెంట్‌లపై పరిమితులను అమలు చేయడానికి ప్రాక్సీని ఉపయోగిస్తుంది. ఇది డేటా సమగ్రతను నిర్ధారించడానికి ఉపయోగపడుతుంది.

const validator = {
  set: function(obj, prop, value) {
    if (prop === 'age') {
      if (!Number.isInteger(value)) {
        throw new TypeError('Age is not an integer');
      }
      if (value < 0) {
        throw new RangeError('Age must be a non-negative integer');
      }
    }

    // The default behavior to store the value
    obj[prop] = value;

    // Indicate success
    return true;
  }
};

let person = {};
let proxy = new Proxy(person, validator);

proxy.age = 25; // Valid
console.log(proxy.age); // Output: 25

try {
  proxy.age = 'young'; // Throws TypeError
} catch (e) {
  console.log(e); // Output: TypeError: Age is not an integer
}

try {
  proxy.age = -10; // Throws RangeError
} catch (e) {
  console.log(e); // Output: RangeError: Age must be a non-negative integer
}

ఉదాహరణ: వినియోగదారు డేటాకు ధృవీకరణ అవసరమయ్యే ఒక ఇ-కామర్స్ ప్లాట్‌ఫారమ్‌ను పరిగణించండి. ఒక ప్రాక్సీ వయస్సు, ఇమెయిల్ ఫార్మాట్, పాస్‌వర్డ్ బలం మరియు ఇతర ఫీల్డ్‌లపై నియమాలను అమలు చేసి, చెల్లని డేటా నిల్వ చేయబడకుండా నిరోధించగలదు.

2. వర్చువలైజేషన్ (లేజీ లోడింగ్)

వర్చువలైజేషన్, దీనిని లేజీ లోడింగ్ అని కూడా అంటారు, ఖరీదైన వనరులు వాస్తవంగా అవసరమయ్యే వరకు వాటి లోడింగ్‌ను ఆలస్యం చేస్తుంది. ఒక ప్రాపర్టీని యాక్సెస్ చేసినప్పుడు మాత్రమే నిజమైన ఆబ్జెక్ట్‌ను లోడ్ చేస్తూ, ప్రాక్సీ ప్లేస్‌హోల్డర్‌గా పనిచేస్తుంది.

const expensiveData = {
  load: function() {
    console.log('Loading expensive data...');
    // Simulate a time-consuming operation (e.g., fetching from a database)
    return new Promise(resolve => {
      setTimeout(() => {
        resolve({
          data: 'This is the expensive data'
        });
      }, 2000);
    });
  }
};

const lazyLoadHandler = {
  get: function(target, prop) {
    if (prop === 'data') {
      console.log('Accessing data, loading it if necessary...');
      return target.load().then(result => {
        target.data = result.data; // Store the loaded data
        return result.data;
      });
    } else {
      return target[prop];
    }
  }
};

const lazyData = new Proxy(expensiveData, lazyLoadHandler);

console.log('Initial access...');
lazyData.data.then(data => {
  console.log('Data:', data); // Output: Data: This is the expensive data
});

console.log('Subsequent access...');
lazyData.data.then(data => {
  console.log('Data:', data); // Output: Data: This is the expensive data (loaded from cache)
});

ఉదాహరణ: అనేక వివరాలు మరియు సంబంధిత మీడియాను కలిగి ఉన్న యూజర్ ప్రొఫైల్స్‌తో కూడిన ఒక పెద్ద సోషల్ మీడియా ప్లాట్‌ఫారమ్‌ను ఊహించుకోండి. మొత్తం ప్రొఫైల్ డేటాను వెంటనే లోడ్ చేయడం అసమర్థంగా ఉంటుంది. ప్రాక్సీతో వర్చువలైజేషన్ ప్రాథమిక ప్రొఫైల్ సమాచారాన్ని ముందుగా లోడ్ చేయడానికి, మరియు వినియోగదారు ఆ విభాగాలకు నావిగేట్ చేసినప్పుడు మాత్రమే అదనపు వివరాలు లేదా మీడియా కంటెంట్‌ను లోడ్ చేయడానికి అనుమతిస్తుంది.

3. లాగింగ్ మరియు ట్రాకింగ్

ప్రాపర్టీ యాక్సెస్ మరియు మార్పులను ట్రాక్ చేయడానికి ప్రాక్సీలను ఉపయోగించవచ్చు. ఇది డీబగ్గింగ్, ఆడిటింగ్ మరియు పనితీరు పర్యవేక్షణకు విలువైనది.

const logHandler = {
  get: function(target, prop, receiver) {
    console.log(`GET ${prop}`);
    return Reflect.get(target, prop, receiver);
  },
  set: function(target, prop, value) {
    console.log(`SET ${prop} to ${value}`);
    target[prop] = value;
    return true;
  }
};

let obj = { name: 'Alice' };
let proxy = new Proxy(obj, logHandler);

console.log(proxy.name); // Output: GET name, Alice
proxy.age = 30; // Output: SET age to 30

ఉదాహరణ: ఒక సహకార డాక్యుమెంట్ ఎడిటింగ్ అప్లికేషన్‌లో, డాక్యుమెంట్ కంటెంట్‌కు చేసిన ప్రతి మార్పును ఒక ప్రాక్సీ ట్రాక్ చేయగలదు. ఇది ఆడిట్ ట్రయల్‌ను సృష్టించడానికి, అన్డూ/రీడూ కార్యాచరణను ప్రారంభించడానికి, మరియు వినియోగదారు సహకారాలపై అంతర్దృష్టులను అందించడానికి అనుమతిస్తుంది.

4. రీడ్-ఓన్లీ వ్యూస్

ప్రాక్సీలు ఆబ్జెక్ట్‌ల యొక్క రీడ్-ఓన్లీ వ్యూస్‌ను సృష్టించి, అనుకోకుండా జరిగే మార్పులను నివారించగలవు. ఇది సున్నితమైన డేటాను రక్షించడానికి ఉపయోగపడుతుంది.

const readOnlyHandler = {
  set: function(target, prop, value) {
    console.error(`Cannot set property ${prop}: object is read-only`);
    return false; // Indicate that the set operation failed
  },
  deleteProperty: function(target, prop) {
    console.error(`Cannot delete property ${prop}: object is read-only`);
    return false; // Indicate that the delete operation failed
  }
};

let data = { name: 'Bob', age: 40 };
let readOnlyData = new Proxy(data, readOnlyHandler);

try {
  readOnlyData.age = 41; // Throws an error
} catch (e) {
  console.log(e); // No error thrown because the 'set' trap returns false.
}

try {
    delete readOnlyData.name; // Throws an error
} catch (e) {
    console.log(e); // No error thrown because the 'deleteProperty' trap returns false.
}

console.log(data.age); // Output: 40 (unchanged)

ఉదాహరణ: ఒక ఆర్థిక వ్యవస్థను పరిగణించండి, ఇక్కడ కొంతమంది వినియోగదారులకు ఖాతా సమాచారానికి రీడ్-ఓన్లీ యాక్సెస్ ఉంటుంది. ఈ వినియోగదారులు ఖాతా బ్యాలెన్స్‌లు లేదా ఇతర కీలక డేటాను మార్చకుండా నిరోధించడానికి ఒక ప్రాక్సీని ఉపయోగించవచ్చు.

5. డిఫాల్ట్ విలువలు

లేని ప్రాపర్టీల కోసం ఒక ప్రాక్సీ డిఫాల్ట్ విలువలను అందించగలదు. ఇది కోడ్‌ను సులభతరం చేస్తుంది మరియు null/undefined తనిఖీలను నివారిస్తుంది.

const defaultValuesHandler = {
  get: function(target, prop, receiver) {
    if (!(prop in target)) {
      console.log(`Property ${prop} not found, returning default value.`);
      return 'Default Value'; // Or any other appropriate default
    }
    return Reflect.get(target, prop, receiver);
  }
};

let config = { apiUrl: 'https://api.example.com' };
let configWithDefaults = new Proxy(config, defaultValuesHandler);

console.log(configWithDefaults.apiUrl); // Output: https://api.example.com
console.log(configWithDefaults.timeout); // Output: Property timeout not found, returning default value. Default Value

ఉదాహరణ: ఒక కాన్ఫిగరేషన్ నిర్వహణ వ్యవస్థలో, ఒక ప్రాక్సీ లేని సెట్టింగ్‌ల కోసం డిఫాల్ట్ విలువలను అందించగలదు. ఉదాహరణకు, ఒక కాన్ఫిగరేషన్ ఫైల్ డేటాబేస్ కనెక్షన్ టైమ్‌అవుట్‌ను పేర్కొనకపోతే, ప్రాక్సీ ముందుగా నిర్వచించిన డిఫాల్ట్ విలువను తిరిగి ఇవ్వగలదు.

6. మెటాడేటా మరియు ఉల్లేఖనలు

ప్రాక్సీలు అసలు ఆబ్జెక్ట్‌ను మార్చకుండా అదనపు సమాచారాన్ని అందించడానికి మెటాడేటా లేదా ఉల్లేఖనలను ఆబ్జెక్ట్‌లకు జోడించగలవు.

const metadataHandler = {
  get: function(target, prop, receiver) {
    if (prop === '__metadata__') {
      return { description: 'This is metadata for the object' };
    }
    return Reflect.get(target, prop, receiver);
  }
};

let article = { title: 'Introduction to Proxies', content: '...' };
let articleWithMetadata = new Proxy(article, metadataHandler);

console.log(articleWithMetadata.title); // Output: Introduction to Proxies
console.log(articleWithMetadata.__metadata__.description); // Output: This is metadata for the object

ఉదాహరణ: ఒక కంటెంట్ మేనేజ్‌మెంట్ సిస్టమ్‌లో, ఒక ప్రాక్సీ ఆర్టికల్స్‌కు రచయిత సమాచారం, ప్రచురణ తేదీ మరియు కీవర్డ్‌లు వంటి మెటాడేటాను జోడించగలదు. ఈ మెటాడేటాను కంటెంట్‌ను శోధించడం, ఫిల్టర్ చేయడం మరియు వర్గీకరించడం కోసం ఉపయోగించవచ్చు.

7. ఫంక్షన్ ఇంటర్‌సెప్షన్

ప్రాక్సీలు ఫంక్షన్ కాల్స్‌ను అడ్డగించి, లాగింగ్, ధృవీకరణ లేదా ఇతర ప్రీ- లేదా పోస్ట్-ప్రాసెసింగ్ లాజిక్‌ను జోడించడానికి మిమ్మల్ని అనుమతిస్తాయి.

const functionInterceptor = {
  apply: function(target, thisArg, argumentsList) {
    console.log('Calling function with arguments:', argumentsList);
    const result = target.apply(thisArg, argumentsList);
    console.log('Function returned:', result);
    return result;
  }
};

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

let proxiedAdd = new Proxy(add, functionInterceptor);

let sum = proxiedAdd(5, 3); // Output: Calling function with arguments: [5, 3], Function returned: 8
console.log(sum); // Output: 8

ఉదాహరణ: ఒక బ్యాంకింగ్ అప్లికేషన్‌లో, ఒక ప్రాక్సీ లావాదేవీ ఫంక్షన్లకు కాల్స్‌ను అడ్డగించి, ప్రతి లావాదేవీని లాగ్ చేసి, లావాదేవీని అమలు చేయడానికి ముందు మోసం గుర్తింపు తనిఖీలను చేయగలదు.

8. కన్స్ట్రక్టర్ ఇంటర్‌సెప్షన్

ప్రాక్సీలు కన్స్ట్రక్టర్ కాల్స్‌ను అడ్డగించి, ఆబ్జెక్ట్ సృష్టిని అనుకూలీకరించడానికి మిమ్మల్ని అనుమతిస్తాయి.

const constructorInterceptor = {
  construct: function(target, argumentsList, newTarget) {
    console.log('Creating a new instance of', target.name, 'with arguments:', argumentsList);
    const obj = new target(...argumentsList);
    console.log('New instance created:', obj);
    return obj;
  }
};

class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
}

let ProxiedPerson = new Proxy(Person, constructorInterceptor);

let person = new ProxiedPerson('Alice', 28); // Output: Creating a new instance of Person with arguments: ['Alice', 28], New instance created: Person { name: 'Alice', age: 28 }
console.log(person);

ఉదాహరణ: ఒక గేమ్ డెవలప్‌మెంట్ ఫ్రేమ్‌వర్క్‌లో, ఒక ప్రాక్సీ గేమ్ ఆబ్జెక్ట్‌ల సృష్టిని అడ్డగించి, స్వయంచాలకంగా ప్రత్యేకమైన IDలను కేటాయించి, డిఫాల్ట్ కాంపోనెంట్‌లను జోడించి, వాటిని గేమ్ ఇంజిన్‌తో నమోదు చేయగలదు.

అధునాతన పరిగణనలు

• పనితీరు: ప్రాక్సీలు సౌలభ్యాన్ని అందించినప్పటికీ, అవి పనితీరు ఓవర్‌హెడ్‌ను పరిచయం చేయగలవు. ముఖ్యంగా పనితీరు-క్లిష్టమైన అప్లికేషన్లలో, ప్రాక్సీలను ఉపయోగించడం వల్ల కలిగే ప్రయోజనాలు పనితీరు ఖర్చులను మించిపోయేలా మీ కోడ్‌ను బెంచ్‌మార్క్ మరియు ప్రొఫైల్ చేయడం ముఖ్యం.
• అనుకూలత: ప్రాక్సీలు జావాస్క్రిప్ట్‌కు సాపేక్షంగా ఇటీవలి చేర్పు, కాబట్టి పాత బ్రౌజర్‌లు వాటికి మద్దతు ఇవ్వకపోవచ్చు. పాత వాతావరణాలతో అనుకూలతను నిర్ధారించడానికి ఫీచర్ డిటెక్షన్ లేదా పాలిఫిల్స్ ఉపయోగించండి.
• రద్దు చేయగల ప్రాక్సీలు: Proxy.revocable() మెథడ్ రద్దు చేయగల ప్రాక్సీని సృష్టిస్తుంది. ప్రాక్సీని రద్దు చేయడం వల్ల తదుపరి కార్యకలాపాలు అడ్డగించబడకుండా నిరోధిస్తుంది. ఇది భద్రత లేదా వనరుల నిర్వహణ ప్రయోజనాల కోసం ఉపయోగపడుతుంది.
• రిఫ్లెక్ట్ API: రిఫ్లెక్ట్ API ప్రాక్సీ ట్రాప్స్ యొక్క డిఫాల్ట్ ప్రవర్తనను నిర్వహించడానికి మెథడ్స్‌ను అందిస్తుంది. Reflect ఉపయోగించడం వల్ల మీ ప్రాక్సీ కోడ్ భాషా స్పెసిఫికేషన్‌తో స్థిరంగా ప్రవర్తిస్తుందని నిర్ధారిస్తుంది.

ముగింపు

జావాస్క్రిప్ట్ ప్రాక్సీలు ఆబ్జెక్ట్ ప్రవర్తనను అనుకూలీకరించడానికి ఒక శక్తివంతమైన మరియు బహుముఖ యంత్రాంగాన్ని అందిస్తాయి. వివిధ ప్రాక్సీ ప్యాటర్న్స్‌పై నైపుణ్యం సాధించడం ద్వారా, మీరు మరింత పటిష్టమైన, నిర్వహించదగిన మరియు సమర్థవంతమైన కోడ్‌ను వ్రాయగలరు. మీరు ధృవీకరణ, వర్చువలైజేషన్, ట్రాకింగ్ లేదా ఇతర అధునాతన టెక్నిక్స్ అమలు చేస్తున్నా, ఆబ్జెక్టులను ఎలా యాక్సెస్ చేయాలో మరియు మార్చాలో నియంత్రించడానికి ప్రాక్సీలు ఒక సౌకర్యవంతమైన పరిష్కారాన్ని అందిస్తాయి. ఎల్లప్పుడూ పనితీరు ప్రభావాలను పరిగణించండి మరియు మీ లక్ష్య వాతావరణాలతో అనుకూలతను నిర్ధారించుకోండి. ప్రాక్సీలు ఆధునిక జావాస్క్రిప్ట్ డెవలపర్ యొక్క ఆయుధశాలలో ఒక కీలక సాధనం, శక్తివంతమైన మెటాప్రోగ్రామింగ్ టెక్నిక్స్‌ను ప్రారంభిస్తాయి.

మరింత అన్వేషణ

• మోజిల్లా డెవలపర్ నెట్‌వర్క్ (MDN): జావాస్క్రిప్ట్ ప్రాక్సీ
• జావాస్క్రిప్ట్ ప్రాక్సీలను అన్వేషించడం: స్మాషింగ్ మ్యాగజైన్ ఆర్టికల్