Underscore: Sugerencia: _.debounce y _.throttle toman un parámetro adicional sobre cómo combinar argumentos

Al comentar sobre mi propia sugerencia, la llamada a combine() debe especificar el mismo contexto que la función de carga útil, por lo tanto

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

en caso de que los argumentos necesiten acceder al objeto de contexto....

Ahora debería estar fijo en el maestro. throttle debería exhibir el comportamiento correcto en el que siempre usa la última copia de sus argumentos, se dispara una vez inmediatamente y cada N segundos a partir de entonces... y se restablece N segundos después se ha producido el último desencadenante final.

Creo que su comentario cercano se aplica a otro problema (probablemente el n. ° 170), ya que el problema planteado por esta solicitud aún se aplica al maestro.
Todavía no hay una manera fácil de hacer que el rebote o la aceleración acumulen argumentos de las llamadas que se combinan, y sigo pensando que es una adición opcional útil que deja el comportamiento predeterminado sin cambios cuando no se especifica el argumento de combinación opcional.

Tienes razón. La acumulación de argumentos está fuera del alcance de Underscore; siéntase libre de guardar sus datos acumulados en un buen lugar fuera de las funciones _.throttle y _.debounce .

Es una pena, considero que el rebote es una especie de pliegue a la izquierda (reducción) en varias llamadas con tiempo de espera, por lo tanto, el acumulador ... pero es su decisión :)

Está bien, no quiero seguir insistiendo, pero en caso de que alguien vea esto más tarde y se pregunte cómo hacer lo mismo, pensé que esta era la forma más limpia sin modificar el rebote en sí mismo (lo agrego al objeto _, otros pueden preferir no 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();
        };
    }
})

Esto da una función antirrebote que tiene sus argumentos reducidos por la función de combinación, por lo que, por ejemplo,

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

unos segundos más tarde llamará a console.log con la matriz [3,4,7,8,9]

@schmerg : esto parece tremendamente útil. ¿Estaría dispuesto a licenciar ese código bajo la licencia MIT? (¡Un "sí" será suficiente!)

@markjaquith Claro, sí. Contento de...

Si alguien viene y quiere una versión js moderna actualizada/comentada de lo anterior:

_.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 Oye, tu versión no restablece allArgs dentro wrapper() , por lo que las llamadas posteriores a func() obtienen lotes históricos de argumentos, así como el lote actual.

¿No debería ser:

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

@markjaquith +1

También func( args ) difiere de la versión original que usa func.apply(context, args); .
Para el primero, args se usa como está en el objetivo func() , mientras que en el último _(código original)_ necesita usar arguments en una función normal o ( ...args ) en una función de flecha gruesa es6.