Bagaimana cara menjelaskan panggilan balik dalam bahasa Inggris biasa? Apa bedanya dengan memanggil satu fungsi dari fungsi lainnya?

Bagaimana cara menjelaskan panggilan balik dalam Bahasa Inggris? Bagaimana mereka berbeda dari memanggil satu fungsi dari fungsi lain mengambil beberapa konteks dari fungsi panggilan? Bagaimana kekuatan mereka dapat dijelaskan kepada programmer pemula?

Seringkali aplikasi perlu menjalankan fungsi yang berbeda berdasarkan konteks / kondisinya. Untuk ini, kami menggunakan variabel tempat kami akan menyimpan informasi tentang fungsi yang akan dipanggil. Sesuai dengan kebutuhannya aplikasi akan mengatur variabel ini dengan informasi tentang fungsi yang akan dipanggil dan akan memanggil fungsi menggunakan variabel yang sama.

Dalam javascript, contohnya di bawah ini. Di sini kita menggunakan argumen metode sebagai variabel tempat kita menyimpan informasi tentang fungsi.

function processArray(arr, callback) {
    var resultArr = new Array(); 
    for (var i = arr.length-1; i >= 0; i--)
        resultArr[i] = callback(arr[i]);
    return resultArr;
}

var arr = [1, 2, 3, 4];
var arrReturned = processArray(arr, function(arg) {return arg * -1;});
// arrReturned would be [-1, -2, -3, -4]

Saya akan mencoba untuk membuat ini tetap sederhana. "Callback" adalah fungsi apa pun yang dipanggil oleh fungsi lain yang menggunakan fungsi pertama sebagai parameter. Sering kali, "panggilan balik" adalah fungsi yang dipanggil ketika sesuatu terjadi. Itu sesuatu yang dapat disebut "event" di programmer-berbicara.

Bayangkan skenario ini: Anda mengharapkan paket dalam beberapa hari. Paket ini adalah hadiah untuk tetangga Anda. Karena itu, begitu Anda mendapatkan paket, Anda ingin membawanya ke tetangga. Anda berada di luar kota, dan karenanya Anda meninggalkan instruksi untuk pasangan Anda.

Anda bisa memberi tahu mereka untuk mendapatkan paket dan membawanya ke tetangga. Jika pasangan Anda sebodoh komputer, mereka akan duduk di pintu dan menunggu paket sampai tiba (TIDAK MELAKUKAN APA SAJA LAIN) dan kemudian setelah datang mereka akan membawanya ke tetangga. Tapi ada cara yang lebih baik. Beri tahu pasangan Anda bahwa SEKALI mereka menerima paket itu, mereka harus membawanya ke tetangga. Kemudian, mereka bisa menjalani kehidupan secara normal SAMPAI mereka menerima paket.

Dalam contoh kami, penerimaan paket adalah "acara" dan membawanya ke tetangga adalah "panggilan balik". Pasangan Anda "menjalankan" instruksi Anda untuk membawa paket hanya ketika paket tiba. Jauh lebih baik!

Pemikiran seperti ini jelas dalam kehidupan sehari-hari, tetapi komputer tidak memiliki akal sehat yang sama. Pertimbangkan bagaimana programmer biasanya menulis ke file:

fileObject = open(file)
# now that we have WAITED for the file to open, we can write to it
fileObject.write("We are writing to the file.")
# now we can continue doing the other, totally unrelated things our program does

Di sini, kami MENUNGGU file dibuka, sebelum kami menulisnya. Ini "menghalangi" aliran eksekusi, dan program kami tidak dapat melakukan hal-hal lain yang mungkin perlu dilakukan! Bagaimana jika kita bisa melakukan ini sebagai gantinya:

# we pass writeToFile (A CALLBACK FUNCTION!) to the open function
fileObject = open(file, writeToFile)
# execution continues flowing -- we don't wait for the file to be opened
# ONCE the file is opened we write to it, but while we wait WE CAN DO OTHER THINGS!

Ternyata kami melakukan ini dengan beberapa bahasa dan kerangka kerja. Itu sangat keren! Lihatlah Node.js untuk mendapatkan latihan nyata dengan pemikiran seperti ini.

Bagaimana cara menjelaskan panggilan balik dalam Bahasa Inggris?

Dalam bahasa Inggris yang sederhana, fungsi panggilan balik adalah seperti Pekerja yang "memanggil kembali" ke Manajernya ketika ia telah menyelesaikan Tugas .

Bagaimana mereka berbeda dari memanggil satu fungsi dari fungsi lain mengambil beberapa konteks dari fungsi panggilan?

Memang benar bahwa Anda memanggil fungsi dari fungsi lain, tetapi kuncinya adalah bahwa panggilan balik diperlakukan seperti Obyek, sehingga Anda dapat mengubah Fungsi yang akan dipanggil berdasarkan kondisi sistem (seperti Pola Desain Strategi).

Bagaimana kekuatan mereka dapat dijelaskan kepada programmer pemula?

Kekuatan panggilan balik dapat dengan mudah dilihat di situs web gaya AJAX yang perlu menarik data dari server. Mengunduh data baru mungkin perlu waktu. Tanpa panggilan balik, seluruh Antarmuka Pengguna Anda akan "macet" saat mengunduh data baru, atau Anda perlu menyegarkan seluruh halaman daripada hanya bagian dari itu. Dengan panggilan balik, Anda dapat menyisipkan gambar "memuat sekarang" dan menggantinya dengan data baru setelah dimuat.

Beberapa kode tanpa panggilan balik:

function grabAndFreeze() {
    showNowLoading(true);
    var jsondata = getData('http://yourserver.com/data/messages.json');
    /* User Interface 'freezes' while getting data */
    processData(jsondata);
    showNowLoading(false);
    do_other_stuff(); // not called until data fully downloaded
}

function processData(jsondata) { // do something with the data
   var count = jsondata.results ? jsondata.results.length : 0;
   $('#counter_messages').text(['Fetched', count, 'new items'].join(' '));
   $('#results_messages').html(jsondata.results || '(no new messages)');
}

Dengan Callback:

Berikut adalah contoh dengan panggilan balik, menggunakan getJSON 's jQuery :

function processDataCB(jsondata) { // callback: update UI with results
   showNowLoading(false);
   var count = jsondata.results ? jsondata.results.length : 0;
   $('#counter_messages').text(['Fetched', count, 'new items'].join(' '));
   $('#results_messages').html(jsondata.results || '(no new messages)');
}

function grabAndGo() { // and don't freeze
    showNowLoading(true);
    $('#results_messages').html(now_loading_image);
    $.getJSON("http://yourserver.com/data/messages.json", processDataCB);
    /* Call processDataCB when data is downloaded, no frozen User Interface! */
    do_other_stuff(); // called immediately
}

Dengan Penutupan:

