Jak wyjaśnić wywołania zwrotne w prostym języku angielskim? Czym się różnią od wywołania jednej funkcji z innej funkcji?

Postaram się, żeby to było proste. "Callback" to każda funkcja, która jest wywoływana przez inną funkcję, która przyjmuje pierwszą funkcję jako parametr. Często "callback" jest funkcją, która jest wywoływana, gdy coś się dzieje. To coś można nazwać "wydarzeniem" w języku programistycznym.

Wyobraź sobie ten scenariusz: spodziewasz się paczki za kilka dni. Paczka jest prezentem dla bliźniego. Dlatego po otrzymaniu paczki chcesz to przyszło do sąsiadów. Jesteś poza miastem, więc zostawiasz instrukcje dla współmałżonka.

W naszym przykładzie, otrzymanie pakietu to "zdarzenie", a przekazanie go sąsiadom to "callback". Twój współmałżonek "wykonuje" twoje instrukcje, aby przynieść paczkę tylko , Gdy paczka dotrze. O wiele lepiej!

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

Tutaj czekamy na otwarcie pliku, zanim do niego napiszemy. To "blokuje" przepływ wykonania, a nasz program nie może zrobić żadnej z innych rzeczy, które może potrzebować! Co jeśli moglibyśmy zrobić to zamiast tego:

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

Okazuje się, że robimy to z niektórymi językami i frameworkami. To jest całkiem fajne! Sprawdź węzeł.js aby zdobyć trochę prawdziwej praktyki z tego rodzaju myślenia.

Jak wyjaśnić wywołania zwrotne po angielsku?

W prostym języku angielskim funkcja wywołania zwrotnego jest podobna do pracownika, który "oddzwania" do swojego Menedżera Po wykonaniu zadania .

Czym się różnią od wywoływania jednej funkcji z innej funkcji wzięcie kontekstu z funkcji wywołującej?

To prawda, że wywołujesz funkcję z innej funkcji, ale kluczem jest to, że wywołanie zwrotne jest traktowany jak Obiekt, dzięki czemu można zmieniać funkcję do wywołania w zależności od stanu systemu(np. wzorzec projektowania strategii).

Jak można wytłumaczyć ich moc początkującemu programiście?

Moc wywołań zwrotnych można łatwo zobaczyć w witrynach w stylu AJAX, które muszą pobierać dane z serwera. Pobieranie nowych danych może zająć trochę czasu. Bez wywołań zwrotnych cały interfejs użytkownika "zamrozi się" podczas pobierania nowych danych lub będziesz musiał odśwież całą stronę, a nie tylko jej część. Dzięki funkcji zwrotnej możesz wstawić obraz "teraz ładowanie" i zastąpić go nowymi danymi po załadowaniu.

Jakiś kod bez wywołania zwrotnego:

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

Z Wywołaniem Zwrotnym:

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
}

Z Zamknięciem:

Często wywołanie zwrotne musi uzyskać dostęp state z funkcji wywołującej za pomocą closure, która jest podobna do Worker, który musi uzyskaj informacje od menedżera , zanim będzie mógł wykonać swoje zadanie. Aby utworzyć closure, możesz wstawić funkcję tak, aby widziała ona dane w kontekście wywołania:

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

Użycie:

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

Zamknięcie

Wreszcie, oto definicja closure z Douglas Crockford :

funkcje mogą być zdefiniowane wewnątrz innych funkcji. Funkcja wewnętrzna ma dostęp do var i parametrów funkcji zewnętrznej. Jeśli odniesienie do wewnętrzna funkcja przetrwa (na przykład jako funkcja zwrotna), zewnętrzne var funkcji również przetrwać.

Zobacz też:

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

Jestem oszołomiony, widząc tak wielu inteligentnych ludzi, którzy nie podkreślają rzeczywistości, że słowo "callback" stało się używane na dwa niespójne sposoby.

Oba sposoby wymagają dostosowania funkcji poprzez przekazanie dodatkowej funkcjonalności (definicji funkcji, anonimowej lub nazwanej) do istniejącej funkcji. ie.

customizableFunc(customFunctionality)

Jeśli funkcja niestandardowa jest po prostu podłączona do bloku kodu, dostosowałeś tę funkcję, w ten sposób.

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

Choć ten rodzaj injected funkcjonalność jest często nazywany "callback", nie ma w tym nic warunkowego. Bardzo oczywistym przykładem jest metoda forEach, w której funkcja niestandardowa jest dostarczana jako argument do zastosowania do każdego elementu tablicy w celu modyfikacji tablicy.

Użycie asynchroniczne z natury polega na nasłuchiwaniu żądanego zdarzenia (np. zakończenia procesu wejścia / wyjścia) tak, że gdy to nastąpi (i tylko wtedy, gdy nastąpi), wykonywana jest niestandardowa funkcja "callback". W oczywistym przykładzie AJAX, gdy dane rzeczywiście przybywa z serwera, funkcja" callback " jest wyzwalana, aby użyć tych danych do modyfikacji DOM i dlatego przerysować okno przeglądarki do tego stopnia.

