it-swarm-tr.com

Geri aramaları düz ingilizce olarak nasıl açıklayabilirim? Bir işlevi diğer bir işlevden çağırmaktan ne kadar farklıdırlar?

Geri aramaları düz İngilizce olarak nasıl açıklayabilirim? Çağrılan işlevden bir bağlam alarak, bir işlevi diğer bir işlevden çağırmaktan ne kadar farklıdırlar? Bir acemi programcısına güçleri nasıl açıklanabilir?

329
Yahoo-Me

Genellikle bir uygulamanın kendi bağlamına/durumuna bağlı olarak farklı işlevleri yerine getirmesi gerekir. Bunun için çağrılacak fonksiyonla ilgili bilgileri saklayacağımız bir değişken kullanırız. İhtiyaca göre, uygulama bu değişkeni çağrılacak işlev hakkında bilgi ile ayarlayacaktır ve aynı değişkeni kullanarak işlevi arayacaktır.

Javascript'te örnek aşağıdadır. Burada, işlev hakkında bilgiyi sakladığımız bir değişken olarak yöntem argümanını kullanırız.

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]
112
Niraj Nawanit

Bu ölüleri basit tutmaya çalışacağım. Bir "geri çağırma", ilk işlevi parametre olarak alan başka bir işlev tarafından çağrılan herhangi bir işlevdir. Çoğu zaman, "geri arama", bir şey olduğunda, denilen bir işlevdir. Bu bir şey programcı-konuşmasında "olay" olarak adlandırılabilir.

Bu senaryoyu hayal edin: Birkaç gün içinde bir paket bekliyorsunuz. Paket, komşunuz için bir hediyedir. Bu nedenle, paketi aldıktan sonra, komşularına getirilmesini istiyorsunuz. Şehir dışındasınız ve eşiniz için talimat bıraktınız.

Onlara paketi almalarını ve komşularına getirmelerini söyleyebilirsiniz. Eşiniz bir bilgisayar kadar aptal olsaydı, kapıda oturuyorlardı ve gelene kadar paketi beklerlerdi (başka bir şey yapmıyorlardı) ve sonra bir kez geldiğinde komşularınıza getiriyorlardı. Ama daha iyi bir yol var. Eşinize, bir kez paketi aldıklarını, komşuların üzerine getirmeleri gerektiğini söyleyin. Daha sonra paketi alır almazlar, normal olarak yaşamı devam ettirirler.

Örneğimizde, paketin alınması "olay" dır ve onu komşulara getirme "geri arama" dır. Eşiniz paketi sadece [] paket geldiğinde getirme talimatlarınızı "çalıştırır". Çok daha iyi!

Bu tür bir düşünce günlük yaşamda açıktır, ancak bilgisayarların aynı ortak anlamı yoktur. Programcıların normal olarak bir dosyaya nasıl yazdıklarını göz önünde bulundurun:

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

Burada, yazmadan önce dosyanın açılmasını BEKLİYORUZ. Bu, yürütme akışını "engeller" ve programımız yapması gerekebilecek diğer hiçbir şeyi yapamaz! Ya bunun yerine bunu yapabilirsek:

# 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!

Bazı diller ve çerçevelerle bunu yaptığımız ortaya çıktı. Çok havalı! Bu tür bir düşünce ile gerçek bir pratik yapmak için göz atın Node.js .

504
Josh Imhoff

Geri aramaları düz İngilizce olarak nasıl açıklayabilirim?

Basit İngilizce'de geri çağırma işlevi Çalışanıgibidir Yöneticisiile Görev.

Çağrılan işlevden bir bağlam alarak, bir işlevi diğer bir işlevden çağırmaktan ne kadar farklıdırlar?

Başka bir işlevden bir işlev çağırdığınız doğrudur, ancak anahtar geri çağrının bir Nesne gibi işlenmesidir, böylece sistemin işlevine göre (İşlev Tasarım Şablonu gibi) çağrılacak İşlev'i değiştirebilirsiniz.

Bir acemi programcısına güçleri nasıl açıklanabilir?

Geri aramaların gücü, bir sunucudan veri çekmek zorunda olan AJAX tarzı web sitelerinde kolayca görülebilir. Yeni verilerin indirilmesi biraz zaman alabilir. Geri aramalar olmadan, tüm Kullanıcı Arayüzünüz yeni verileri indirirken "donacak" ya da sadece bir kısmı yerine tüm sayfayı yenilemeniz gerekecektir. Bir geri çağırma ile, "şimdi yükleniyor" bir görüntü ekleyebilir ve yüklendikten sonra onu yeni verilerle değiştirebilirsiniz.

Geri arama olmadan bazı kodlar:

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)');
}

Geri arama ile:

JQuery's getJSON kullanarak bir geri çağırma örneği:

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
}

Kapanış ile:

Genellikle geri çağırma, İşçiöncesi Yöneticisindenbilgisinden bilgi almak için gereken [__///] İşçi/(+)/gibi bir statekullanarak çağrı işlevinden closuredosyasına erişmesi gerekir. Görevgörevini tamamlayabilir. closureöğesini oluşturmak için, işlevi çağıran bağlamda verileri görecek şekilde satır içi yapabilirsiniz:

/* 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
}

Kullanımı:

// 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); 

Kapatma

Son olarak, burada Douglas Crockford adından closuretanımı verilmiştir:

İşlevler, diğer işlevlerin içinde tanımlanabilir. İç fonksiyon, dış fonksiyonun değişkenlerine ve parametrelerine erişebilir. Bir içsel fonksiyona bir referans hayatta kalırsa (örneğin bir geri arama fonksiyonu olarak), dış fonksiyonun varyasyonu da hayatta kalır.

Ayrıca bakınız:

80
user508994

Çok sayıda akıllı insanın "geri arama" kelimesinin iki tutarsız şekilde kullanılmaya başlandığı gerçeğini vurgulamadığını görmekten şaşırdım.

Her iki yol da, mevcut bir işleve ek işlevsellik (işlev tanımı, adsız veya adlandırılmış) ileterek bir işlevin özelleştirilmesini içerir. yani.

customizableFunc(customFunctionality)

Özel işlevler basitçe kod bloğuna takılıysa, işlevi de özelleştirdiniz.

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

Bu tür enjekte edilen işlevsellik genellikle "geri arama" olarak adlandırılsa da, bununla ilgili hiçbir şey yoktur. Çok açık bir örnek, özel bir işlevin, diziyi değiştirmek için dizideki her öğeye uygulanacak bir argüman olarak sağlandığı forEach yöntemidir.

Ancak bu temel olarak asenkron programlama için "geri çağırma" işlevlerinin kullanımından, AJAX veya node.js'de olduğu gibi veya sadece kullanıcı etkileşimi olaylarına (fare tıklamaları gibi) işlevsellik atama konusunda farklıdır. ). Bu durumda, tüm fikir özel işlevi yerine getirmeden önce şarta bağlı bir olayın gerçekleşmesini beklemektir. Bu kullanıcı etkileşimi durumunda açıktır, ancak diskten dosya okumak gibi zaman alabilen g/Ç (giriş/çıkış) işlemlerinde de önemlidir. Bu, "geri arama" teriminin en belirgin anlam ifade ettiği yerdir. Bir g/ç işlemi başlatıldığında (http isteğinden veri döndürmek için bir dosyanın diskten veya sunucudan okunmasını istemek gibi) bir zaman uyumsuz programı beklemiyor bitirmesi için. Daha sonra ne zaman görevlendirilmiş olursa olsun ilerlemeye devam edebilir ve yalnızca okuma dosyasının veya http isteğinin tamamlandığı (veya başarısız olduğu) ve verinin özel işlev için kullanılabilir olduğu bildirildikten sonra özel işlevlerle yanıt verebilir. Telefondaki bir işi aramak ve "geri arama" numaranızı bırakmak gibi bir şey, böylece birileri size geri dönmeye uygun olduğunda sizi arayabilir. Bu, diğer işlere ne kadar zaman devam edemediğini ve katılamayacağını bilenler için hatta beklemekten daha iyidir.

Eşzamansız kullanım, doğal olarak, istenen olayı (örneğin, g/Ç işleminin tamamlanması) dinlemenin bazı araçlarını içerir, böylece gerçekleştiğinde (ve yalnızca gerçekleştiğinde), özel "geri çağırma" işlevi gerçekleştirilir. Bariz AJAX örneğinde, veriler sunucudan gerçekten geldiğinde, bu verileri DOM'yi değiştirmek için kullanmak ve bu nedenle tarayıcı penceresini bu ölçüde yeniden çizmek için "geri arama" işlevi tetiklenir.

Özetlemek için. Bazı insanlar "geri arama" kelimesini, mevcut bir işleve argüman olarak enjekte edilebilecek herhangi bir özel işlevsellikten bahsetmek için kullanır. Ancak, en azından benim için en uygun kullanım, enjekte edilen "geri arama" işlevinin asenkron olarak kullanıldığı - yalnızca bildirilmeyi beklediği bir olayın gerçekleşmesi üzerine yürütülecek olmasıdır.

37
Robert Polevoi

Programlayıcı olmayan terimlerde, geri çağırma, bir programdaki boşluk doldurmadır.

Birçok kâğıt formun ortak bir maddesi “acil durumlarda arayacak kişi” dir. Orada boş bir satır var. Birinin adını ve telefon numarasını yazarsın. Acil bir durum olursa, o kişi aranır.

  • Herkes aynı boş form alır, ancak
  • Herkes farklı bir acil durum irtibat numarası yazabilir.

Bu anahtar. Formu değiştirmezsiniz (kod, genellikle bir başkasının). Ancak, eksik bilgi parçalarını doldurabilirsiniz ( numaranızı).

Örnek 1:

Geri çağrılar, muhtemelen bir programın davranışını eklemek/değiştirmek için özelleştirilmiş yöntemler olarak kullanılır. Örneğin, bir işlevi yerine getiren, ancak çıktının nasıl yazdırılacağını bilmeyen bazı C kodları alın. Yapabileceği tek şey bir dize yapmak. Dize ne yapılacağını anlamaya çalıştığında, boş bir satır görür. Ancak, programcı size geri arama yazmak için boş verdi!

Bu örnekte, bir sayfadaki boşluğu doldurmak için kurşun kalem kullanmazsınız, set_print_callback(the_callback) işlevini kullanırsınız.

  • Modül/koddaki boş değişken boş satırdır,
  • set_print_callback kalemdir,
  • ve the_callback, doldurduğunuz bilgilerinizdir.

Şimdi programdaki bu boş satırı doldurdunuz. Çıktıyı yazdırması gerektiğinde, bu boş satıra bakacak ve oradaki talimatları izleyecektir (örneğin, koyduğunuz işlevi çağırın.) Pratik olarak, bu, bir günlük dosyasına, bir yazıcıya ekrana yazdırma imkanı verir, bir ağ bağlantısı üzerinden veya bunların bir kombinasyonu ile. Ne yapmak istediğinizi boş bıraktınız.

Örnek 2:

Size acil bir numarayı aramanız gerektiği söylendiğinde, gidip kağıt formda yazılanları okuyorsunuz ve ardından okuduğunuz numarayı aramalısınız. Bu satır boşsa hiçbir şey yapılmaz.

Gui programlama aynı şekilde çalışır. Bir düğme tıklatıldığında, programın daha sonra ne yapacağını bulması gerekir. O gider ve geri arama arar. Bu geri arama, "Button1 tıklandığında yaptığınız şey" etiketli bir boşlukta olur

Çoğu IDE, sizden istediğinizde (örneğin button1_clicked) boşluğu otomatik olarak doldurur (temel yöntemi yazın). Bununla birlikte, bu boşluk, lütfen çok iyi tanıdığınız herhangi bir yöntemi içerebilir . Bu geri aramanın adını uygun boş bıraktığınız sürece, run_computations veya butter_the_biscuits yöntemini çağırabilirsiniz. Boş acil durum numarasına "555-555-1212" yazabilirsiniz. Çok anlamlı değil, ama izin verilebilir.


Son not: Geri aramayla doldurduğunuz boş satır? İstenildiği zaman silinebilir ve yeniden yazılabilir. (Başka bir soru olup olmamanız veya konuşmamanız, ancak bu onların gücünün bir parçasıdır)

26
JoeyG

Johny programcının bir zımbaya ihtiyacı var, bu yüzden ofis tedarik bölümüne gidiyor ve bir tane talep ediyor, talep formunu doldurduktan sonra ya orada durabilir ve katipin zımba için depoya bakmasını bekler (engelleme işlevi çağrısı gibi) ) ya da git bu arada başka bir şey yap.

bu genellikle zaman alır, johny zımba almaya hazır olduğunda onları aramak isteyen istek formu ile birlikte bir not koyar, bu yüzden o arada onun masasında uyku gibi başka bir şey yapabilir.

21
tovmeod

Bir örnekle başlamak her zaman daha iyi olur :).

İki A ve B modülünüz olduğunu varsayalım.

B modülünde bir olay/koşul meydana geldiğinde A modülünün bildirilmiş olmasını istersiniz. Bununla birlikte, B modülünün A modülünüz hakkında hiçbir fikri yoktur. Bildiği tek şey, belirli bir işlevin (A modülünün adresi) ) A modülü tarafından sağlanan bir fonksiyon göstericisi vasıtasıyla.

Bu nedenle, B'nin tek yapması gereken, işlev göstergesini kullanarak belirli bir olay/koşul meydana geldiğinde A modülüne "geri çağırma" dır. A geri çağırma işlevi içinde daha fazla işlem yapabilir.

*) Buradaki açık bir avantaj, A modülüyle ilgili her şeyi B modülünden çıkarmanızdır. Modül B, modül A'nın kim olduğu ile ilgilenmek zorunda değildir.

19
Gargi Srinivas

10 kareyi döndüren bir işleve ihtiyacınız olduğunu ve bir işlev yazdığınızı hayal edin:

function tenSquared() {return 10*10;}

Daha sonra 9 kareye ihtiyacınız var, böylece başka bir işlev yazmalısınız:

function nineSquared() {return 9*9;}

Sonunda bunların hepsini genel bir işlevle değiştireceksiniz:

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

Aynı düşünce, geri aramalar için de geçerlidir. Bir şey yapan ve doA çağrıları yaparken bir işleve sahipsiniz:

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

Daha sonra aynı işlevin doB'yi çağırmasını istiyorsanız bunun yerine tüm işlevi çoğaltabilirsiniz:

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

Veya bir geri çağırma işlevini değişken olarak iletebilir ve işlevin yalnızca bir kez olması gerekir:

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

O zaman sadece compute (doA) ve compute (doB) komutlarını çağırmanız gerekir.

Kod basitleştirmenin ötesinde, senkronize olmayan kodun, telefondaki birini aradığınızda ve bir geri arama numarası bıraktığınızda olduğu gibi, tamamlama sırasında keyfi işlevinizi çağırarak tamamlandığını bilmenizi sağlar.

18
Brian Nickel

Hasta hissediyorsun ve doktora gidiyorsun. Sizi muayene ediyor ve biraz ilaca ihtiyacınız olduğunu belirler. Bazı ilaçları reçete eder ve reçeteyi yerel eczanenize çağırır. Eve git. Daha sonra eczane size reçetenizin hazır olduğunu bildirmek için çağrı yapar. Sen git ve al.

11
effigy

Açıklanması gereken iki nokta var, bir tanesi geri çağrmanın nasıl çalıştığını (içeriğiyle ilgili herhangi bir bilgi olmadan çağrılabilecek bir fonksiyonun etrafından geçerek), diğeri ne için kullanıldığını (olayları eşzamansız olarak ele almak).

Diğer cevapların kullandığı bir parselin gelmesini beklemenin benzetmesi, her ikisini de açıklamak için iyi bir şeydir. Bir bilgisayar programında, bilgisayara bir paket beklemesini söyleyeceksiniz. Normalde, şimdi orada oturur ve parsel gelene kadar bekler (ve başka bir şey yapmaz), muhtemelen hiç gelmezse, süresiz olarak. İnsanlara göre, bu aptalca geliyor, ancak başka önlemler alınmadan, bu bir bilgisayar için tamamen doğal.

Şimdi geri arama, ön kapınızdaki zil olacaktı. Parsel hizmetini, evin neresinde olduğunuzu (hatta) nerede olduğunuzu veya zilin nasıl çalıştığını bilmeden, parselin gelişini size bildirecek bir yol sunarsınız. (Örneğin, bazı "çanlar" aslında bir telefon çağrısı gönderir.) Bağlam dışında, herhangi bir zamanda "çağrılabilir" olarak adlandırılabilecek bir "geri çağırma işlevi" sağladığınız için, artık ön sundurmada oturmayı durdurabilir ve " olay "(parsel varışta) zamanı geldiğinde.

10
Hanno Fietz

Geri aramalar, telefon sistemi açısından en kolay şekilde tanımlanır. İşlev çağrısı, birini telefonla aramak, ona soru sormak, cevap almak ve telefonu kapatmakla aynıdır; geri arama eklemek, analojiyi değiştirir. Ona bir soru sorarak, ona isminizi ve numaranızı da verin, böylece sizi cevapla geri arayabilir. - Paul Jakubik, "C++ 'da Geri Arama Uygulamaları"

6
DejanLekic

Bir arkadaşınızın evden ayrıldığını ve “Güvenle geldiğinizi bilmesi için beni eve gidince ara” deyin; bu (kelimenin tam anlamıyla) a geri arama. Dil ne olursa olsun, geri arama işlevi budur. Bir işlemi tamamladığında bazı işlemlerin kontrolü size geri vermesini istersiniz, bu yüzden size geri aramak için kullanması için bir işlev verirsiniz.

Python’da, örneğin

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

grabDBValuename__, yalnızca bir veritabanından bir değer almak ve daha sonra aslında değerle ne yapılacağını belirtmenize izin vermek için yazılabilir, bu nedenle bir işlevi kabul eder. Ne zaman veya eğer grabDBValue'nin ne zaman döneceğini bilmiyorsunuz, fakat/olduğunda ne yapmasını istediğinizi biliyorsunuz. Burada, değeri bir GUI penceresine gönderen isimsiz bir fonksiyona (veya lambda) geçiyorum. Bunu yaparak programın davranışını kolayca değiştirebilirim:

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

Geri aramalar, fonksiyonların birinci sınıf değerlerin olduğu gibi, her zamanki tamsayılar, karakter dizeleri, boolean'ler, vb. Gibi dillerde iyi çalışır. ve arayan bunu kullanabilir; Java'da, arayanlar sınıf dışında herhangi bir işlev ("yöntemler") olmadığından, belirli bir yöntem adına sahip belirli bir türde statik bir sınıf ister; ve diğer birçok dinamik dilde, basit sözdizimi olan bir işlevi iletebilirsiniz.

PROTIP:

lexical scoping (Scheme veya Perl gibi) dillerinde aşağıdaki gibi bir numara çekebilirsiniz:

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

Bu durumda $val6 olacaktır, çünkü geri arama, tanımlandığı lexical ortamında bildirilen değişkenlere erişebilir. Sözlüksel kapsam ve adsız geri aramalar, acemi programcı için daha fazla çalışmayı garanti eden güçlü bir kombinasyondur.

6
gatlin

Bana potansiyel olarak uzun süren bir görev vermiş gibi davranalım: karşılaştığınız ilk beş eşsiz insanın isimlerini alın. Seyrek nüfuslu bir bölgedeysem bu günler alabilir. Etrafta koşarken ellerinizle oturmakla gerçekten ilgilenmiyorsunuz ve "Liste elinize geldiğinde beni cep telefonundan ara ve bana geri oku. İşte burada." Diyorsunuz.

Bana bir geri arama referansı verdiniz - daha fazla işlem yapmak için yürütmem gereken bir fonksiyon.

JavaScript’te şuna benzer bir şey olabilir:

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);

Bu muhtemelen birçok yönden geliştirilebilir. Örneğin, ikinci bir geri arama sağlayabilirsiniz: bir saatten uzun sürerse, kırmızı telefonu arayın ve zaman aşımına uğrayan cevapları bu kişiye söyleyin.

6
steamer25

Geri arama olmadan, hiçbiri özel programlama kaynakları (iş parçacığı ve diğerleri gibi), bir program birbiri ardına sırayla yürütülen bir dizi komut değildir ve hatta bir tür "dinamik davranış" ile belirli şartlara göre, olası tüm senaryolar önceden programlanacaktır.

Bu nedenle, bir program için gerçek bir dinamik davranış sağlamamız gerekirse geri arama özelliğini kullanabiliriz. Geri çağırma ile parametrelere göre talimat verebilirsiniz, bir program daha önce tanımlanmış bazı parametreleri sağlayan başka bir programı çağırmasını ve bazı sonuçlar beklemesini bekleyebilir ( bu sözleşme veya işlem imzasıdır ), böylece bu sonuçlar daha önce bilinmeyen üçüncü taraf program tarafından üretilebilir/işlenebilir.

Bu teknik, programlara, işlevlere, nesnelere ve bilgisayarların koştuğu tüm kod birimlerine uygulanan polimorfizmin temelidir.

Geri çağırma örneği olarak kullanılan insan dünyası, bazı işler yaparken Nice'in açıkladığını, bir Ressam olduğunuzu varsayalım ( burada ana program olduğunuzu, boyaların olduğunu düşünelim ) bazen müşterinizi arayarak işinizin sonucunu onaylamasını isteyin, bu nedenle resmin iyi olup olmadığına karar verir ( müşterinizin üçüncü taraf programı olduğuna karar verir ).

Yukarıdaki örnekte, bir Ressam ve sonucu onaylama işini başkalarına "temsilci" olarak adlandırıyorsunuz, resim parametredir ve her yeni müşteri (geri çağırılan "işlev") çalışmanızın istediğini kararlaştırmasının sonucunu değiştirir resim hakkında ( müşterilerin verdiği karar "geriçağırım işlevi" nden ) döndürülen sonuçtur.

Umarım bu açıklama faydalı olabilir.

6
Luciano

Çalıştırmak istediğiniz bazı kodlar var. Normalde, onu aradığınızda, devam etmeden önce bitmesini beklersiniz (bu, uygulamanızın grileşmesine neden olabilir/imleç için sıkma süresi üretebilir).

Alternatif bir yöntem bu kodu paralel olarak çalıştırmak ve kendi çalışmanızı sürdürmektir. Peki ya orijinal kodunuz aradığı kodun cevabına bağlı olarak farklı şeyler yapmalıysa? Eh, bu durumda, bitince çağırmasını istediğiniz kodun adını/yerini girebilirsiniz. Bu bir "geri arama" dır.

Normal kod: Bilgi İsteyin-> İşlem Bilgisi-> İşlemin sonucuyla ilgilenin-> Başka şeyler yapmaya devam edin.

Geri aramalarla: Bilgi İste-> Bilgi İşlem--> Başka şeyler yapmaya devam edin. Ve daha sonra bazı noktalarda-> İşlem sonucu ile ilgilen.

6
Andrew Ducker

Geri çağırma, ikinci bir işlev tarafından çağrılacak olan bir işlevdir. Bu ikinci işlev hangi işlevi arayacağını önceden bilmiyor. Böylece geri çağırma işlevinin identity bir yere kaydedilir veya ikinci işleve parametre olarak iletilir. Programlama diline bağlı olarak bu "kimlik" geri aramanın adresi veya başka bir tür işaretçi olabilir veya işlevin adı olabilir. Ana prensip aynıdır, fonksiyonu açıkça tanımlayan bazı bilgileri saklıyor ya da aktarıyoruz.

Süre geldiğinde, ikinci işlev o andaki koşullara bağlı olarak parametreler sağlayan geri çağırma işlevini çağırabilir. Geri aramaları bir dizi olası geri aramalardan bile seçebilir. Programlama dili, ikinci işlevin “kimliğini” bilerek geri aramayı çağırmasını sağlamak için bir tür sözdizimi sağlamalıdır.

Bu mekanizmanın birçok olası kullanımı vardır. Geri aramalarla, bir fonksiyonun tasarımcısı, hangi geri aramalar yapılmışsa onu aramasını sağlayarak kişiselleştirilmesine izin verebilir. Örneğin, bir sıralama işlevi parametre olarak bir geri çağırma alabilir ve bu geri çağırma, hangisinin önce geleceğine karar vermek için iki öğeyi karşılaştırma işlevi olabilir.

Bu arada, programlama diline bağlı olarak, yukarıdaki tartışmadaki "fonksiyon" kelimesi "blok", "kapatma", "lambda" vb. İle değiştirilebilir.

5
David Casseres

Genellikle değişkenleri fonksiyonlara göndeririz. Değişkenin argüman olarak verilmeden önce işlenmesi gereken bir göreviniz olduğunu varsayalım - geri arama kullanabilirsiniz.

function1(var1, var2) olağan yoldur.

var2'nin işlenip sonra argüman olarak gönderilmesini istersem ne olur? function1(var1, function2(var2))

Bu bir geri çağrı türüdür - function2 bazı kodları çalıştırır ve bir değişkeni ilk işleve geri döndürür.

5
Nishant

Geri aramaları öğretmek için önce işaretçiyi öğretmeniz gerekir. Öğrenciler bir değişkene işaretçi fikrini anladıktan sonra geri arama fikri kolaylaşacaktır. C/C++ kullandığınızı varsayarsak, bu adımlar takip edilebilir.

  • Öncelikle öğrencilerinize normal değişken tanımlayıcıları kullanarak işaretçiler kullanarak değişkenleri nasıl kullanacaklarını ve değiştirebileceklerini gösterin.
  • O zaman onlara sadece işaretçilerle yapılabilecek şeyler olduğunu öğretin (bir değişkeni referansa göre geçirmek gibi).
  • Ardından, çalıştırılabilir kodun veya işlevlerin bellekteki diğer veriler (veya değişkenler) gibi olduğunu söyleyin. Bu nedenle, işlevlerin adresleri veya işaretçileri de vardır.
  • Ardından, işlev işaretçileriyle işlevlerin nasıl çağrılabildiğini gösterin ve bunlara geri arama denir.
  • Şimdi, soru şu, neden bazı işlevleri çağırmak için tüm bu güçlük? Fayda nedir? Veri işaretçileri gibi, işlev göstericisi aka geri aramaların normal tanımlayıcıları kullanmaktan bazı avantajları vardır.
  • Birincisi, işlev tanımlayıcıları veya işlev adları normal veri olarak kullanılamaz. Yani, fonksiyonlarla bir veri yapısı oluşturamazsınız (bir dizi veya bağlı fonksiyonlar listesi gibi). Ancak geri aramalarla, bir dizi, bağlantılı bir liste oluşturabilir veya bunları anahtar/değer çiftleri veya ağaçlar sözlüğü veya başka şeyler sözlüğü gibi başka verilerle kullanabilirsiniz. Bu güçlü bir faydadır. Ve diğer yararlar aslında bunun çocuğudur.
  • Geri aramaların en yaygın kullanımı, olay sürücüsü programlamasında görülür. Gelen sinyale bağlı olarak bir veya daha fazla fonksiyonun yürütüldüğü yer. Geri aramalarla, geri arama ile sinyalleri eşlemek için bir sözlük tutulabilir. Sonra giriş sinyali çözünürlüğü ve karşılık gelen kodun yürütülmesi çok daha kolay hale gelir.
  • Aklıma gelen geri aramaların ikinci kullanımı daha yüksek dereceli işlevlerdir. Giriş fonksiyon olarak diğer fonksiyonları alan fonksiyonlar. İşlevleri argüman olarak göndermek için geri çağrılara ihtiyacımız var. Örnek, bir dizi alan ve geri arama yapan bir işlev olabilir. Ardından, dizinin her bir öğesinde geri çağrı yapar ve sonuçları başka bir dizide döndürür. Fonksiyonu iki katına geri çağırırsak, iki katına çıkmış bir dizi alırız. Bir kare geri çağırmasını geçersek, kare alırız. Karekökler için uygun bir geri arama göndermeniz yeterlidir. Bu normal işlevlerle yapılamaz.

Daha birçok şey olabilir. Öğrencileri dahil edin ve keşfederler. Bu yardımcı olur umarım.

4
Gulshan

Bir mecazi açıklama:

Bir arkadaşıma teslim etmek istediğim bir paket var ve arkadaşımın ne zaman alacağını da bilmek istiyorum.

Bu yüzden parseyi postaneye götürüp teslim etmelerini rica ediyorum. Arkadaşımın paketi ne zaman alacağını bilmek istersem iki seçeneğim var:

(a) Postanede teslim edilene kadar bekleyebilirim.

(b) Teslim edildiğinde bir e-posta alacağım.

Seçenek (b) geri aramaya benzer.

4
tonylo

Düz İngilizce olarak bir geri arama bir sözdür. Joe, Jane, David ve Samantha çalışmak için bir carpool paylaşıyorlar. Joe bugün araba kullanıyor. Jane, David ve Samantha'nın birkaç seçeneği var:

  1. Joe'nun dışarıda olup olmadığını görmek için her 5 dakikada bir pencereyi kontrol edin
  2. Joe kapı zilini çalıncaya kadar işlerini yapmaya devam et.

Seçenek 1: Bu, daha önce Joe'nun dışarıda olup olmadığını kontrol eden Jane'in bir "döngüde" sıkışıp kalmayacağı bir sorgulama örneği gibidir. Jane bu arada başka bir şey yapamaz.

Seçenek 2: Bu geri arama örneğidir. Jane dışarıdayken Joe'ya kapı zilini çalmasını söyler. Ona kapı zilini çalması için bir "işlev" veriyor. Joe'nun kapı zilinin nasıl çalıştığını veya nerede olduğunu bilmesine gerek yok, sadece o işlevi çağırması gerekiyor, yani orada olduğu zaman kapı zilini çalması gerekiyor.

Geri aramalar "olaylar" tarafından yönlendirilir. Bu örnekte "olay" Joe'nun gelişidir. Örneğin, Ajax'ta olaylar asenkron isteğin "başarısı" veya "arızası" olabilir ve her biri aynı veya farklı geri aramalara sahip olabilir.

JavaScript uygulamaları ve geri aramalar açısından. Ayrıca "kapanışları" ve uygulama bağlamını da anlamamız gerekiyor. "Bu" ifadesi, JavaScript geliştiricilerinin kafasını karıştırabilir. Bu örnekte, her kişinin "ring_the_door_bell ()" yöntemi/geri çağırma yönteminde, her kişinin sabah rutini örneğine göre yapması gereken başka yöntemler olabilir. "televizyonu kapat()". "Bunun" "Jane" nesnesine veya "David" nesnesine atıfta bulunmasını isterdik, böylece her biri Joe onları almadan önce ne gerekiyorsa yapabilir. Bu, Joe ile geri çağırma ayarının, "bu" doğru nesneye gönderme yapması için yöntemin parodi edilmesini gerektirdiği yerdir.

Umarım yardımcı olur!

3
Nael El Shawwa

Bence açıklaması kolay bir iş.

İlk başta geri arama sadece sıradan fonksiyonlardır.
Üstelik, bu işlevi başka bir işlevin içinden (hadi A diyelim) olarak adlandırıyoruz (hadi B diyelim).

Bununla ilgili sihir, karar vermemdir ki, hangi işlevi, dış) B işlevinden çağırılmalıdır.

B fonksiyonunu yazdığım sırada hangi geri arama fonksiyonunun çağrılması gerektiğini bilmiyorum. B fonksiyonunu çağırdığımda, bu fonksiyona da A fonksiyonunu çağırmasını söylerim. Hepsi bu.

3
yunzen

Geri Arama İşlevi Nedir?

Bu ilk sorunun basit cevabı, bir geri çağırma işlevinin, bir işlev işaretçisi aracılığıyla çağrılan bir işlev olduğudur. Bir işlevin işaretleyicisini (adresini) diğerine argüman olarak iletirseniz, bu işaretçi işlevi çağırmak için kullanıldığında, onu işaret ettiği zaman geri aramanın yapıldığı söylenir.

Geri arama işlevinin izlenmesi zordur, ancak bazen çok yararlıdır. Özellikle kütüphaneleri tasarlarken. Geri arama işlevi, kullanıcıdan sizden bir işlev adı vermesini istemek gibi bir işlemdir ve bu işlevi belirli bir koşulda arayacaksınız.

Örneğin, bir geri arama sayacı yazarsınız. Süreyi ve hangi işlevi çağıracağınızı belirlemenizi sağlar ve işlev buna göre geri çağırılır. “İşlevimi () her 10 saniyede bir 5 kez çalıştır”

Veya bir işlev dizini oluşturabilir, işlev adının bir listesini iletebilir ve kütüphaneden uygun şekilde geri çağırmasını isteyebilirsiniz. “Başarı durumunda geri arama başarılı (), başarısız olursa geri arama başarısız ().”

Basit bir işaretçi örneğine bakalım

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

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

Argüman geri çağırma işlevine nasıl iletilir?

Geri çağrıyı uygulamak için işlev göstergesinin, boşluk dahilinde * alındığı, bunun yapı dahil her türlü değişkenin alabileceğini gösterir. Bu nedenle yapıya göre birden fazla argüman iletebilirsiniz.

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;   
}
3
Sachin Mhetre

Geri arama, kendi kendine adreslenmiş damgalanmış bir zarftır. Bir işlevi çağırdığınızda, bu bir mektup göndermek gibidir. Bu işlevin başka bir işlevi çağırmasını istiyorsanız, bu bilgiyi başvuru veya adres biçiminde sağlarsınız.

3
pete

“Bilgisayar programlamasında geri çağırma, diğer koda argüman olarak iletilen yürütülebilir koda veya çalıştırılabilir koda yapılan bir referanstır. Bu, daha düşük seviyeli bir yazılım katmanının daha yüksek seviyeli bir katmanda tanımlanan bir alt yordamı (veya işlevi) çağırmasını sağlar. ”- Wikipedia

İşlev İşaretçisi kullanarak C’de geri arama

C de geri çağırma, İşlev İşaretçisi kullanılarak gerçekleştirilir. İşlev İşaretçisi - adından da anlaşılacağı gibi, işleve bir işaretçidir.

Örneğin, int (* ptrFunc) ();

Burada, ptrFunc, argüman almayan ve bir tamsayı döndüren bir fonksiyonun göstergesidir. Parantez içine koymayı ihmal etmeyin, aksi takdirde derleyici, ptrFunc öğesinin hiçbir şey almayan ve bir tamsayı göstericiye döndüren normal bir işlev adı olduğunu varsayar.

İşlev işaretleyicisini göstermek için bazı kodlar.

#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;
}

Şimdi fonksiyon göstergesini kullanarak C'deki Geri Arama kavramını anlamaya çalışalım.

Programın tamamı üç dosyaya sahiptir: callback.c, reg_callback.h ve 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)();                               
}

Bu programı çalıştırırsak, çıktı

Bu, register_callback içindeki geriçağırım fonksiyonunu gösteren, my_callback içindeki ana programın içindeki fonksiyon geri çağırmayı gösteren bir programdır.

Daha yüksek katman işlevi, normal bir çağrı olarak daha düşük bir katman işlevini çağırır ve geri çağırma mekanizması, alt katman işlevinin bir işaretçi aracılığıyla bir geri çağrı işlevine daha yüksek katman işlevini çağırmasını sağlar.

Arayüz Kullanarak Java'da Geri Arama

Java, işlev işaretçisi kavramına sahip değildir Arayüz mekanizması aracılığıyla Geri Çağırma mekanizmasını uygular. Burada işlev işaretçisi yerine, callee görevini tamamladığında çağrılacak bir yöntemi olan bir Arayüz ilan ediyoruz.

Bir örnek ile göstereyim:

Geri Arama Arabirimi

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

Arayan veya Yüksek Seviye Sınıfı

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
}
}

Callee veya alt katman işlevi

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
}
}

EventListener desenini kullanarak geri arama

  • Liste öğesi

Bu desen, 0'dan n'ye kadar sayıda Gözlemci/Dinleyiciye belirli bir görevin bittiğini bildirmek için kullanılır

  • Liste öğesi

Geri arama mekanizması ve EventListener/Observer mekanizması arasındaki fark, geri aramada, arayan kişinin tek arayanı bilgilendirmesidir, oysa Eventlisener/Observer'da arayan kişi bu olayla ilgilenen herkesi haberdar edebilir (bildirim, bazı diğer bölümlere gidebilir). görevi tetiklemeyen uygulama)

Bir örnekle açıklayayım.

Etkinlik Arayüzü

public interface Events {

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

Sınıf Widget'ı

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);
    }
}

Sınıf Düğmesi

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

Sınıf Onay Kutus

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;
}
}

Etkinlik Sınıfı

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

Diğer Sınıf

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

Ana Sınıf

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);
}
}

Yukarıdaki koddan da anlaşılacağı gibi, uygulamamız için gerçekleşebilecek tüm olayları listeleyen olaylar adlı bir arayüze sahibiz. Widget sınıfı, Button, Checkbox gibi tüm UI bileşenleri için temel sınıftır. Bu UI bileşenleri, olayları çerçeve kodundan alan nesnelerdir. Widget sınıfı, Events arabirimini uygular ve ayrıca OnClickEventListener & OnLongClickEventListener adlı iki iç içe arabirime sahiptir

Bu iki arayüz, Button veya Checkbox gibi Widget türetilmiş UI bileşenlerinde meydana gelebilecek olayları dinlemekle sorumludur. Dolayısıyla, bu örneği Java Arayüzü kullanan önceki Geri Çağırma örneğiyle karşılaştırırsak, bu iki arayüz Geri Çağırma arabirimi olarak çalışır. Dolayısıyla daha yüksek seviye kodu (Here Activity) bu iki arayüzü uygular. Bir widget'ta bir olay gerçekleştiğinde ve daha yüksek seviye kodu (veya burada Etkinlik olan yüksek seviye kodunda uygulanan bu arayüzlerin yöntemi) çağrılır.

Şimdi, Callback ve Eventlistener modeli arasındaki temel farkı tartışmama izin verin. Geri Arama'yı kullanarak, Callee'nin yalnızca tek bir Arayanı bilgilendirebileceğini belirttiğimiz gibi. Ancak EventListener modeli durumunda, Uygulamanın herhangi bir kısmı veya sınıfı Düğme veya Onay Kutusunda meydana gelebilecek olaylar için kayıt olabilir. Bu tür bir sınıf örneği, OtherClass'tır. OtherClass kodunu görüyorsanız, Aktivite'de tanımlanan Düğme içinde oluşabilecek ClickEvent'in kendisini dinleyici olarak kaydettiğini göreceksiniz. İlginç olan kısım, Aktivitenin (Arayan) yanı sıra, bu OtherClass'ın, click olayı Düğmede gerçekleştiğinde de bildirileceğidir.

2

Düz ve basit: Geri çağırma, başka bir işleve verdiğiniz bir işlevdir, böylece yapabilsin call onu.

Genellikle bazı işlemler tamamlandığında çağrılır. Diğer işleve vermeden önce geri aramayı oluşturduğunuzdan, onu arama sitesindeki içerik bilgileri ile başlatabilirsiniz. Bu nedenle bir çağrı * geri * olarak adlandırılır - ilk işlev geri çağrıldığı yerden içeriye geri çağırır.

2
Andrei Vajna II

Geri arama, bir koşul gerçekleştiğinde yürütülmesi planlanan bir yöntemdir.

Bir "gerçek dünya" örneği, yerel bir video oyun mağazası. Half-Life 3'ü bekliyorsunuz. İçinde olup olmadığını görmek için her gün mağazaya gitmek yerine, oyun mevcut olduğunda haberdar olmak için e-postanızı bir listeye kaydedersiniz. E-posta "geri aramanız" haline gelir ve karşılanması gereken koşul oyunun kullanılabilirliğidir.

"Programcılar" örneği, bir düğmeye tıklandığında işlem yapmak istediğiniz bir web sayfasıdır. Bir düğme için geri çağırma yöntemini kaydedersiniz ve diğer işleri yapmaya devam edersiniz. Kullanıcı düğmeyi tıklattığında/olursa, tarayıcı bu olayın geri arama listesine bakacak ve yönteminizi arayacaktır.

Geri çağırma, olayları eşzamansız olarak işlemenin bir yoludur. Geri aramanın ne zaman gerçekleştirileceğini veya hiçbir zaman yürütüleceğini asla bilemezsiniz. Bunun avantajı, cevabınızı beklerken diğer görevleri yerine getirmek için program ve CPU döngülerinizi serbest bırakmasıdır.

2
Optimist

[edit] iki fonksiyonumuz olduğunda, functionA ve functionB diyorsa, eğer functionA functionB'ye bağlıdır.

daha sonra functionB adını geri çağırma işlevi olarak adlandırırız.

callback function wikipedia example

1

Bir iş arkadaşınıza görev vermek için bir yöntem düşünün. Basit bir görev aşağıdaki olabilir:

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

İş arkadaşınız matematiği özenle yapar ve aşağıdaki sonucu verir:

x = -6
y = -4

Ancak iş arkadaşınızın bir sorunu var, her zaman ^ gibi notasyonları anlamıyor, ancak açıklamalarıyla anlıyor. exponent gibi. Bunlardan birini bulduğu her zaman, aşağıdakileri geri alırsınız:

I don't understand "^"

Bu, karakterin iş arkadaşınız için ne anlama geldiğini açıkladıktan sonra talimat setinizin tamamını yeniden yazmanızı gerektirir ve sorular arasında her zaman hatırlamaz. Ve bana sadece sormak gibi ipuçlarını hatırlamakta zorlanıyor. Yazılı talimatlarınızı her zaman ancak yapabildiği en iyi şekilde takip eder.

Bir çözüm düşünürseniz, tüm talimatlarınıza sadece aşağıdakileri eklersiniz:

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

Şimdi bir sorunu olduğunda, size kötü bir cevap vermek ve süreci yeniden başlatmak yerine, sizi arar ve sorar.

1
Guvante

Geri aramalar, kendi kodunuzu, başka bir zamanda yürütülecek başka bir kod bloğuna eklemenizi sağlar; bu, gereksiniminize uyacak şekilde diğer kod bloğunun davranışını değiştirir veya buna ekler. Daha fazla bakım gerektirebilir kod sahibi olurken esneklik ve özelleştirilebilirlik kazanırsınız.

Daha az hardcode = bakımı ve değişimi kolay = daha az zaman = daha fazla işletme değeri = uygunsuzluk.

Örneğin, javascript'te Underscore.js kullanarak, aşağıdaki gibi bir dizideki tüm öğeleri bulabilirsiniz:

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

Underscore.js izniyle örnek: http://documentcloud.github.com/underscore/#filter

1
letuboy

Geri arama işlevleri:

callback adında bir callback function tanımlarız, ona otherFunction parametresini verir ve onu işlev gövdesinin içine çağırırız.

function callback(otherFunction){
    otherFunction();
}

callback işlevini çağırdığımızda, function türünün bir argümanını bekler, bu yüzden onu adsız bir işlevle çağırırız. Ancak, eğer argüman function tipinde değilse bir hata üretir.

callback(function(){console.log('SUCCESS!')}); 
callback(1); // error

Pizza örneğini pişirme. malzemelerle tepesinde pizza tabanı pişirmek için fırın Şimdi burada, ovencallback function. ve pizza base with ingredientsotherFunction 'dir.

Dikkat edilmesi gereken nokta farklı pizza malzemelerinin farklı türde pizzalar ürettiği, ancak fırının hangi fırında aynı kalır. Bu, biraz farklı kişisel sonuçlar üretmek için farklı işlevlere sahip işlevleri beklemeye devam eden bir callback function 'un işidir.

0
Sagar Munjal

Bir web sayfası indirme açısından bu:

Programınız bir cep telefonunda çalışıyor ve web sayfasını istiyor http://www.google.com . Programınızı eşzamanlı olarak yazarsanız, verileri indirmek için yazdığınız işlev tüm veriler indirilinceye kadar sürekli çalışacaktır. Bu, kullanıcı arayüzünüzün yenilenmeyeceği ve temelde donmuş görüneceği anlamına gelir. Programınızı geri çağrılar kullanarak yazıyorsanız, veri talebinde bulunursunuz ve "işiniz bittiğinde bu işlevi yürütün" diyorsunuz. Bu, dosya indirilirken kullanıcı arayüzünün kullanıcı etkileşimine hala izin vermesini sağlar. Web sayfasının indirilmesi bittiğinde, sonuç fonksiyonunuz (geri arama) çağrılır ve verileri kullanabilirsiniz.

Temel olarak, bir şey istemenizi ve sonucu beklerken çalışmaya devam etmenizi sağlar. Sonuç bir geri arama işlevi aracılığıyla size döndüğünde, kaldığı yerden işlemi başlatabilirsiniz.

0
sokket