Seringkali panggilan balik perlu diakses statedari fungsi panggilan menggunakan a closure, yang seperti Pekerja perlu mendapatkan informasi dari Manajer sebelum dia dapat menyelesaikan Tugasnya . Untuk membuat closure, Anda bisa sebaris fungsi sehingga melihat data dalam konteks panggilan:

/* Grab messages, chat users, etc by changing dtable. Run callback cb when done.*/
function grab(dtable, cb) { 
    if (null == dtable) { dtable = "messages"; }
    var uiElem = "_" + dtable;
    showNowLoading(true, dtable);
    $('#results' + uiElem).html(now_loading_image);
    $.getJSON("http://yourserver.com/user/"+dtable+".json", cb || function (jsondata) {
       // Using a closure: can "see" dtable argument and uiElem variables above.
       var count = jsondata.results ? jsondata.results.length : 0, 
           counterMsg = ['Fetched', count, 'new', dtable].join(' '),
           // no new chatters/messages/etc
           defaultResultsMsg = ['(no new ', dtable, ')'].join(''); 
       showNowLoading(false, dtable);
       $('#counter' + uiElem).text(counterMsg);
       $('#results'+ uiElem).html(jsondata.results || defaultResultsMsg);
    });
    /* User Interface calls cb when data is downloaded */

    do_other_stuff(); // called immediately
}

Pemakaian:

// update results_chatters when chatters.json data is downloaded:
grab("chatters"); 
// update results_messages when messages.json data is downloaded
grab("messages"); 
// call myCallback(jsondata) when "history.json" data is loaded:
grab("history", myCallback); 

Penutupan

Akhirnya, berikut adalah definisi closuredari Douglas Crockford :

Fungsi dapat didefinisikan di dalam fungsi lain. Fungsi dalam memiliki akses ke vars dan parameter fungsi luar. Jika referensi ke fungsi dalam bertahan (misalnya, sebagai fungsi callback), vars fungsi luar juga bertahan.

Lihat juga:

• http://javascript.crockford.com/survey.html
• http://api.jquery.com/jQuery.when/
• http://api.jquery.com/jQuery.getJSON/
• http://github.com/josher19/jQuery-Parse

Saya terpana melihat begitu banyak orang pintar gagal menekankan kenyataan bahwa kata "panggilan balik" telah digunakan dalam dua cara yang tidak konsisten.

Kedua cara melibatkan kustomisasi fungsi dengan melewatkan fungsi tambahan (definisi fungsi, anonim atau bernama) ke fungsi yang ada. yaitu.

customizableFunc(customFunctionality)

Jika fungsionalitas khusus dicolokkan ke blok kode, Anda telah menyesuaikan fungsinya, seperti itu.

    customizableFucn(customFunctionality) {
      var data = doSomthing();
      customFunctionality(data);
      ...
    }

Meskipun jenis fungsi yang disuntikkan ini sering disebut "panggilan balik", tidak ada yang bergantung pada itu. Contoh yang sangat jelas adalah metode forEach di mana fungsi kustom disediakan sebagai argumen untuk diterapkan ke setiap elemen dalam array untuk memodifikasi array.

Tapi ini pada dasarnya berbeda dari penggunaan fungsi "callback" untuk pemrograman asinkron , seperti dalam AJAX atau node.js atau hanya dalam menetapkan fungsionalitas untuk peristiwa interaksi pengguna (seperti klik mouse). Dalam kasus ini, seluruh gagasannya adalah untuk menunggu peristiwa kontinjensi terjadi sebelum menjalankan fungsi kustom. Ini jelas dalam kasus interaksi pengguna, tetapi juga penting dalam proses i / o (input / output) yang dapat memakan waktu, seperti membaca file dari disk. Di sinilah istilah "panggilan balik" masuk akal paling jelas. Setelah proses i / o dimulai (seperti meminta file untuk dibaca dari disk atau server untuk mengembalikan data dari permintaan http), sebuah asinkronProgram tidak menunggu sampai selesai. Itu dapat melanjutkan dengan tugas apa pun yang dijadwalkan berikutnya, dan hanya merespons dengan fungsi khusus setelah diberitahu bahwa file baca atau permintaan http selesai (atau gagal) dan bahwa data tersedia untuk fungsi kustom. Ini seperti menelepon bisnis di telepon dan meninggalkan nomor "panggilan balik" Anda, sehingga mereka dapat menghubungi Anda ketika seseorang tersedia untuk kembali kepada Anda. Itu lebih baik daripada menggantung di telepon untuk siapa yang tahu berapa lama dan tidak bisa menghadiri urusan lain.

Penggunaan asinkron secara inheren melibatkan beberapa cara mendengarkan acara yang diinginkan (misalnya, penyelesaian proses i / o) sehingga, ketika itu terjadi (dan hanya ketika itu terjadi) fungsionalitas "panggilan balik" kustom dijalankan. Dalam contoh AJAX yang jelas, ketika data benar-benar datang dari server, fungsi "callback" dipicu untuk menggunakan data itu untuk memodifikasi DOM dan karenanya menggambar ulang jendela browser sejauh itu.

Untuk rekap. Beberapa orang menggunakan kata "callback" untuk merujuk pada segala jenis fungsi khusus yang dapat disuntikkan ke fungsi yang ada sebagai argumen. Tetapi, setidaknya bagi saya, penggunaan kata yang paling tepat adalah di mana fungsi "panggilan balik" yang disuntikkan digunakan secara tidak serempak - hanya akan dijalankan pada saat suatu peristiwa yang menunggu untuk diberitahukan.

Dalam istilah non-programer, panggilan balik adalah isian yang kosong dalam suatu program.

Item umum pada banyak formulir kertas adalah "Orang yang dihubungi jika terjadi keadaan darurat". Ada garis kosong di sana. Anda menulis nama dan nomor telepon seseorang. Jika keadaan darurat terjadi, maka orang itu dipanggil.

• Semua orang mendapatkan formulir kosong yang sama, tetapi
• Setiap orang dapat menulis nomor kontak darurat yang berbeda.

Ini kuncinya. Anda tidak mengubah formulir (kodenya, biasanya milik orang lain). Namun Anda dapat mengisi informasi yang hilang ( nomor Anda ).

Contoh 1:

Callback digunakan sebagai metode khusus, mungkin untuk menambah / mengubah perilaku program. Misalnya, ambil beberapa kode C yang menjalankan fungsi, tetapi tidak tahu cara mencetak hasil. Yang bisa dilakukan hanyalah membuat string. Ketika mencoba mencari tahu apa yang harus dilakukan dengan string, ia melihat garis kosong. Tapi, programmer memberi Anda tempat kosong untuk menuliskan panggilan balik Anda!

Dalam contoh ini, Anda tidak menggunakan pensil untuk mengisi kosong pada selembar kertas, Anda menggunakan fungsinya set_print_callback(the_callback).

• Variabel kosong dalam modul / kode adalah baris kosong,
• set_print_callback adalah pensil,
• dan the_callbackinformasi Anda sedang Anda isi.