To podsumowanie. Niektórzy ludzie używają słowa "callback", aby odnieść się do wszelkiego rodzaju niestandardowych funkcji, które mogą być wstrzykiwane do istniejącej funkcji jako argument. Ale, przynajmniej dla mnie, najbardziej odpowiednie użycie tego słowa Jest tam, gdzie wstrzykiwana funkcja "callback" jest używana asynchronicznie - do wykonania tylko po wystąpieniu zdarzenia, które czeka na powiadomienie.

W terminach innych niż programista, callback jest wypełnieniem-in-the-blank w programie.

• każdy dostaje taką samą pustą formę, ale
• każdy może napisać inny numer kontaktowy.

Przykład 1:

Wywołania zwrotne są używane jako niestandardowe metody, ewentualnie do dodawania / zmiany zachowania programu. Na przykład, weźmy jakiś kod C, który wykonuje funkcję, ale nie wie, jak wydrukować wyjście. Wszystko, co może zrobić, to zrobić sznurek. Kiedy próbuje dowiedzieć się, co zrobić ze sznurkiem, widzi pustą linię. Ale programista dał ci puste pole do napisz swoją odpowiedź zwrotną!

W tym przykładzie nie używasz ołówka do wypełnienia pustego arkusza papieru, używasz funkcji set_print_callback(the_callback).

• pustą zmienną w module / kodzie jest pusta linia,
• set_print_callback jest ołówkiem,
• i the_callback to Twoje informacje, które wypełniasz.

Wypełniłeś teraz tę pustą linię w programie. Za każdym razem, gdy musi wydrukować wyjście, będzie patrzeć na tę pustą linię I postępować zgodnie z instrukcjami (tj. wywołaj funkcję, którą tam umieściłeś.) Praktycznie pozwala to na drukowanie na ekranie, do pliku dziennika, do drukarki, przez połączenie sieciowe lub dowolną ich kombinację. Wypełniłeś puste pole tym, co chcesz zrobić.

Przykład 2:

Kiedy powiedziano ci, że musisz zadzwonić pod numer alarmowy, idź i przeczytaj to, co jest napisane w papierowym formularzu, a następnie zadzwoń pod numer, który przeczytałeś. Jeśli ta linia jest pusta, nic nie zostanie zrobione.

Programowanie Gui działa tak samo. Po kliknięciu przycisku program musi dowiedzieć się, co robić dalej. Idzie i szuka odpowiedzi. To wywołanie zwrotne dzieje się w pustym oznaczonym "oto, co robisz, gdy Button1 jest kliknięty"

Większość IDE automatycznie wypełni puste pole (napisz podstawową metodę), gdy o to poprosisz (np. button1_clicked). Jednak ten blank może mieć dowolną metodę, którą dobrze sobie życzysz. Możesz wywołać metodę run_computations lub butter_the_biscuits, o ile umieścisz to nazwisko oddzwonienia w odpowiedniej pustce. Możesz wpisać" 555-555-1212 " w pustym numerze alarmowym. To nie ma sensu, ale jest dopuszczalne.

Ostatnia uwaga: ta pusta linia, którą wypełniasz przy oddzwanianiu? Może być wymazana i przepisana do woli.To, czy powinieneś, czy nie, to kolejne pytanie, ale to część ich mocy.]}

Johny programista potrzebuje zszywacza, więc idzie do działu zaopatrzenia biurowego i prosi o taki, Po wypełnieniu formularza może albo stać i czekać, aż Urzędnik rozejrzy się po magazynie w poszukiwaniu zszywacza (jak wywołanie funkcji blokującej) lub zrobić coś innego w międzyczasie.

Ponieważ zwykle wymaga to czasu, johny umieszcza notatkę wraz z formularzem z prośbą, aby zadzwonić do niego, gdy zszywacz jest gotowy do odbioru, więc w międzyczasie może pójść zrobić coś innego jak drzemanie na biurku.

Zawsze lepiej zacząć od przykładu :).

Załóżmy, że masz dwa moduły A i B.

Chcesz, aby moduł A był powiadamiany, gdy jakieś zdarzenie/warunek wystąpi w module B. Jednak moduł B nie ma pojęcia o Twoim module A. wszystko, co wie, to adres do konkretnej funkcji (modułu a) za pomocą wskaźnika funkcji dostarczanego mu przez moduł A.

Więc wszystko, co B musi teraz zrobić, to "callback" do modułu A, gdy określone zdarzenie / warunek występuje przez korzystanie ze wskaźnika funkcji. A może zrobić dalsze przetwarzanie wewnątrz funkcji zwrotnej.

