Underscore: सुझाव: _.debounce और _.throttle तर्कों को कैसे संयोजित करें, इसके लिए अतिरिक्त पैरामीटर लेते हैं

मेरे अपने सुझाव पर टिप्पणी करते हुए, कॉल टू कॉम्बिनेशन () को पेलोड फ़ंक्शन के समान संदर्भ निर्दिष्ट करना चाहिए, इसलिए

allargs = combine.apply(this, [allargs, slice.call(arguments,0)])

यदि तर्कों को संदर्भ वस्तु तक पहुँचने की आवश्यकता है ....

अब मास्टर पर फिक्स होना चाहिए। throttle को सही व्यवहार प्रदर्शित करना चाहिए जहां यह हमेशा आपके तर्कों की नवीनतम प्रति का उपयोग करता है, तुरंत एक बार सक्रिय होता है, और उसके बाद प्रत्येक N सेकंड ... और N सेकंड के बाद खुद को रीसेट करता है अंतिम अनुगामी ट्रिगर हुआ है।

मुझे लगता है कि आपकी करीबी टिप्पणी किसी अन्य मुद्दे (शायद # 170) पर लागू होती है, क्योंकि इस अनुरोध द्वारा उठाया गया मुद्दा अभी भी मास्टर पर लागू होता है।
संयुक्त होने वाली कॉलों से बहस या थ्रॉटल जमा करने के लिए अभी भी कोई आसान तरीका नहीं है, और मुझे अभी भी लगता है कि यह एक उपयोगी वैकल्पिक जोड़ है जो वैकल्पिक संयोजन तर्क निर्दिष्ट नहीं होने पर डिफ़ॉल्ट व्यवहार को अपरिवर्तित छोड़ देता है।

आह, तुम सही हो। तर्कों को जमा करना अंडरस्कोर के दायरे से बाहर है -- बेझिझक अपने संचित डेटा को _.throttle और _.debounce फ़ंक्शंस के बाहर किसी अच्छी जगह पर रखें।

यह अफ़सोस की बात है, मैं बहस को एक तरह से गुना-बाएं (कम) करने के लिए टाइमआउट के साथ कई कॉलों पर विचार करता हूं इसलिए संचायक ... लेकिन यह आपकी कॉल है :)

ठीक है, धमाका करते रहने के लिए नहीं, लेकिन अगर कोई इसे कुछ समय बाद देख रहा है और सोच रहा है कि इसे कैसे किया जाए, तो मुझे लगा कि यह बहस को संशोधित किए बिना सबसे साफ तरीका है (मैं इसे _ ऑब्जेक्ट में जोड़ता हूं, अन्य इसे पसंद नहीं कर सकते हैं) प्रति)

_.mixin({
  debounceReduce: function(func, wait, combine) {
    var allargs,
        context,
        wrapper = _.debounce(function() {
            var args = allargs;
            allargs = undefined;
            func.apply(context, args);
        }, wait);
        return function() {
            context = this;
            allargs = combine.apply(context, [allargs,  Array.prototype.slice.call(arguments,0)]);
            wrapper();
        };
    }
})

यह एक विवादित फ़ंक्शन देता है जिसके तर्कों को कम्बाइन फ़ंक्शन द्वारा कम किया जाता है, उदाहरण के लिए,

  delayLog = _.debounceReduce(function() { console.log(arguments); }, 5000, 
                              function(acc,args) { return (acc || []).concat(args); });
  delayLog(3,4);
  delayLog(7,8,9);

कुछ सेकंड बाद में कंसोल को कॉल करेगा। सरणी के साथ लॉग इन करें [3,4,7,8,9]

@schmerg - यह काफी उपयोगी लग रहा है। क्या आप उस कोड को एमआईटी लाइसेंस के तहत लाइसेंस देने के इच्छुक होंगे? (एक "हाँ" पर्याप्त होगा!)

@markjaquith ज़रूर बात - हाँ। बहुत खुशी हुई...

अगर कोई साथ आता है और उपरोक्त के आधुनिक जेएस संस्करण को अद्यतन/टिप्पणी करना चाहता है:

_.mixin({
  debounceReduce(func, wait, combine) {
    let allArgs; // accumulator for args across calls

    // normally-debounced fn that we will call later with the accumulated args
    const wrapper = _.debounce(() => func(allArgs), wait);

    // what we actually return is this function which will really just add the new args to
    // allArgs using the combine fn
    return (...args) => {
      allArgs = combine(allArgs,  [...args]);
      wrapper();
    };
  },
});

@kmannislands अरे, आपका संस्करण allArgs को wrapper() $ के अंदर रीसेट नहीं करता है, इसलिए बाद में func() पर कॉल करने से args के ऐतिहासिक बैचों के साथ-साथ वर्तमान बैच भी प्राप्त होता है।

क्या यह नहीं होना चाहिए:

const wrapper = _.debounce(() => {
    const args = allArgs;
    allArgs = undefined;
    func(args);
}, wait);

@markjaquith +1

साथ ही func( args ) मूल संस्करण से अलग है जो func.apply(context, args); का उपयोग करता है।
पूर्व के लिए, args का उपयोग लक्ष्य func() के रूप में किया जाता है, जबकि बाद के _(मूल कोड)_ में आपको सामान्य फ़ंक्शन में arguments का उपयोग करने की आवश्यकता होती है या ( ...args ) एक es6 वसा तीर समारोह में।