Anda sekarang telah mengisi baris kosong ini dalam program. Setiap kali perlu mencetak output, itu akan melihat baris kosong itu, dan ikuti instruksi di sana (yaitu memanggil fungsi yang Anda letakkan di sana.) Secara praktis, ini memungkinkan kemungkinan pencetakan untuk menyaring, ke file log, ke printer, melalui koneksi jaringan, atau kombinasi daripadanya. Anda telah mengisi bagian yang kosong dengan apa yang ingin Anda lakukan.

Contoh 2:

Ketika Anda diberi tahu bahwa Anda perlu memanggil nomor darurat, Anda pergi dan membaca apa yang tertulis di formulir kertas, dan kemudian memanggil nomor yang Anda baca. Jika garis itu kosong, tidak ada yang akan dilakukan.

Pemrograman Gui bekerja dengan cara yang sama. Ketika sebuah tombol diklik, program perlu mencari tahu apa yang harus dilakukan selanjutnya. Ia pergi dan mencari callback. Callback ini kebetulan berada di tempat kosong berlabel "Inilah yang Anda lakukan ketika Button1 diklik"

Sebagian besar IDE akan secara otomatis mengisi bagian yang kosong untuk Anda (tulis metode dasar) ketika Anda memintanya (misalnya button1_clicked). Namun kosong itu dapat memiliki metode apa pun yang sangat Anda sukai . Anda bisa memanggil metode run_computationsatau butter_the_biscuitsselama Anda memasukkan nama panggilan balik itu di tempat yang tepat. Anda dapat mengosongkan "555-555-1212" di nomor darurat. Itu tidak masuk akal, tapi itu dibolehkan.

Catatan akhir: Baris kosong yang Anda isi dengan callback? Itu bisa dihapus dan ditulis ulang sesuka hati. (Apakah Anda harus atau tidak adalah pertanyaan lain, tetapi itu adalah bagian dari kekuatan mereka)

Selalu lebih baik untuk memulai dengan contoh :).

Anggap Anda memiliki dua modul A dan B.

Anda ingin modul A diberi tahu ketika beberapa peristiwa / kondisi terjadi di modul B. Namun, modul B tidak tahu tentang modul Anda A. Yang diketahui adalah alamat ke fungsi tertentu (modul A) melalui penunjuk fungsi yang disediakan oleh modul A.

Jadi yang harus dilakukan B sekarang adalah "callback" ke dalam modul A ketika peristiwa / kondisi tertentu terjadi dengan menggunakan pointer fungsi. A dapat melakukan pemrosesan lebih lanjut di dalam fungsi panggilan balik.

*) Keuntungan yang jelas di sini adalah bahwa Anda mencabut semua tentang modul A dari modul B. Modul B tidak perlu peduli siapa / apa modul A itu.

Johny programmer membutuhkan stapler, jadi dia pergi ke departemen persediaan kantor dan meminta satu, setelah mengisi formulir permintaan dia bisa berdiri di sana dan menunggu petugas pergi melihat-lihat gudang untuk stapler (seperti panggilan fungsi pemblokiran ) atau lakukan hal lain sementara itu.

karena ini biasanya membutuhkan waktu, johny meletakkan catatan bersama dengan formulir permintaan meminta mereka untuk memanggilnya ketika stapler siap untuk diambil, sehingga sementara itu dia bisa pergi melakukan sesuatu yang lain seperti tidur di mejanya.

Bayangkan Anda membutuhkan fungsi yang mengembalikan 10 kuadrat sehingga Anda menulis fungsi:

function tenSquared() {return 10*10;}

Kemudian Anda perlu 9 kuadrat sehingga Anda menulis fungsi lain:

function nineSquared() {return 9*9;}

Akhirnya Anda akan mengganti semua ini dengan fungsi generik:

function square(x) {return x*x;}

Pemikiran yang sama persis berlaku untuk panggilan balik. Anda memiliki fungsi yang melakukan sesuatu dan ketika selesai melakukan panggilan doA:

function computeA(){
    ...
    doA(result);
}

Kemudian Anda ingin fungsi yang sama persis untuk memanggil doB sebagai gantinya Anda dapat menduplikasi seluruh fungsi:

function computeB(){
    ...
    doB(result);
}

Atau Anda bisa melewatkan fungsi panggilan balik sebagai variabel dan hanya perlu memiliki fungsi sekali:

function compute(callback){
    ...
    callback(result);
}

Maka Anda hanya perlu memanggil compute (doA) dan compute (doB).

Selain menyederhanakan kode, ini memungkinkan kode asinkron memberi tahu Anda telah selesai dengan memanggil fungsi sewenang-wenang Anda pada penyelesaian, mirip dengan ketika Anda memanggil seseorang di telepon dan meninggalkan nomor panggilan balik.

Anda merasa sakit sehingga Anda pergi ke dokter. Dia memeriksa Anda dan memastikan Anda membutuhkan obat. Dia meresepkan beberapa obat-obatan dan memanggil resep ke apotek lokal Anda. Kamu pulang. Kemudian, apotek Anda menelepon untuk memberi tahu Anda bahwa resep Anda siap. Anda pergi dan mengambilnya.

Ada dua hal untuk dijelaskan, satu adalah cara kerja callback (melewati fungsi yang dapat dipanggil tanpa mengetahui konteksnya), yang lain untuk apa fungsi itu digunakan (menangani acara secara tidak serempak).

Analogi menunggu bingkisan tiba yang telah digunakan oleh jawaban lain adalah baik untuk menjelaskan keduanya. Dalam program komputer, Anda akan memberi tahu komputer untuk mengharapkan sebuah paket. Biasanya, sekarang akan duduk di sana dan menunggu (dan tidak melakukan apa pun) sampai parsel tiba, mungkin tanpa batas waktu jika tidak pernah tiba. Bagi manusia, ini terdengar konyol, tetapi tanpa langkah lebih lanjut, ini benar-benar alami untuk komputer.

Sekarang panggilan balik akan menjadi bel di pintu depan Anda. Anda memberikan layanan paket dengan cara untuk memberi tahu Anda tentang kedatangan paket tanpa mereka harus tahu di mana (bahkan jika) Anda berada di rumah, atau bagaimana bel bekerja. (Misalnya, beberapa "bel" sebenarnya mengirimkan panggilan telepon.) Karena Anda memberikan "fungsi panggil balik" yang dapat "dipanggil" kapan saja, di luar konteks, kini Anda dapat berhenti duduk di teras depan dan "menangani event "(kedatangan paket) kapan pun waktunya.

Bayangkan seorang teman meninggalkan rumah Anda, dan Anda memberi tahu dia "Panggil saya ketika Anda sampai di rumah sehingga saya tahu Anda tiba dengan selamat"; itu adalah (secara harfiah) panggilan kembali . Itulah fungsi panggilan balik, apa pun bahasanya. Anda ingin beberapa prosedur untuk memberikan kontrol kembali kepada Anda ketika telah menyelesaikan beberapa tugas, sehingga Anda memberikannya fungsi untuk digunakan untuk memanggil kembali kepada Anda.