*) wyraźną zaletą jest to, że wyodrębniasz wszystko o module a z modułu B. moduł B nie musi przejmować się kim/czym jest moduł A.

Wyobraź sobie, że potrzebujesz funkcji, która zwraca 10 do kwadratu, więc napisz funkcję:

function tenSquared() {return 10*10;}

Później potrzebujesz 9 do kwadratu, więc napisz inną funkcję:

function nineSquared() {return 9*9;}

W końcu zamienisz wszystkie z nich na ogólną funkcję:

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

Dokładnie to samo myślenie dotyczy wywołań zwrotnych. Masz funkcję, która coś robi i po zakończeniu wywołuje doA:

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

Później chcesz, aby ta sama funkcja wywołała doB, zamiast tego możesz powielić całą funkcja:

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

Lub możesz przekazać funkcję zwrotną jako zmienną i tylko raz mieć tę funkcję:

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

Następnie wystarczy wywołać compute(DOA) i compute (doB).

Poza uproszczeniem kodu, pozwala kodowi asynchronicznemu informować, że zakończył się, wywołując dowolną funkcję po zakończeniu, podobnie jak gdy dzwonisz do kogoś przez telefon i zostawiasz numer oddzwaniający.

Źle się czujesz, więc idź do lekarza. Bada cię i stwierdza, że potrzebujesz leków. Przepisuje leki i dzwoni do twojej lokalnej apteki. Idź do domu. Później dzwoni Apteka, aby powiedzieć, że recepta jest gotowa. Idź i odbierz.

Są dwa punkty do wyjaśnienia, jeden jest jak callback działa (przekazywanie wokół funkcji, które mogą być wywołane bez żadnej wiedzy o jej kontekście), drugi to, co jest używane do (obsługa zdarzeń asynchronicznie).

Analogia oczekiwania na dotarcie paczki, która została wykorzystana przez inne odpowiedzi, jest dobra do wyjaśnienia obu. W programie komputerowym można powiedzieć komputerowi, aby oczekiwał paczki. Normalnie siedziałby tam i czekał (i nic innego nie robił) aż paczka przybywa, być może w nieskończoność, jeśli nigdy nie przybywa. Dla ludzi brzmi to głupio, ale bez dalszych środków jest to całkowicie naturalne dla komputera.

Wyobraź sobie, że przyjaciółka wychodzi z twojego domu, a ty mówisz jej "zadzwoń do mnie, Gdy wrócisz do domu, żebym wiedział, że bezpiecznie dotarłeś"; to jest (dosłownie) Oddzwoń . Na tym polega funkcja zwrotna, niezależnie od języka. Chcesz, aby jakaś procedura przeszła kontrolę z powrotem do ciebie, gdy zakończy jakieś zadanie, więc dajesz mu funkcję, której możesz użyć, aby oddzwonić do ciebie.

W Pythonie, na przykład,

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

grabDBValue można zapisać tylko po to, aby pobrać wartość z bazy danych, a następnie niech określa się, co ma rzeczywiście zrobić z wartością, więc przyjmuje ona funkcję. Nie wiesz, kiedy i czy grabDBValue powróci, ale jeśli/kiedy to nastąpi, wiesz, co chcesz, aby to zrobić. Tutaj przekazuję anonimową funkcję (lub lambda ), która wysyła wartość do okna GUI. Mogę łatwo zmienić zachowanie programu, robiąc to:

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

Wywołania zwrotne działają dobrze w językach, w których funkcje są wartościami pierwszej klasy , podobnie jak zwykłe liczby całkowite, ciągi znaków, booleany, itd. W języku C można" przekazać " funkcję, przekazując do niej wskaźnik i wywołujący może jej użyć; w Javie wywołujący poprosi o statyczną klasę określonego typu z określoną nazwą metody, ponieważ nie ma funkcji ("metod", tak naprawdę) poza klasami; a w większości innych języków dynamicznych można po prostu przekazać funkcję o prostej składni.

Protip:

W językach z Zakres leksykalny (Jak Scheme lub Perl) można wyciągnąć trick jak to:

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

$val w tym przypadku będzie to 6, ponieważ wywołanie zwrotne ma dostęp do zmiennych zadeklarowanych w środowisku leksykalnym, w którym zostało zdefiniowane. Zakres leksykalny i anonimowe wywołania zwrotne to potężne połączenie, które gwarantuje dalsze badania dla początkującego programisty.

Masz jakiś kod, który chcesz uruchomić. Zwykle po wywołaniu go czekasz na jego zakończenie przed kontynuowaniem (co może spowodować, że aplikacja stanie się szara/wytworzy czas obracania kursora).

Alternatywną metodą jest równoległe uruchamianie tego kodu i kontynuowanie własnej pracy. Ale co jeśli twój oryginalny kod musi robić różne rzeczy w zależności od odpowiedzi z kodu, który wywołał? Cóż, w takim przypadku możesz podać nazwę / lokalizację kodu, który chcesz zadzwoń, gdy będzie po wszystkim. To jest "Oddzwoń".

