Jika sebuah objek mempunyai beberapa metode dan kita berencana untuk mengirimkannya kebagian kode lain secara terus-menerus, kita bisa mengikatkannya didalam sebuah perulangan:

for (let key in user) {
  if (typeof user[key] == 'function') {
    user[key] = user[key].bind(user);
  }
}

Librari Javascript juga menyediakan fungsi untuk memudahkan pengikatan/binding masal, contoh _.bindAll(object, methodNames) didalam lodash.

Partial functions/Fungsi sebagian

Sampai sekarang kita hanya berbicara tentang binding/pengikatan this. Ayo kita lihat lebih dalam.

Kita bisa mengikat bukan hanya this, tapi juga argumen. Yang mana sangat jarang digunakan, tapi terkadang cukup mudah digunakan.

Sintaks penuh dari bind:

let bound = func.bind(context, [arg1], [arg2], ...);

Yang mana mengijinkan kita untuk mengikat konteks sebagai this dan memulai argumen dari sebuah fungsi.

Contoh, kita mempunyai sebuah fungsi perkalian mul(a, b):

function mul(a, b) {
  return a * b;
}

Kita gunakan bind untuk membuat sebuah fungsi double didalamnya:

function mul(a, b) {
  return a * b;
}

let double = mul.bind(null, 2);

alert( double(3) ); // = mul(2, 3) = 6
alert( double(4) ); // = mul(2, 4) = 8
alert( double(5) ); // = mul(2, 5) = 10

Panggilan pada mul.bind(null, 2) membuat function double baru yang memberikan panggilan terhadap mul, memperbaiki null sebagai konteksnya dan 2 sebagai argumen pertamanya. Argumen-argumen lebih lanjut yang diberikan ???as is/sebagaimana adanya???.

Itu dipanggil partial function application ??? kita membuat sebuah fungsi baru dengan memperbaiki beberapa parameter dari yang sudah ada.

Harap dicatat bahwa disini kita tidak menggunakan this. Tapi bind memerlukannya, jadi kita harus meletakkan di dalam sesuatu seperti null.

Fungsi triple di dalam kode dibawah ini melipatkan tiga kali lipat nilai tersebut:

function mul(a, b) {
  return a * b;
}

let triple = mul.bind(null, 3);

alert( triple(3) ); // = mul(3, 3) = 9
alert( triple(4) ); // = mul(3, 4) = 12
alert( triple(5) ); // = mul(3, 5) = 15

Kenapa kita umumnya membuat fungsi parsial?

Manfaatnya bahwa kita dapat membuat sebuah fungsi independen dengan nama yang dapat dibaca (double, triple). Kita bisa menggunakannya dan tidak menyediakan argumen pertamanya setiap saat karena sudah diperbaiki dengan bind.

Dalam kasus lain, aplikasi parsial berguna saat kita punya sebuah fungsi generik dan menginginkan varian yang kurang universal untuk kenyamanan.

Contoh, kita punya sebuah fungsi send(from, to, text). Kemudian, di dalam objek user kita mungkin ingin menggunakan varian parsial darinya: sendTo(to, text) yang dikirim dari user saat ini.

Menjadi parsial tanpa konteks

Bagaimana jika kita ingin memperbaiki beberapa argumen, tetapi bukan konteks this? Contoh, untuk sebuah method objek.

bind yang asli tidak mengizinkan itu. Kita tidak bisa begitu saja mengabaikan konteks dan lompat ke argumen.

Untungnya, fungsi partial untuk mengikat argumen saja dapat dengan mudah diterapkan.

Seperti ini:

function partial(func, ...argsBound) {
  return function(...args) { // (*)
    return func.call(this, ...argsBound, ...args);
  }
}

// Usage:
let user = {
  firstName: "John",
  say(time, phrase) {
    alert(`[${time}] ${this.firstName}: ${phrase}!`);
  }
};

// tambahkan method parsial dengan waktu tetap
user.sayNow = partial(user.say, new Date().getHours() + ':' + new Date().getMinutes());

user.sayNow("Hello");
// Something like:
// [10:00] John: Hello!

Hasil dari panggilan partial(func[, arg1, arg2...]) yaitu sebuah pembungkus (*) yang memanggil func dengan:

• this sama seperti yang didapat (user.sayNow menyebutnya user)
• Lalu berikan ...argsBound ??? argumen dari panggilan partial yaitu ("10:00")
• Lalu berikan ...args ??? argumen yang diberikan ke pembungkus (" Hello ")

Sangat mudah melakukannya dengan sintaks penyebaran, bukan?

Juga ada implementasi _.partial yang siap dari perpustakaan lodash.

Kesimpulan

Method func.bind(context, ...args) mengembalikan sebuah ???varian terikat??? dari function func yang memperbaiki konteksthis dan argumen pertama jika diberikan.

Biasanya kita menerapkan bind untuk memperbaiki this untuk sebuah method objek, sehingga kita bisa memberikannya ke suatu tempat. Misalnya, ke setTimeout.

Ketika kita memperbaiki beberapa argumen dari function yang ada, fungsi yang dihasilkan (less universal) disebut partially applied atau partial.

Parsial lebih mudah digunakan ketika kita tidak ingin mengulangi argumen yang sama berulang kali. Seperti jika kita memiliki fungsi send (from, to), dan from harus selalu sama untuk tugas kita, kita bisa mendapatkan sebuah partial dan melanjutkannya.