Dalam Python, misalnya,

grabDBValue( (lambda x: passValueToGUIWindow(x) ))

grabDBValuebisa ditulis hanya untuk mengambil nilai dari database dan kemudian membiarkan Anda menentukan apa yang sebenarnya harus dilakukan dengan nilai, sehingga ia menerima fungsi. Anda tidak tahu kapan atau apakah grabDBValueakan kembali, tetapi jika / ketika itu kembali, Anda tahu apa yang ingin Anda lakukan. Di sini, saya mengirimkan fungsi anonim (atau lambda ) yang mengirimkan nilai ke jendela GUI. Saya dapat dengan mudah mengubah perilaku program dengan melakukan ini:

grabDBValue( (lambda x: passToLogger(x) ))

Callback bekerja dengan baik dalam bahasa di mana fungsi adalah nilai kelas pertama , seperti integer biasa, string karakter, boolean, dll. Dalam C, Anda dapat "meneruskan" fungsi sekitar dengan mengedarkan pointer ke sana dan penelepon dapat menggunakannya; di Jawa, pemanggil akan meminta kelas statis dari jenis tertentu dengan nama metode tertentu karena tidak ada fungsi ("metode," benar-benar) di luar kelas; dan di sebagian besar bahasa dinamis lainnya Anda hanya dapat melewatkan fungsi dengan sintaksis sederhana.

Protip:

Dalam bahasa dengan pelingkupan leksikal (seperti Skema atau Perl) Anda dapat melakukan trik seperti ini:

my $var = 2;
my $val = someCallerBackFunction(sub callback { return $var * 3; });
# Perlistas note: I know the sub doesn't need a name, this is for illustration

$valdalam hal ini akan 6karena callback memiliki akses ke variabel yang dideklarasikan dalam lingkungan leksikal di mana ia didefinisikan. Lingkup leksikal dan panggilan balik anonim adalah kombinasi yang kuat yang menuntut studi lebih lanjut untuk programmer pemula.

Anda memiliki beberapa kode yang ingin Anda jalankan. Biasanya, ketika Anda menyebutnya Anda kemudian menunggu untuk selesai sebelum Anda melanjutkan (yang dapat menyebabkan aplikasi Anda menjadi abu-abu / menghasilkan waktu pemintalan untuk kursor).

Metode alternatif adalah menjalankan kode ini secara paralel dan melanjutkan pekerjaan Anda sendiri. Tetapi bagaimana jika kode asli Anda perlu melakukan hal-hal yang berbeda tergantung pada respons dari kode yang disebutnya? Nah, dalam hal ini Anda bisa memasukkan nama / lokasi kode yang Anda ingin panggil ketika selesai. Ini adalah "panggilan balik".

Kode normal: Minta Informasi-> Proses Informasi-> Berurusan dengan hasil Pemrosesan-> Lanjutkan untuk melakukan hal-hal lain.

Dengan panggilan balik: Minta Informasi-> Proses Informasi-> Lanjutkan untuk melakukan hal-hal lain. Dan di beberapa titik kemudian-> Berurusan dengan hasil Pemrosesan.

Tanpa panggilan balik, sumber daya pemrograman khusus lainnya (seperti threading, dan lain-lain), suatu program merupakan urutan instruksi yang dieksekusi secara berurutan , dan bahkan dengan semacam "perilaku dinamis" yang ditentukan oleh kondisi tertentu, semua skenario yang mungkin harus diprogram sebelumnya .

Jadi, Jika kita perlu memberikan perilaku dinamis nyata untuk suatu program, kita dapat menggunakan panggilan balik. Dengan panggilan balik Anda dapat menginstruksikan oleh parameter, program untuk memanggil program lain yang menyediakan beberapa parameter yang telah ditentukan sebelumnya dan dapat mengharapkan beberapa hasil ( ini adalah kontrak atau tanda tangan operasi ), sehingga hasil ini dapat diproduksi / diproses oleh program pihak ketiga yang tidak sebelumnya diketahui.

Teknik ini adalah dasar dari polimorfisme yang diterapkan pada program, fungsi, objek dan semua kesatuan lainnya dari kode yang dijalankan oleh komputer.

Dunia manusia yang digunakan sebagai contoh untuk menelepon kembali dijelaskan dengan bagus ketika Anda melakukan beberapa pekerjaan, misalkan Anda adalah seorang pelukis (di sini Anda adalah program utama, yang melukis ) dan kadang-kadang menelepon klien Anda untuk memintanya menyetujui hasil pekerjaan Anda. , jadi, ia memutuskan apakah gambarnya bagus ( klien Anda adalah program pihak ketiga ).

Dalam contoh di atas Anda adalah seorang pelukis dan "mendelegasikan" pekerjaan kepada orang lain untuk menyetujui hasilnya, gambar adalah parameter, dan setiap klien baru (fungsi "dipanggil" kembali) mengubah hasil pekerjaan Anda memutuskan apa yang diinginkannya tentang gambar ( keputusan yang dibuat oleh klien adalah hasil yang dikembalikan dari "fungsi panggilan balik" ).

Semoga penjelasan ini bermanfaat.

Mari kita berpura-pura memberi saya tugas yang berpotensi jangka panjang: dapatkan nama-nama dari lima orang unik pertama yang Anda temui. Ini mungkin memakan waktu berhari-hari jika saya berada di daerah yang jarang penduduknya. Anda tidak benar-benar tertarik duduk di tangan Anda sementara saya berlarian sehingga Anda berkata, "Ketika Anda sudah memiliki daftar itu, panggil saya di sel saya dan bacakan kembali kepada saya. Ini nomornya.".

Anda telah memberi saya referensi panggilan balik - fungsi yang seharusnya saya jalankan untuk memberikan pemrosesan lebih lanjut.

Dalam JavaScript, tampilannya mungkin seperti ini:

var lottoNumbers = [];
var callback = function(theNames) {
  for (var i=0; i<theNames.length; i++) {
    lottoNumbers.push(theNames[i].length);
  }
};

db.executeQuery("SELECT name " +
                "FROM tblEveryOneInTheWholeWorld " +
                "ORDER BY proximity DESC " +
                "LIMIT 5", callback);

while (lottoNumbers.length < 5) {
  playGolf();
}
playLotto(lottoNumbers);

Ini mungkin dapat ditingkatkan dengan banyak cara. Misalnya, Anda bisa memberikan panggilan balik kedua: jika berakhir lebih lama dari satu jam, hubungi telepon merah dan beri tahu orang yang menjawab bahwa Anda sudah kehabisan waktu.