Normalny kod: zapytaj o informacje- > Informacje o przetwarzaniu->radź sobie z wynikami przetwarzania - > Kontynuuj inne czynności.

Z wywołaniami zwrotnymi: zapytaj o informacje->Informacje o przetwarzaniu- > Kontynuuj inne czynności. I w pewnym późniejszym momencie - > radzić sobie z wynikami przetwarzania.

Bez wywołania zwrotnego ani innych specjalnych zasobów programistycznych (takich jak wątki i inne), program jest dokładnie sekwencją instrukcji, które są wykonywane kolejno jedna po drugiej, i nawet przy pewnego rodzaju "dynamicznym zachowaniu" określonym przez pewne warunki, wszystkie możliwe scenariusze powinny być wcześniej zaprogramowane.

Tak więc, jeśli musimy zapewnić prawdziwe dynamiczne zachowanie do programu możemy użyć callback. Z callback można instruować przez parametry, a program do wywoływania innego programu dostarczającego określone wcześniej parametry i może oczekiwać pewnych wyników ( jest to podpis umowy lub operacji ), więc wyniki te mogą być wytwarzane / przetwarzane przez inny program, który nie był wcześniej znany.

Technika ta jest podstawą polimorfizmu stosowanego do programów, funkcji, obiektów i wszystkich innych jednostek kodu uruchamianych przez komputery.

Ludzki świat używany jako przykład do oddzwaniania jest ładnie wyjaśnione kiedy wykonujesz jakąś pracę, Załóżmy, że jesteś malarzem (Tutaj jesteś głównym programem, który maluje ) i czasami zadzwoń do klienta, aby poprosić go o zatwierdzenie wyniku pracy, więc on decyduje, czy obraz jest dobry (twój Klient jest programem trzeciej strony).

W powyższym przykładzie jesteś malarzem i "delegujesz" innym zadanie do zatwierdzenia wyniku, obraz jest parametrem, a każdy nowy klient (wywołana "funkcja") zmienia wynik twojej pracy decydując, co chce o obrazie ( decyzja podjęta przez klientów są zwracane wynik z "funkcji callback" ).

Mam nadzieję, że to wyjaśnienie może być przydatne.

Udawajmy, że dałaś mi potencjalnie długotrwałe zadanie: zdobądź nazwiska pierwszych pięciu unikalnych osób, które napotkasz. To może potrwać kilka dni, jeśli jestem w słabo zaludnionym obszarze. Nie jesteś zainteresowany siedzeniem na rękach, kiedy ja biegam, więc mówisz: "kiedy będziesz miał listę, zadzwoń do mnie na komórkę i Przeczytaj mi ją. Oto numer.".

Dałeś mi referencję zwrotną -- funkcję, którą powinienem wykonać, aby przekazać dalej przetwarzam.

W JavaScript może to wyglądać mniej więcej tak:

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

To prawdopodobnie można poprawić na wiele sposobów. Na przykład, można zapewnić drugi callback: jeśli kończy się to trwa dłużej niż godzinę, zadzwoń na czerwony telefon i powiedzieć osobie, która odpowiada, że masz czas.

połączenia zwrotne najłatwiej opisać w kategoriach systemu telefonicznego. Wywołanie funkcji jest analogiczne do wywołania kogoś przez telefon, zadając jej pytanie, otrzymując odpowiedź i odkładając słuchawkę; dodanie wywołania zwrotnego zmienia analogię tak, że po zadaniu jej pytania, możesz również podać jej swoje imię i numer, aby mogła oddzwonić z odpowiedzią. -- Paweł Jakubik , "Implementacje Callback w C++"

Wywołanie zwrotne jest funkcją, która zostanie wywołana przez drugą funkcję. Ta druga funkcja nie wie z góry, jaką funkcję wywoła. Tak więc tożsamość funkcji zwrotnej jest gdzieś przechowywana lub przekazywana do drugiej funkcji jako parametr. Ta "tożsamość", w zależności od języka programowania, może być adresem wywołania zwrotnego, lub innym rodzajem wskaźnika, lub może to być nazwa funkcji. Zleceniodawca jest taki sam, przechowujemy lub przekazujemy pewne informacje to jednoznacznie identyfikuje funkcję.

Gdy nadejdzie czas, druga funkcja może wywołać callback, dostarczając parametry w zależności od okoliczności w tym momencie. Może nawet wybrać callback z zestawu możliwych połączeń zwrotnych. Język programowania musi zapewnić pewien rodzaj składni, aby druga funkcja mogła wywołać callback, znając jego " tożsamość."

Ten mechanizm ma bardzo wiele możliwych zastosowań. Za pomocą wywołań zwrotnych projektant funkcji może niech to być dostosowane przez to wywołanie niezależnie od połączeń zwrotnych są dostarczane. Na przykład, funkcja sortowania może przyjmować callback jako parametr, a to callback może być funkcją porównywania dwóch elementów, aby zdecydować, który z nich jest pierwszy.

