Underscore: Saran: _.debounce dan _.throttle ambil parameter tambahan untuk cara menggabungkan argumen

Mengomentari saran saya sendiri, panggilan ke combine() harus menentukan konteks yang sama dengan fungsi payload, karenanya

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

jika argumen perlu mengakses objek konteks ....

Sekarang harus diperbaiki pada master. throttle harus menunjukkan perilaku yang benar di mana ia selalu menggunakan salinan terbaru dari argumen Anda, langsung aktif sekali, dan setiap N detik setelahnya ... dan me-reset sendiri N detik setelahnya pemicu trailing terakhir telah terjadi.

Saya pikir komentar dekat Anda berlaku untuk masalah lain (mungkin #170), karena masalah yang diangkat oleh permintaan ini masih berlaku pada master.
Masih tidak ada cara mudah untuk mendebounce atau mencekik argumen akumulasi dari panggilan yang sedang digabungkan, dan saya masih berpikir itu adalah tambahan opsional yang berguna yang membuat perilaku default tidak berubah ketika argumen penggabungan opsional tidak ditentukan.

Anda benar. Mengumpulkan argumen berada di luar cakupan Garis Bawah -- jangan ragu untuk menyimpan data yang terkumpul di tempat yang baik di luar fungsi _.throttle dan _.debounce .

Sayang sekali, saya menganggap debounce sebagai semacam flip-kiri (mengurangi) lebih dari beberapa panggilan dengan batas waktu maka akumulator ... tapi itu panggilan Anda :)

OK, bukan untuk terus menggedor, tetapi jika ada yang melihat ini nanti dan bertanya-tanya bagaimana melakukan hal yang sama, saya pikir ini adalah cara terbersih tanpa memodifikasi debounce itu sendiri (saya menambahkannya ke objek _, orang lain mungkin lebih suka tidak ke)

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

Ini memberikan fungsi debouncing yang argumennya dikurangi dengan fungsi kombinasikan, misalnya,

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

akan beberapa detik kemudian memanggil console.log dengan array [3,4,7,8,9]

@schmerg — ini terlihat sangat berguna. Apakah Anda bersedia melisensikan kode itu di bawah lisensi MIT? (Jawaban "ya" sudah cukup!)

@markjaquith Tentu saja - ya. Senang...

Jika ada yang datang dan ingin memperbarui/mengkomentari versi js modern di atas:

_.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 Hei, versi Anda tidak mengatur ulang allArgs di dalam wrapper() , jadi panggilan berikutnya ke func() mendapatkan kumpulan argumen historis serta kumpulan saat ini.

Bukankah seharusnya:

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

@markjaquith +1

Juga func( args ) berbeda dari versi asli yang menggunakan func.apply(context, args); .
Untuk yang pertama, args digunakan seperti pada target func() , sedangkan di _(kode asli)_ selanjutnya Anda perlu menggunakan arguments dalam fungsi normal atau ( ...args ) dalam fungsi panah gemuk es6.