Panggilan balik paling mudah dijelaskan dalam hal sistem telepon. Panggilan fungsi analog dengan memanggil seseorang di telepon, mengajukan pertanyaan kepadanya, mendapatkan jawaban, dan menutup telepon; menambahkan callback mengubah analoginya sehingga setelah mengajukan pertanyaan kepadanya, Anda juga memberikan nama dan nomor Anda sehingga dia dapat menghubungi Anda kembali dengan jawabannya. - Paul Jakubik, "Implementasi Callback di C ++"

Panggilan balik adalah fungsi yang akan dipanggil oleh fungsi kedua. Fungsi kedua ini tidak tahu sebelumnya apa fungsi yang akan dipanggil. Jadi identitas fungsi panggilan balik disimpan di suatu tempat, atau diteruskan ke fungsi kedua sebagai parameter. "Identitas" ini, tergantung pada bahasa pemrograman, mungkin alamat dari panggilan balik, atau semacam penunjuk lain, atau itu mungkin nama fungsi. Prinsipnya sama, kami menyimpan atau meneruskan beberapa informasi yang jelas mengidentifikasi fungsi.

Ketika saatnya tiba, fungsi kedua dapat memanggil callback, memasok parameter tergantung pada keadaan pada saat itu. Bahkan mungkin memilih callback dari serangkaian kemungkinan callback. Bahasa pemrograman harus menyediakan semacam sintaks untuk memungkinkan fungsi kedua memanggil callback, mengetahui "identitasnya."

Mekanisme ini memiliki banyak kegunaan yang mungkin. Dengan panggilan balik, perancang suatu fungsi dapat membiarkannya dikustomisasi dengan meminta panggilan apa pun yang diberikan kembali. Misalnya, fungsi penyortiran mungkin mengambil panggilan balik sebagai parameter, dan panggilan balik ini mungkin berfungsi untuk membandingkan dua elemen untuk memutuskan mana yang lebih dulu.

Omong-omong, tergantung pada bahasa pemrograman, kata "fungsi" dalam diskusi di atas mungkin diganti dengan "blokir," "penutupan," "lambda," dll.

Biasanya kami mengirim variabel ke fungsi. Misalkan Anda memiliki tugas di mana variabel perlu diproses sebelum diberikan sebagai argumen - Anda dapat menggunakan panggilan balik.

function1(var1, var2) adalah cara yang biasa.

Bagaimana jika saya ingin var2diproses dan kemudian dikirim sebagai argumen? function1(var1, function2(var2))

Ini adalah salah satu jenis panggilan balik - di mana function2mengeksekusi beberapa kode dan mengembalikan variabel kembali ke fungsi awal.

Penjelasan metaforis:

Saya punya parsel yang ingin saya kirim ke teman, dan saya juga ingin tahu kapan teman saya menerimanya.

Jadi saya membawa bungkusan itu ke kantor pos dan meminta mereka untuk mengirimkannya. Jika saya ingin tahu kapan teman saya menerima bungkusan itu, saya punya dua opsi:

(a) Saya bisa menunggu di kantor pos sampai dikirim.

(B) Saya akan mendapatkan email saat dikirimkan.

Opsi (b) analog dengan panggilan balik.

Untuk mengajarkan panggilan balik, Anda harus mengajarkan pointer terlebih dahulu. Setelah siswa memahami gagasan pointer ke variabel, gagasan panggilan balik akan menjadi lebih mudah. Dengan asumsi Anda menggunakan C / C ++, langkah-langkah ini dapat diikuti.

• Pertama-tama perlihatkan kepada siswa Anda cara menggunakan dan memanipulasi variabel menggunakan pointer bersama menggunakan pengenal variabel normal.
• Kemudian ajari mereka ada hal-hal yang bisa dilakukan hanya dengan pointer (seperti melewati variabel dengan referensi).
• Kemudian beri tahu mereka bagaimana kode atau fungsi yang dapat dieksekusi sama seperti beberapa data lain (atau variabel) dalam memori. Jadi, fungsi juga memiliki alamat atau petunjuk.
• Kemudian tunjukkan pada mereka bagaimana fungsi dapat dipanggil dengan pointer fungsi dan katakan ini disebut callback.
• Sekarang, pertanyaannya adalah, mengapa semua kerumitan ini memanggil beberapa fungsi? Apa manfaatnya? Seperti data pointer, fungsi pointer alias panggilan balik memiliki beberapa keunggulan dibandingkan menggunakan pengidentifikasi normal.
• Yang pertama adalah, pengidentifikasi fungsi atau nama fungsi tidak dapat digunakan sebagai data normal. Maksud saya, Anda tidak dapat membuat struktur data dengan fungsi (seperti array atau daftar fungsi yang ditautkan). Tetapi dengan panggilan balik, Anda dapat membuat larik, daftar tertaut, atau menggunakannya dengan data lain seperti dalam kamus pasangan nilai kunci atau pohon, atau hal lainnya. Ini adalah manfaat yang sangat kuat. Dan manfaat lain sebenarnya adalah anak yang satu ini.
• Penggunaan callback yang paling umum terlihat dalam pemrograman driver acara. Di mana satu atau lebih fungsi dijalankan berdasarkan beberapa sinyal yang masuk. Dengan panggilan balik, kamus dapat dipertahankan untuk memetakan sinyal dengan panggilan balik. Maka resolusi sinyal input dan eksekusi kode yang sesuai menjadi lebih mudah.
• Penggunaan kedua panggilan balik yang muncul di pikiran saya adalah fungsi tingkat tinggi. Fungsi yang mengambil fungsi lain sebagai argumen input. Dan untuk mengirim fungsi sebagai argumen, kita perlu panggilan balik. Contohnya bisa berupa fungsi yang mengambil array dan panggilan balik. Kemudian ia melakukan panggilan balik pada setiap item array dan mengembalikan hasilnya dalam array lain. Jika kita melewati fungsi panggilan balik dua kali lipat, kita mendapatkan array bernilai dua kali lipat. Jika kami melewati callback kuadrat, kami mendapatkan kotak. Untuk akar kuadrat, cukup kirim callback yang sesuai. Ini tidak dapat dilakukan dengan fungsi normal.

Mungkin ada banyak hal lagi. Libatkan siswa dan mereka akan menemukan. Semoga ini membantu.

Dalam bahasa Inggris yang sederhana, panggilan balik adalah sebuah janji. Joe, Jane, David dan Samantha berbagi tempat parkir untuk bekerja. Joe mengemudi hari ini. Jane, David dan Samantha memiliki beberapa opsi:

1. Periksa jendela setiap 5 menit untuk melihat apakah Joe keluar
2. Terus lakukan hal mereka sampai Joe membunyikan bel pintu.

Opsi 1: Ini lebih seperti contoh polling di mana Jane akan terjebak dalam "lingkaran" memeriksa apakah Joe ada di luar. Jane tidak bisa melakukan hal lain untuk sementara waktu.