Nawiasem mówiąc, w zależności od języka programowania, słowo "function" w powyższej dyskusji może zostać zastąpione przez "block"," closure"," lambda " itp.

Zazwyczaj wysyłamy zmienne do funkcji . Załóżmy, że masz zadanie, w którym zmienna musi zostać przetworzona przed podaniem jej jako argumentu - możesz użyć funkcji callback .

function1(var1, var2) tak jak zwykle .

Co jeśli chcę, aby var2 zostały przetworzone, a następnie wysłane jako argument? function1(var1, function2(var2))

Jest to jeden z typów wywołania zwrotnego - gdzie function2 wykonuje jakiś kod i zwraca zmienną z powrotem do początkowej funkcji .

Metaforyczne Wyjaśnienie:

Mam paczkę, którą chcę dostarczyć znajomemu, i chcę też wiedzieć, kiedy mój znajomy ją otrzyma.

Więc zabieram paczkę na pocztę i proszę o jej dostarczenie. Jeśli chcę wiedzieć, kiedy mój znajomy otrzyma paczkę, mam dwie opcje:

(a) mogę poczekać na poczcie, aż zostanie dostarczony.

(b) otrzymam e-mail, gdy zostanie dostarczony.

Opcja (b) jest analogiczna do wywołania zwrotnego.

Aby uczyć wywołań zwrotnych, musisz najpierw nauczyć wskaźnik. Gdy uczniowie zrozumieją ideę wskaźnika do zmiennej, idea wywołań zwrotnych stanie się łatwiejsza. Zakładając, że używasz C / c++, te kroki można wykonać.

• najpierw pokaż uczniom, jak używać i manipulować zmiennymi za pomocą wskaźników obok zwykłych identyfikatorów zmiennych.
• następnie naucz ich, że są rzeczy, które można zrobić tylko za pomocą wskaźników(jak przekazanie zmiennej przez reference).
• następnie powiedz im, jak wykonywalny kod lub funkcje są tak samo jak niektóre inne dane (lub zmienne) w pamięci. Tak więc funkcje mają również adresy lub wskaźniki.
• następnie pokaż im, jak funkcje mogą być wywoływane za pomocą wskaźników funkcji i powiedz, że są to wywołania zwrotne.
Pytanie brzmi, po co te wszystkie problemy z wywołaniem niektórych funkcji? Jakie są korzyści? Podobnie jak wskaźniki danych, wskaźnik funkcji aka wywołania zwrotne ma pewne zalety w porównaniu z używaniem normalnego identyfikatory.
• pierwszym z nich jest to, że identyfikatory funkcji lub nazwy funkcji nie mogą być używane jako zwykłe dane. Chodzi mi o to, że nie można utworzyć struktury danych z funkcjami (jak tablica lub powiązana lista funkcji). Ale za pomocą wywołań zwrotnych możesz utworzyć tablicę, listę połączoną lub użyć ich z innymi danymi, takimi jak w słowniku par klucz-wartość lub drzewach, lub dowolnymi innymi rzeczami. Jest to potężna korzyść. I inne korzyści są rzeczywiście dziecko tego jednego.
• najczęstsze użycie wywołań zwrotnych jest widoczne w programowaniu sterowników zdarzeń. Gdzie jedna lub więcej funkcji jest wykonywana na podstawie jakiegoś sygnału przychodzącego. W przypadku wywołań zwrotnych słownik może być utrzymywany w celu mapowania sygnałów za pomocą wywołań zwrotnych. Wtedy rozdzielczość sygnału wejściowego i wykonanie odpowiedniego kodu stają się znacznie łatwiejsze.
Drugie użycie wywołań zwrotnych, które przychodzą mi do głowy, to funkcje wyższego rzędu. Funkcje, które przyjmują inne funkcje jako argumenty wejściowe. Aby wysłać funkcje jako argumenty, potrzebujemy wywołań zwrotnych. Przykładem może być funkcja które biorą tablicę i oddzwanianie. Następnie wykonuje wywołanie zwrotne na każdej pozycji tablicy i zwraca wyniki w innej tablicy. Jeśli przekażemy funkcji podwojenie wywołania zwrotnego, otrzymamy tablicę o podwojonej wartości. Jeśli przechodzimy przez kwadraty, otrzymujemy kwadraty. W przypadku korzeni kwadratowych wystarczy wysłać odpowiednie połączenie zwrotne. Nie można tego zrobić przy normalnych funkcjach.

Może być wiele innych rzeczy. Zaangażuj uczniów, a oni odkryją. Mam nadzieję, że to pomoże.

W prostym języku angielskim wywołanie zwrotne jest obietnicą. Joe, Jane, David i Samantha podwożą się do pracy. Joe dziś prowadzi. Jane, David i Samantha mają kilka opcji:

1. sprawdzaj okno co 5 minut, aby zobaczyć, czy Joe jest poza
Rób swoje, dopóki Joe nie zadzwoni.

Opcja 1: jest to bardziej jak przykład sondażu, w którym Jane utknęłaby w "pętli" sprawdzając, czy Joe jest na zewnątrz. Jane nie może zrobić nic innego w średnim czas.

Opcja 2: to jest przykład wywołania zwrotnego. Jane mówi Joe, aby zadzwonił do jej drzwi, kiedy jest na zewnątrz. Daje mu "funkcję" dzwonienia dzwonkiem do drzwi. Joe nie musi wiedzieć, jak działa dzwonek Do Drzwi ani gdzie jest, po prostu musi wywołać tę funkcję, tj. zadzwonić dzwonkiem do drzwi, gdy tam jest.

Wywołania zwrotne są napędzane przez "zdarzenia". W tym przykładzie "wydarzeniem" jest przybycie Joe. W Ajaxie na przykład zdarzenia mogą być "sukcesem" lub "porażką" żądania asynchronicznego i każde z nich może mieć te same lub różne wywołania zwrotne.

W zakresie aplikacji JavaScript i wywołań zwrotnych. Musimy również zrozumieć "zamknięcia" i kontekst aplikacji. To, do czego odnosi się "to", może łatwo zdezorientować programistów JavaScript. W tym przykładzie wewnątrz każdej osoby" ring_the_door_bell () " metoda / callback może być kilka innych metod, które każda osoba musi zrobić na podstawie ich porannej rutyny ex. "turn_off_the_tv ()". Chcielibyśmy, aby "to" odnosiło się do obiektu "Jane" lub obiektu "David", aby każdy może ustawić wszystko, co trzeba zrobić, zanim Joe je odbierze. To jest, gdzie konfigurowanie callback z Joe wymaga parodiowania metody tak ,że " to " odnosi się do właściwego obiektu.

Mam nadzieję, że to pomoże!

Wywołanie zwrotne to zaadresowana do siebie koperta stemplowana. Wywołanie funkcji jest jak wysłanie listu. Jeśli chcesz, aby ta funkcja wywoływała inną funkcję, podaj tę informację w formie referencji lub adresu.

Myślę, że to dość łatwe zadanie do wyjaśnienia.

Na początku callback to zwykłe funkcje.
I dalej jest, że nazywamy tę funkcję (nazwijmy ją A) z wewnątrz innej funkcji (nazwijmy ją B).

Magia polega na tym, że ja decyduję, która funkcja powinna być wywołana przez funkcję z z zewnątrz B.

W czasie pisania funkcji B Nie wiem, która funkcja callback powinna być wywołana. W czasie wywołania funkcji B I również powiedz tej funkcji, aby wywołać funkcję A. to wszystko.

Co To jest funkcja Callback?

Prosta odpowiedź na to pierwsze pytanie jest taka, że funkcja zwrotna jest funkcją wywoływaną przez wskaźnik funkcji. Jeśli przekazujesz wskaźnik (adres) funkcji jako argument do innego, gdy wskaźnik ten jest używany do wywołania funkcji, do której wskazuje, mówi się, że wywołanie zwrotne jest wykonywane.

Funkcja zwrotna jest trudna do wyśledzenia, ale czasami jest bardzo przydatna. Zwłaszcza, gdy projektujesz biblioteki. Funkcja Callback to jak poproszenie użytkownika o podanie nazwy funkcji i wywołanie tej funkcji pod pewnymi warunkami.

Na przykład piszesz timer wywołania zwrotnego. To pozwala określić czas trwania i jaką funkcję do wywołania, a funkcja będzie callback odpowiednio. "Uruchom mojafunkcję() co 10 sekund przez 5 razy"

Lub możesz utworzyć katalog funkcji, przekazując listę nazw funkcji i poprosić bibliotekę o odpowiednie wywołanie zwrotne. "Callback success () if success, callback fail () jeśli się nie powiodło."

Spójrzmy na prosty przykład wskaźnika funkcji

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

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

Jak przekazać argument do funkcji callback?

Obserwowałem, że wskaźnik funkcji do implementacji odbioru zwrotnego przyjmuje w void *, co wskazuje, że może przyjmować dowolne typy zmiennych łącznie ze strukturą. Dlatego możesz przekazać wiele argumentów według struktury.

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

Wywołanie zwrotne jest metodą, która jest zaplanowana do wykonania po spełnieniu warunku.

Przykładem "prawdziwego świata" jest lokalny sklep z grami wideo. Czekasz na Half-Life 3. Zamiast codziennie chodzić do sklepu, aby sprawdzić, czy gra jest dostępna, rejestrujesz swój adres e-mail na liście, aby otrzymywać powiadomienia o dostępności gry. Wiadomość e-mail staje się Twoim "oddzwonieniem", a warunkiem, który należy spełnić, jest dostępność gry.

