Underscore: Sugestão: _.debounce e _.throttle pegam um parâmetro extra para como combinar argumentos

Comentando minha própria sugestão, a chamada para combine() deve especificar o mesmo contexto que a função de carga útil, portanto

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

caso os argumentos precisem acessar o objeto de contexto....

Agora deve ser corrigido no mestre. throttle deve exibir o comportamento correto onde ele sempre usa a cópia mais recente de seus argumentos, dispara uma vez imediatamente e a cada N segundos depois ... e se reinicia N segundos depois ocorreu o último gatilho à direita.

Acho que seu comentário próximo se aplica a outro problema (provavelmente #170), pois o problema levantado por essa solicitação ainda se aplica ao mestre.
Ainda não há uma maneira fácil de ter argumentos de debounce ou de acumulação de aceleração das chamadas que estão sendo combinadas, e ainda acho que é uma adição opcional útil que deixa o comportamento padrão inalterado quando o argumento de combinação opcional não é especificado.

Ah, você está certo. Acumular argumentos está fora do escopo do Underscore - sinta-se à vontade para armazenar seus dados acumulados em um bom local externo às funções _.throttle e _.debounce .

É uma pena, considero o debounce como uma espécie de fold-left (reduce) em várias chamadas com tempo limite, portanto, o acumulador ...

OK, para não continuar batendo, mas caso alguém esteja olhando para isso algum tempo depois e se perguntando como fazer o mesmo, achei que essa era a maneira mais limpa sem modificar o próprio debounce (eu o adiciono ao objeto _ , outros podem preferir não para)

_.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();
        };
    }
})

Isso dá uma função debounced que tem seus argumentos reduzidos pela função combine então, por exemplo,

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

alguns segundos depois chamará console.log com o array [3,4,7,8,9]

@schmerg — isso parece tremendamente útil. Você estaria disposto a licenciar esse código sob a licença do MIT? (Um "sim" será suficiente!)

@markjaquith Claro - sim. Seria um prazer...

Se alguém vier e quiser uma versão js moderna atualizada / comentada do acima:

_.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 Ei, sua versão não redefine allArgs dentro wrapper() , portanto, as chamadas subsequentes para func() obtêm lotes históricos de argumentos, bem como o lote atual.

Não deveria ser:

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

@markjaquith +1

Também func( args ) difere da versão original que usa func.apply(context, args); .
Para o primeiro, args é usado como está no destino func() , enquanto no posterior _(código original)_ você precisa usar arguments em uma função normal ou ( ...args ) em uma função de seta gorda es6.