Opsi 2: Ini adalah contoh panggilan balik. Jane memberitahu Joe untuk membunyikan bel pintu ketika dia di luar. Dia memberinya "fungsi" untuk membunyikan bel pintu. Joe tidak perlu tahu bagaimana bel pintu bekerja atau di mana itu, dia hanya perlu memanggil fungsi itu yaitu membunyikan bel pintu ketika dia ada di sana.

Panggilan balik didorong oleh "acara". Dalam contoh ini "acara" adalah kedatangan Joe. Dalam Ajax misalnya acara dapat "berhasil" atau "gagal" dari permintaan asinkron dan masing-masing dapat memiliki panggilan balik yang sama atau berbeda.

Dalam hal aplikasi JavaScript dan panggilan balik. Kita juga perlu memahami "penutupan" dan konteks aplikasi. Apa yang dimaksud dengan "ini" dapat dengan mudah membingungkan pengembang JavaScript. Dalam contoh ini dalam metode / panggilan balik "ring_the_door_bell ()" setiap orang mungkin ada beberapa metode lain yang perlu dilakukan setiap orang berdasarkan ex rutinitas pagi mereka. "Matikan tvnya()". Kami ingin "ini" merujuk ke objek "Jane" atau objek "David" sehingga masing-masing dapat mengatur apa pun yang mereka butuhkan sebelum Joe mengambilnya. Di sinilah pengaturan callback dengan Joe membutuhkan memparodikan metode sehingga "ini" mengacu pada objek yang tepat.

Semoga itu bisa membantu!

Panggilan balik adalah amplop bermesin yang ditujukan sendiri. Ketika Anda memanggil suatu fungsi, itu seperti mengirim surat. Jika Anda ingin fungsi itu memanggil fungsi lain, Anda memberikan informasi itu dalam bentuk referensi atau alamat.

Saya pikir ini tugas yang agak mudah untuk dijelaskan.

Pada panggilan balik pertama hanya fungsi biasa.
Dan selanjutnya, kita memanggil fungsi ini (sebut saja A) dari dalam fungsi lain (sebut saja B).

Keajaiban tentang ini adalah saya yang memutuskan, fungsi mana yang harus dipanggil oleh fungsi dari luar B.

Pada saat saya menulis fungsi, BI tidak tahu fungsi callback mana yang harus dipanggil. Pada saat saya memanggil fungsi, BI juga memberi tahu fungsi ini untuk memanggil fungsi A. Itu saja.

Apa itu Fungsi Panggilan Balik?

Jawaban sederhana untuk pertanyaan pertama ini adalah bahwa fungsi callback adalah fungsi yang dipanggil melalui pointer fungsi. Jika Anda melewatkan pointer (alamat) suatu fungsi sebagai argumen ke yang lain, ketika pointer itu digunakan untuk memanggil fungsi itu menunjuk ke sana dikatakan bahwa panggilan balik dilakukan.

Fungsi panggilan balik sulit dilacak, tetapi terkadang sangat berguna. Terutama saat Anda mendesain perpustakaan. Fungsi panggilan balik seperti meminta pengguna Anda untuk memberi Anda nama fungsi, dan Anda akan memanggil fungsi itu dalam kondisi tertentu.

Misalnya, Anda menulis timer panggilan balik. Ini memungkinkan Anda menentukan durasi dan fungsi apa yang harus dipanggil, dan fungsi tersebut akan menjadi panggilan balik yang sesuai. “Jalankan fungsi saya () setiap 10 detik selama 5 kali”

Atau Anda dapat membuat direktori fungsi, melewati daftar nama fungsi dan meminta pustaka untuk memanggil kembali sesuai. "Panggilan balik sukses () jika berhasil, panggilan balik gagal () jika gagal."

Mari kita lihat contoh pointer fungsi sederhana

void cbfunc()
{
     printf("called");
}

 int main ()
 {
                   /* function pointer */ 
      void (*callback)(void); 
                   /* point to your callback function */ 
      callback=(void *)cbfunc; 
                   /* perform callback */
      callback();
      return 0; 
}

Bagaimana cara menyampaikan argumen ke fungsi panggilan balik?

Mengamati bahwa pointer fungsi untuk mengimplementasikan panggilan balik tidak berlaku *, yang menunjukkan bahwa ia dapat mengambil semua jenis variabel termasuk struktur. Oleh karena itu Anda dapat menyampaikan beberapa argumen berdasarkan struktur.

typedef struct myst
{
     int a;
     char b[10];
}myst;

void cbfunc(myst *mt) 
{
     fprintf(stdout,"called %d %s.",mt->a,mt->b); 
}

int main() 
{
       /* func pointer */
    void (*callback)(void *);       //param
     myst m;
     m.a=10;
     strcpy(m.b,"123");       
     callback = (void*)cbfunc;    /* point to callback function */
     callback(&m);                /* perform callback and pass in the param */
     return 0;   
}

Panggilan balik adalah metode yang dijadwalkan untuk dieksekusi ketika suatu kondisi terpenuhi.

Contoh "dunia nyata" adalah toko video game lokal. Anda menunggu Half-Life 3. Alih-alih pergi ke toko setiap hari untuk melihat apakah itu masuk, Anda mendaftarkan email Anda pada daftar untuk diberi tahu ketika permainan tersedia. Email menjadi "panggilan balik" Anda dan syarat yang harus dipenuhi adalah ketersediaan game.

Contoh "programmer" adalah halaman web tempat Anda ingin melakukan tindakan ketika tombol diklik. Anda mendaftarkan metode panggilan balik untuk suatu tombol dan melanjutkan melakukan tugas-tugas lain. Ketika / jika pengguna menekan tombol, browser akan melihat daftar panggilan balik untuk peristiwa itu dan memanggil metode Anda.

Panggilan balik adalah cara untuk menangani acara secara tidak sinkron. Anda tidak akan pernah tahu kapan callback akan dieksekusi, atau apakah akan dieksekusi sama sekali. Keuntungannya adalah ia membebaskan program dan siklus CPU Anda untuk melakukan tugas-tugas lain sambil menunggu balasan.

Sederhana dan sederhana: Panggilan balik adalah fungsi yang Anda berikan ke fungsi lain, sehingga dapat memanggilnya .

Biasanya disebut ketika beberapa operasi selesai. Karena Anda membuat panggilan balik sebelum memberikannya ke fungsi lain, Anda dapat menginisialisasi dengan informasi konteks dari situs panggilan. Itulah mengapa ia dinamai panggilan * kembali * - fungsi pertama memanggil kembali ke dalam konteks dari mana ia dipanggil.

“Dalam pemrograman komputer, panggilan balik adalah referensi ke kode yang dapat dieksekusi, atau bagian dari kode yang dapat dieksekusi, yang diteruskan sebagai argumen ke kode lain. Ini memungkinkan lapisan perangkat lunak tingkat rendah untuk memanggil subrutin (atau fungsi) yang didefinisikan dalam lapisan tingkat yang lebih tinggi. " - Wikipedia