Przykład "programistów" to strona, na której chcesz wykonać akcję po kliknięciu przycisku. Rejestrujesz metodę wywołania zwrotnego dla przycisku i kontynuujesz wykonywanie innych zadań. Gdy / jeśli użytkownik naciśnie przycisk, przeglądarka spojrzy na listę wywołań zwrotnych dla tego zdarzenia i wywoła Twoją metodę.

Wywołanie zwrotne jest sposobem asynchronicznie obsługiwać zdarzenia. Nigdy nie wiadomo, kiedy wywołanie zwrotne zostanie wykonane lub czy w ogóle zostanie wykonane. Zaletą jest to, że uwalnia Twój program i cykle procesora do wykonywania innych zadań podczas oczekiwania na odpowiedź.

Prosty i prosty: wywołanie zwrotne jest funkcją, którą można przekazać innej funkcji, tak aby mogła ona wywołać ją.

Zwykle jest wywoływany, gdy jakaś operacja jest zakończona. Ponieważ tworzysz callback przed przekazaniem go do innej funkcji, możesz zainicjować go informacjami kontekstowymi z witryny połączeń. Dlatego nazywa się call * back* - pierwsza funkcja woła z powrotem do kontekstu, z którego została wywołana.

"w programowaniu komputerowym wywołanie zwrotne jest odniesieniem do kodu wykonywalnego lub kawałka kodu wykonywalnego, który jest przekazywany jako argument do innego kodu. Pozwala to warstwie oprogramowania niższego poziomu na wywołanie podprogramu (lub funkcji) zdefiniowanego w warstwie wyższego poziomu."- Wikipedia

Wywołanie zwrotne w C za pomocą wskaźnika funkcji

W C, callback jest zaimplementowany za pomocą wskaźnika funkcji. Function Pointer-jak sama nazwa wskazuje, jest wskaźnikiem do funkcji.

Dla przykład: int (*ptrFunc) ();

Tutaj ptrFunc jest wskaźnikiem do funkcji, która nie pobiera argumentów i zwraca liczbę całkowitą. Nie zapomnij umieścić w nawiasie, w przeciwnym razie kompilator założy, że ptrFunc jest normalną nazwą funkcji, która nic nie bierze i zwraca wskaźnik do liczby całkowitej.

Oto kod do zademonstrowania wskaźnika funkcji.

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

Teraz spróbujmy zrozumieć pojęcie Callback w C za pomocą wskaźnika funkcji.

The kompletny program posiada trzy pliki: callback.c, reg_callback.h i 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)();                               
}

Jeśli uruchomimy ten program, wyjściem będzie

Jest to program demonstrujący funkcję callback inside register_callback inside my_callback back inside main program

Funkcja warstwy wyższej wywołuje funkcję warstwy dolnej jako normalne wywołanie, a mechanizm wywołania zwrotnego pozwala funkcji warstwy dolnej wywołać funkcję warstwy wyższej za pomocą wskaźnika do wywołania zwrotnego funkcja.

Wywołanie zwrotne w Javie za pomocą interfejsu

Java nie ma pojęcia wskaźnika funkcji Implementuje Mechanizm Callback poprzez mechanizm interfejsu W tym miejscu zamiast wskaźnika funkcji deklarujemy interfejs posiadający metodę, która zostanie wywołana, gdy callee zakończy swoje zadanie

Pozwól, że zademonstruję to na przykładzie:

Interfejs Wywołania Zwrotnego

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

Rozmówca lub wyższy poziom Klasa

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 lub funkcja dolnej warstwy

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

Wywołanie zwrotne za pomocą wzorca EventListener

• pozycja listy

Ten wzorzec jest używany do powiadamiania 0 do n liczb obserwatorów / słuchaczy o zakończeniu danego zadania

• pozycja listy

Różnica między mechanizmem Callback a mechanizmem EventListener / Observer polega na tym, że w callback, callee powiadamia pojedynczego dzwoniącego, podczas gdy w Eventlisener / Observer, callee może powiadomić każdego, kto jest zainteresowany tym zdarzeniem (powiadomienie może przejść do innych części aplikacji, które nie uruchomiły zadania)

Interfejs Zdarzeń

public interface Events {

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

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

Class Button

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

Class Checkbox

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

Klasa Aktywności

Pakiet com.som_itsolutions.trening.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();
    }   
}

Inna Klasa

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

Klasa Główna

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

Jak widać z powyższego kodu, mamy interfejs o nazwie events, który w zasadzie wymienia wszystkie zdarzenia, które mogą wystąpić w naszej aplikacji. Klasa Widget jest klasą bazową dla wszystkich elementów interfejsu, takich jak przycisk, Checkbox. Te komponenty interfejsu użytkownika są obiektami, które faktycznie otrzymują zdarzenia z kodu frameworka. Klasa Widget implementuje interfejs zdarzeń, a także ma dwa zagnieżdżone interfejsy mianowicie OnClickEventListener & OnLongClickEventListener

