Berfungsi tanpa nama
Sederhananya, lambda adalah fungsi tanpa nama, atau fungsi anonim. Sepotong kecil kode yang dapat dieksekusi, yang dapat diedarkan seolah-olah itu adalah variabel. Dalam JavaScript:
function () {}; // very simple
Mari kita lihat sekarang beberapa kegunaan lambda ini.
Mengabstraksi kode boilerplate
Lambdas dapat digunakan untuk mengabstraksi kode boilerplate. Misalnya loop. Kami terbiasa menulis for
dan while
mengulang sepanjang hari. Tetapi ini adalah kode yang tidak tertulis. Kita bisa mengekstrak kode di dalam loop, bagian terpenting dari loop, dan memisahkan sisanya:
for (var i=0; i<array.length; i++) {
// do what something useful with array[i]
}
dengan menggunakan forEach
objek array, menjadi:
array.forEach(function (element, index) {
// do something useful with element
// element is the equivalent of array[i] from above
});
Abstraksi di atas mungkin tidak begitu berguna, tetapi ada fungsi tingkat tinggi lainnya, seperti forEach
, yang menjalankan tugas yang jauh lebih berguna. Contoh filter
:
var numbers = [1, 2, 3, 4];
var even = [];
// keep all even numbers from above array
for (var i=0; i<numbers.length; i++) {
if (numbers[i] % 2 === 0) {
even.push(numbers[i]);
}
}
alert(even);
// Using the filter method
even = [1, 2, 3, 4].filter(function (number) {
return number % 2 === 0;
});
alert(even);
Penundaan eksekusi kode
Di beberapa lingkungan, di mana konsep acara tersedia, kita dapat menggunakan lambda untuk menanggapi peristiwa yang mungkin terjadi di beberapa titik waktu.
window.onload = function () {
alert("Loaded");
};
window.setTimeout(function () {
alert("Code executed after 2 seconds.");
}, 2000);
Ini bisa saja dilakukan dengan beberapa cara lain, tetapi itu agak bertele-tele. Misalnya, di Java ada Runnable
antarmuka.
Pabrik fungsi
Sampai saat ini, kami hanya menggunakan lambda untuk sebagian besar kemampuan gula sintaksisnya. Tetapi ada situasi di mana lambda bisa jauh lebih berguna. Misalnya kita mungkin memiliki fungsi yang mengembalikan lambda. Katakanlah kita memiliki fungsi yang nilai kembaliannya ingin di-cache.
var users = [];
var getUser = function (name) {
if (! users[name]) {
// expensive operations to get a user. Ajax for example
users[name] = user_from_ajax;
}
return users[name];
};
Nanti, kita mungkin memperhatikan bahwa kita memiliki fungsi yang serupa:
var photos = [];
var getPhoto = function (name) {
if (! photo[name]) {
// expensive operations to get a user. Ajax for example
photos[name] = photo_from_ajax;
}
return photos[name];
};
Jelas ada pola di sana, jadi mari kita abstraksi. Mari gunakan memoization .
/**
* @param {Array} store Data structure in which we cache lambda's return values
* @param {Function} lambda
* @return {Function} A function that caches the result of calling the lambda param
*/
var memoize = function (store, lambda) {
// return a new lambda
return function (name) {
if (! store[name]) {
// Execute the lambda and cache the result
store[name] = lambda(name);
}
return store[name];
};
};
var getUsers = memoize([], function (name) {
// expensive operations to get a user. Ajax for example
});
var getPhotos = memoize([], function (name) {
// expensive operations to get a photo. Ajax for example
});
Seperti yang Anda lihat, dengan menggunakan lambda, kami dapat memisahkan logika caching / memoization. Jika untuk contoh lain ada beberapa solusi, saya yakin masalah khusus ini hampir tidak dapat diselesaikan dengan menggunakan teknik lain. Kami berhasil mengekstrak beberapa kode boilerplate penting ke satu tempat. Belum lagi kami menyingkirkan users
dan photos
variabel global.
Melihat profil Anda, saya melihat bahwa Anda sebagian besar adalah pengguna Python. Untuk pola di atas, Python memiliki konsep dekorator. Ada banyak contoh di internet untuk dekorator memoisasi . Satu-satunya perbedaan adalah bahwa di Python Anda kemungkinan besar memiliki fungsi bersarang bernama di dalam fungsi dekorator itu. Alasannya karena Python hanya mendukung lambda ekspresi tunggal. Tapi konsepnya sama.
Sebagai contoh penggunaan lambda Python. Kode di atas tempat kami memfilter angka genap dapat direpresentasikan dengan Python seperti ini:
filter(lambda x: x % 2 == 0, [1, 2, 3, 4])
Bagaimanapun, lambda tidak begitu kuat tanpa penutupan. Penutupan inilah yang membuat konsep lambda begitu kuat. Dalam contoh memoization saya, saya telah menggunakan closures untuk membuat closure di sekitar store
param. Dengan cara ini, saya memiliki akses ke param itu bahkan setelah memoize
fungsi mengembalikan hasilnya (lambda).