Callback di C menggunakan Function Pointer

Di C, callback diimplementasikan menggunakan Function Pointer. Function Pointer - seperti namanya, adalah penunjuk ke suatu fungsi.

Misalnya, int (* ptrFunc) ();

Di sini, ptrFunc adalah pointer ke fungsi yang tidak menggunakan argumen dan mengembalikan integer. JANGAN lupa untuk memasukkan tanda kurung, jika tidak kompiler akan menganggap bahwa ptrFunc adalah nama fungsi normal, yang tidak mengambil apa-apa dan mengembalikan pointer ke integer.

Berikut ini beberapa kode untuk mendemonstrasikan penunjuk fungsi.

#include<stdio.h>
int func(int, int);
int main(void)
{
    int result1,result2;
    /* declaring a pointer to a function which takes
       two int arguments and returns an integer as result */
    int (*ptrFunc)(int,int);

    /* assigning ptrFunc to func's address */                    
    ptrFunc=func;

    /* calling func() through explicit dereference */
    result1 = (*ptrFunc)(10,20);

    /* calling func() through implicit dereference */        
    result2 = ptrFunc(10,20);            
    printf("result1 = %d result2 = %d\n",result1,result2);
    return 0;
}

int func(int x, int y)
{
    return x+y;
}

Sekarang mari kita mencoba memahami konsep Callback di C menggunakan pointer fungsi.

Program lengkap memiliki tiga file: callback.c, reg_callback.h dan reg_callback.c.

/* callback.c */
#include<stdio.h>
#include"reg_callback.h"

/* callback function definition goes here */
void my_callback(void)
{
    printf("inside my_callback\n");
}

int main(void)
{
    /* initialize function pointer to
    my_callback */
    callback ptr_my_callback=my_callback;                        
    printf("This is a program demonstrating function callback\n");
    /* register our callback function */
    register_callback(ptr_my_callback);                          
    printf("back inside main program\n");
    return 0;
}

/* reg_callback.h */
typedef void (*callback)(void);
void register_callback(callback ptr_reg_callback);


/* reg_callback.c */
#include<stdio.h>
#include"reg_callback.h"

/* registration goes here */
void register_callback(callback ptr_reg_callback)
{
    printf("inside register_callback\n");
    /* calling our callback function my_callback */
    (*ptr_reg_callback)();                               
}

Jika kita menjalankan program ini, hasilnya akan menjadi

Ini adalah program yang menunjukkan fungsi callback di dalam register_callback di dalam my_callback kembali ke dalam program utama

Fungsi lapisan yang lebih tinggi memanggil fungsi lapisan bawah sebagai panggilan normal dan mekanisme panggilan balik memungkinkan fungsi lapisan bawah untuk memanggil fungsi lapisan yang lebih tinggi melalui penunjuk ke fungsi panggilan balik.

Callback di Java Menggunakan Antarmuka

Java tidak memiliki konsep pointer fungsi. Ia mengimplementasikan mekanisme Callback melalui mekanisme Interface-nya. Di sini alih-alih pointer fungsi, kami mendeklarasikan sebuah Interface yang memiliki metode yang akan dipanggil ketika callee menyelesaikan tugasnya.

Izinkan saya menunjukkannya melalui contoh:

Antarmuka Panggilan Balik

public interface Callback
{
    public void notify(Result result);
}

Penelepon atau Kelas Tingkat Tinggi

public Class Caller implements Callback
{
Callee ce = new Callee(this); //pass self to the callee

//Other functionality
//Call the Asynctask
ce.doAsynctask();

public void notify(Result result){
//Got the result after the callee has finished the task
//Can do whatever i want with the result
}
}

Fungsi Callee atau lapisan bawah

public Class Callee {
Callback cb;
Callee(Callback cb){
this.cb = cb;
}

doAsynctask(){
//do the long running task
//get the result
cb.notify(result);//after the task is completed, notify the caller
}
}

Callback Menggunakan pola EventListener

• Daftar barang

Pola ini digunakan untuk memberi tahu 0 hingga n jumlah Pengamat / Pendengar bahwa tugas tertentu telah selesai

• Daftar barang

Perbedaan antara mekanisme Callback dan mekanisme EventListener / Observer adalah bahwa dalam callback, callee memberi tahu penelepon tunggal, sedangkan dalam Eventlisener / Observer, callee dapat memberi tahu siapa pun yang tertarik dengan peristiwa itu (notifikasi dapat pergi ke beberapa bagian lain dari aplikasi yang belum memicu tugas)

Izinkan saya menjelaskannya melalui contoh.

Antarmuka Acara

public interface Events {

public void clickEvent();
public void longClickEvent();
}

Widget kelas

package com.som_itsolutions.training.java.exampleeventlistener;

import java.util.ArrayList;
import java.util.Iterator;

public class Widget implements Events{

    ArrayList<OnClickEventListener> mClickEventListener = new ArrayList<OnClickEventListener>(); 
    ArrayList<OnLongClickEventListener> mLongClickEventListener = new ArrayList<OnLongClickEventListener>();

    @Override
    public void clickEvent() {
        // TODO Auto-generated method stub
        Iterator<OnClickEventListener> it = mClickEventListener.iterator();
                while(it.hasNext()){
                    OnClickEventListener li = it.next();
                    li.onClick(this);
                }   
    }
    @Override
    public void longClickEvent() {
        // TODO Auto-generated method stub
        Iterator<OnLongClickEventListener> it = mLongClickEventListener.iterator();
        while(it.hasNext()){
            OnLongClickEventListener li = it.next();
            li.onLongClick(this);
        }

    }

    public interface OnClickEventListener
    {
        public void onClick (Widget source);
    }

    public interface OnLongClickEventListener
    {
        public void onLongClick (Widget source);
    }

    public void setOnClickEventListner(OnClickEventListener li){
        mClickEventListener.add(li);
    }
    public void setOnLongClickEventListner(OnLongClickEventListener li){
        mLongClickEventListener.add(li);
    }
}

Tombol Kelas

public class Button extends Widget{
private String mButtonText;
public Button (){
} 
public String getButtonText() {
return mButtonText;
}
public void setButtonText(String buttonText) {
this.mButtonText = buttonText;
}
}

Kotak centang kelas

public class CheckBox extends Widget{
private boolean checked;
public CheckBox() {
checked = false;
}
public boolean isChecked(){
return (checked == true);
}
public void setCheck(boolean checked){
this.checked = checked;
}
}

Kelas Kegiatan

package com.som_itsolutions.training.java.exampleeventlistener;