Te dwa interfejsy są odpowiedzialne za nasłuchiwanie zdarzeń, które mogą wystąpić w elementach interfejsu, takich jak przycisk lub Checkbox. Jeśli więc porównamy ten przykład z wcześniejszym przykładem wywołania zwrotnego przy użyciu interfejsu Java, te dwa interfejsy działają jako interfejs wywołania zwrotnego. Więc kod wyższego poziomu (tutaj Activity) implementuje te dwa interfejsy. I za każdym razem, gdy wystąpi zdarzenie do widżetu, kod wyższego poziomu (lub metoda tych interfejsów zaimplementowanych w kodzie wyższego poziomu, który jest tutaj Activity) zostanie wywołany.

Teraz pozwól mi omówić podstawową różnicę między Callback i Eventlistener wzór. Jak już wspomnieliśmy, za pomocą Callback, Callee może powiadomić tylko jednego rozmówcę. Ale w przypadku wzorca EventListener, każda inna część lub klasa aplikacji może zarejestrować zdarzenia, które mogą występuje na przycisku lub polu wyboru. Przykładem tego rodzaju klasy jest OtherClass. Jeśli zobaczysz kod OtherClass, okaże się, że zarejestrował się jako słuchacz do ClickEvent, który może wystąpić w przycisku zdefiniowanym w ćwiczeniu. Ciekawostką jest to, że oprócz aktywności (rozmówcy), ta Innaklasa będzie również powiadamiana za każdym razem, gdy wystąpi zdarzenie kliknięcia na przycisku.

[edytuj]gdy mamy dwie funkcje powiedzmy functia i functionB, Jeśli functia zależy od functionB .

Następnie wywołujemy functionB jako funkcję wywołania zwrotnego.jest to szeroko stosowane w Spring framework.

Pomyśl o metodzie jako o zadaniu współpracownikowi. Proste zadanie może być następujące:

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

Twój współpracownik sumiennie wykonuje obliczenia i daje następujący wynik:

x = -6
y = -4

Ale twój współpracownik ma problem, nie zawsze rozumie notacje, takie jak ^, ale rozumie je po ich opisie. Takich jak exponent. Za każdym razem, gdy znajdzie jedną z nich, otrzymujesz następujące:

I don't understand "^"

Wymaga to przepisania całego zestawu instrukcji ponownie po wyjaśnieniu, co oznacza postać do współpracownika, a on nie zawsze pamięta między pytaniami. I ma trudności z zapamiętaniem twoich wskazówek, takich jak po prostu zapytaj mnie. Zawsze podąża za twoimi pisemnymi wskazówkami najlepiej jak potrafi.

Myślisz o rozwiązaniu, po prostu dodaj następujące instrukcje do wszystkich instrukcji:

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

Teraz, gdy ma problem, dzwoni do Ciebie i pyta, zamiast dawać złą odpowiedź i zmuszać proces do ponownego uruchomienia.

Callbacks pozwala wstawić własny kod do innego bloku kodu, który ma być wykonywany w innym czasie, który modyfikuje lub dodaje do zachowania tego innego bloku kodu w zależności od potrzeb. Zyskujesz elastyczność i możliwość dostosowania, a jednocześnie możesz mieć bardziej łatwy w utrzymaniu kod.

Mniej twardego kodu = łatwiej utrzymać I zmienić = mniej czasu = więcej wartości biznesowej = awesomeness.

Na przykład w javascript, używając podkreślenia.js, można znaleźć wszystkie parzyste elementy w tablicy tak:

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

Przykład dzięki uprzejmości podkreślenia.js: http://documentcloud.github.com/underscore/#filter

To pod względem pobierania strony:

Twój program działa na komórce i prosi o stronę http://www.google.com. Jeśli piszesz program synchronicznie, funkcja, którą piszesz, aby pobrać dane, będzie działać nieprzerwanie, aż wszystkie dane zostaną pobrane. Oznacza to, że interfejs użytkownika nie będzie odświeżany i w zasadzie pojawi się zamrożony. Jeśli piszesz swój program za pomocą wywołań zwrotnych, żądasz danych i mówisz " wykonaj tę funkcję po zakończeniu."To pozwala interfejsowi nadal zezwalać na interakcję użytkownika podczas pobierania pliku. Po zakończeniu pobierania strony internetowej wywoływana jest funkcja wyniku (callback) i możesz obsłużyć dane.

Zasadniczo pozwala na żądanie czegoś i kontynuowanie wykonywania w oczekiwaniu na wynik. Gdy wynik wróci do ciebie za pomocą funkcji zwrotnej, możesz rozpocząć operację, w której została przerwana.