मान लें कि मेरे पास एक props ऑब्जेक्ट है, जिसमें कई कुंजियां हैं keyA, keyB...

और मेरे पास 3 कार्य हैं funcA, funcB और funcC, प्रत्येक में एक तर्क है जो props है। हालांकि, प्रत्येक फ़ंक्शन उनके props तर्क के शून्य, एक या अधिक कुंजी/मानों का उपयोग करेगा, और मैं जानना चाहता हूं कि प्रत्येक फ़ंक्शन द्वारा किन कुंजियों का उपयोग किया गया है।

उदाहरण के लिए:

const funcA = props => {/* do something with props.keyA and props.keyB */}

const funcB = props => {/* do something with props.keyC */}

const funcC = props => {/* do nothing with props */}

और मैं एक तंत्र (यानी एक रैपर फ़ंक्शन, या एक रैपर वर्ग ...) रखना चाहता हूं, जिसे, जब func{A,B,C} कहा जाता है, कंसोल होगा। उन कुंजियों को लॉग करें जिनके साथ फ़ंक्शन को कॉल किया गया है:

// I wish to have the following lines console.logged:
funcA is using keyA and keyB
funcB is using keyC
funcC is not using anything

मेरा पहला कदम निम्नलिखित तरीके से props ऑब्जेक्ट पर Proxy बनाना है:

const propsProxy = new Proxy(props, {
  get (target, key) {
    console.log(`${key} has been used.`);
    return target[key];
  }
}

// ...

funcA(propsProxy); // Logs "keyA has been used. keyB has been used."
funcB(propsProxy); // Logs "keyC has been used."
funcC(propsProxy);

लेकिन फिर मैं फ़ंक्शन नाम को भी लॉग इन करने के तरीके पर फंस गया हूं।

संपादित करें: कुछ टिप्पणियों को पढ़ने के बाद, ऐसा लगता है कि मुझे कुछ स्पष्टीकरण जोड़ने की जरूरत है। आइए इसे और अधिक व्यावहारिक बनाएं।

मैं वास्तव में इस परिवाद को लिख रहा हूं, आइए इसे wrapper कहते हैं, जो अंतिम डेवलपर्स इसका उपयोग करेंगे जैसे:

import wrapper from 'wrapper';

// User defines funcA=..., funcB=..., funcC=... and props

wrapper(funcA, funcB, funcC, props); // Will call funcA(props), funcB(props) and funcC(props)
// Should log:
// funcA is using keyA and keyB
// funcB is using keyC
// funcC is not using anything

प्रश्न: कृपया wrapper के लिए कोड लिखें?

1
jeanpaul62 12 मई 2018, 22:09

1 उत्तर

सबसे बढ़िया उत्तर

आप wrapper को इस प्रकार परिभाषित कर सकते हैं:

function wrapper(props, ...funcs) {
  funcs.forEach(function(func) {                                       // for each function func passed as argument
    var used = [];                                                     // this will be the array of used property names (duplicates included)

    var propsProxy = new Proxy(props, {                                // set up a new proxy of props
      get(target, key) {
        used.push(key);                                                // ... which add the key used to used array
        return target[key];
      }
    });

    func(propsProxy);                                                  // call func with the proxy object

    console.log(func.name + " used " + (used.length? used.join(" and "): "nothing")); // log the results
  });
}

उदाहरण:

function funcA(props) {
  var result = props.propA + props.propC;
}

function funcB(props) {
  if(props.propA) {
    return true;
  }
}

function funcC(props) {
}

function wrapper(props, ...funcs) {
  funcs.forEach(function(func) {
    var used = [];

    var propsProxy = new Proxy(props, {
      get(target, key) {
        used.push(key);
        return target[key];
      }
    });

    func(propsProxy);
    
    console.log(func.name + " used " + (used.length? used.join(" and "): "nothing"));
  });
}

wrapper({
  propA: 5,
  propB: 6,
  propC: 7
}, funcA, funcB, funcC);
1
ibrahim mahrir 12 मई 2018, 23:11