public class Activity implements Widget.OnClickEventListener
{
    public Button mButton;
    public CheckBox mCheckBox;
    private static Activity mActivityHandler;
    public static Activity getActivityHandle(){
        return mActivityHandler;
    }
    public Activity ()
    {
        mActivityHandler = this;
        mButton = new Button();
        mButton.setOnClickEventListner(this);
        mCheckBox = new CheckBox();
        mCheckBox.setOnClickEventListner(this);
        } 
    public void onClick (Widget source)
    {
        if(source == mButton){
            mButton.setButtonText("Thank you for clicking me...");
            System.out.println(((Button) mButton).getButtonText());
        }
        if(source == mCheckBox){
            if(mCheckBox.isChecked()==false){
                mCheckBox.setCheck(true);
                System.out.println("The checkbox is checked...");
            }
            else{
                mCheckBox.setCheck(false);
                System.out.println("The checkbox is not checked...");
            }       
        }
    }
    public void doSomeWork(Widget source){
        source.clickEvent();
    }   
}

Kelas Lainnya

public class OtherClass implements Widget.OnClickEventListener{
Button mButton;
public OtherClass(){
mButton = Activity.getActivityHandle().mButton;
mButton.setOnClickEventListner(this);//interested in the click event                        //of the button
}
@Override
public void onClick(Widget source) {
if(source == mButton){
System.out.println("Other Class has also received the event notification...");
}
}

Kelas Utama

public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Activity a = new Activity();
OtherClass o = new OtherClass();
a.doSomeWork(a.mButton);
a.doSomeWork(a.mCheckBox);
}
}

Seperti yang dapat Anda lihat dari kode di atas, bahwa kami memiliki antarmuka yang disebut peristiwa yang pada dasarnya mencantumkan semua peristiwa yang mungkin terjadi untuk aplikasi kami. Kelas Widget adalah kelas dasar untuk semua komponen UI seperti Tombol, Kotak Centang. Komponen UI ini adalah objek yang benar-benar menerima peristiwa dari kode kerangka kerja. Kelas widget mengimplementasikan antarmuka Acara dan juga memiliki dua antarmuka bersarang yaitu OnClickEventListener & OnLongClickEventListener

Kedua antarmuka ini bertanggung jawab untuk mendengarkan acara yang mungkin terjadi pada komponen UI yang diturunkan dari Widget seperti Tombol atau Kotak Centang. Jadi jika kita membandingkan contoh ini dengan contoh Callback sebelumnya menggunakan Java Interface, kedua antarmuka ini berfungsi sebagai antarmuka Callback. Jadi kode tingkat yang lebih tinggi (Aktivitas Di Sini) mengimplementasikan dua antarmuka ini. Dan setiap kali suatu peristiwa terjadi pada widget, kode tingkat yang lebih tinggi (atau metode antarmuka ini diimplementasikan dalam kode tingkat yang lebih tinggi, yang ada di sini Kegiatan) akan dipanggil.

Sekarang saya akan membahas perbedaan mendasar antara pola Callback dan Eventlistener. Seperti yang telah kami sebutkan bahwa menggunakan Callback, Callee hanya dapat memberi tahu Penelepon tunggal. Tetapi dalam kasus pola EventListener, setiap bagian atau kelas Aplikasi dapat mendaftar untuk acara yang mungkin terjadi pada Tombol atau Kotak Centang. Contoh kelas semacam ini adalah OtherClass. Jika Anda melihat kode OtherClass, Anda akan mendapati bahwa kode itu telah terdaftar sebagai pendengar ClickEvent yang mungkin muncul di Tombol yang ditentukan dalam Kegiatan. Bagian yang menarik adalah bahwa, di samping Activity (Penelepon), OtherClass ini juga akan diberitahukan setiap kali klik terjadi pada Button.

Callback memungkinkan Anda untuk memasukkan kode Anda sendiri ke dalam blok kode lain untuk dieksekusi di waktu lain, yang mengubah atau menambah perilaku blok kode lain itu sesuai dengan kebutuhan Anda. Anda mendapatkan fleksibilitas dan kemampuan penyesuaian sementara dapat memiliki kode yang lebih dapat dikelola.

Kurang hardcode = lebih mudah untuk dipelihara dan diubah = lebih sedikit waktu = lebih banyak nilai bisnis = kedahsyatan.

Misalnya, dalam javascript, menggunakan Underscore.js, Anda bisa menemukan semua elemen genap dalam array seperti ini:

var evens = _.filter([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
=> [2, 4, 6]

Contoh milik Underscore.js: http://documentcloud.github.com/underscore/#filter

[diedit] ketika kita memiliki dua fungsi yaitu functionA dan functionB , jika functionA bergantung pada functionB .

maka kita memanggil functionB sebagai fungsi callback . Ini banyak digunakan dalam kerangka Spring.

Pikirkan metode sebagai memberikan tugas kepada rekan kerja. Tugas sederhana mungkin sebagai berikut:

Solve these equations:
x + 2 = y
2 * x = 3 * y

Rekan kerja Anda rajin menghitung dan memberi Anda hasil berikut:

x = -6
y = -4

Tetapi rekan kerja Anda memiliki masalah, ia tidak selalu memahami notasi, seperti ^, tetapi ia memahaminya dengan deskripsi mereka. Seperti exponent. Setiap kali dia menemukan salah satu dari ini Anda mendapatkan yang berikut:

I don't understand "^"

Ini mengharuskan Anda untuk menulis ulang seluruh set instruksi Anda lagi setelah menjelaskan apa arti karakter itu kepada rekan kerja Anda, dan dia tidak selalu ingat di antara pertanyaan. Dan dia juga kesulitan mengingat tipmu, seperti tanyakan saja padaku. Namun dia selalu mengikuti arahan tertulis Anda sebaik mungkin.

Anda memikirkan solusi, Anda hanya menambahkan yang berikut ini ke semua instruksi Anda:

If you have any questions about symbols, call me at extension 1234 and I will tell you its name.

Sekarang, setiap kali dia memiliki masalah, dia memanggil Anda dan bertanya, alih-alih memberi Anda respons buruk dan membuat proses memulai kembali.

Ini darinya dalam hal mengunduh halaman web:

Program Anda berjalan di ponsel dan meminta halaman web http://www.google.com . Jika Anda menulis program secara sinkron, fungsi yang Anda tulis untuk mengunduh data akan terus berjalan hingga semua data diunduh. Ini berarti UI Anda tidak akan di-refresh dan pada dasarnya akan tampak beku. Jika Anda menulis program menggunakan panggilan balik, Anda meminta data dan mengatakan "jalankan fungsi ini setelah selesai." Ini memungkinkan UI untuk tetap memungkinkan interaksi pengguna saat file sedang diunduh. Setelah halaman web selesai mengunduh, fungsi hasil Anda (panggilan balik) dipanggil dan Anda dapat menangani datanya.

Pada dasarnya, ini memungkinkan Anda untuk meminta sesuatu dan terus mengeksekusi sambil menunggu hasilnya. Setelah hasilnya kembali kepada Anda melalui fungsi panggilan balik, Anda dapat mengambil operasi di mana itu ditinggalkan.