Underscore: Предложение: _.debounce и _.throttle принимают дополнительный параметр для объединения аргументов.

Комментируя мое собственное предложение, вызов comb() должен указывать тот же контекст, что и функция полезной нагрузки, поэтому

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

в случае, если аргументы должны получить доступ к объекту контекста....

Теперь должно быть исправлено на master. throttle должен демонстрировать правильное поведение, когда он всегда использует последнюю копию ваших аргументов, срабатывает один раз немедленно и затем каждые N секунд... и сбрасывает себя через N секунд после произошел последний замыкающий триггер.

Я думаю, что ваш подробный комментарий относится к другой проблеме (вероятно, № 170), поскольку проблема, поднятая этим запросом, по-прежнему актуальна для master.
До сих пор не существует простого способа, чтобы дебаунс или дроссель накапливал аргументы из объединяемых вызовов, и я все еще думаю, что это полезное дополнительное дополнение, которое оставляет поведение по умолчанию неизменным, когда необязательный аргумент объединения не указан.

Ах, ты прав. Накопление аргументов выходит за рамки Underscore — не стесняйтесь хранить накопленные данные в удобном месте вне функций _.throttle и _.debounce .

Жаль, я считаю debounce своего рода fold-left (reduce) по нескольким вызовам с тайм-аутом, следовательно, аккумулятор ... но это ваш выбор :)

Хорошо, не для того, чтобы продолжать стучать, но на случай, если кто-то посмотрит на это позже и задастся вопросом, как сделать то же самое, я решил, что это был самый чистый способ без изменения самого 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);

через несколько секунд вызовет console.log с массивом [3,4,7,8,9]

@schmerg — это выглядит чрезвычайно полезным. Хотели бы вы лицензировать этот код под лицензией MIT? («Да» будет достаточно!)

@markjaquith Конечно, да. С радостью...

Если кто-то приходит и хочет обновить / прокомментировать современную js-версию вышеизложенного:

_.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() получают исторические пакеты аргументов, а также текущий пакет.

Разве не должно быть:

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

@markjaquith +1

Также func( args ) отличается от оригинальной версии, в которой используется func.apply(context, args); .
В первом случае args используется как есть в целевом func() , тогда как в более позднем _(исходном коде)_ вам нужно использовать либо arguments в обычной функции или ( ...args ) в функции жирной стрелки es6.