function - सादा अंग्रेजी में कॉलबैक की व्याख्या कैसे करें? वे किसी फ़ंक्शन को किसी अन्य फ़ंक्शन से कॉल करने से अलग कैसे हैं?




callback (20)

सादे अंग्रेजी में कॉलबैक की व्याख्या कैसे करें? कॉलिंग फ़ंक्शन से कुछ संदर्भ लेने वाले किसी अन्य फ़ंक्शन से एक फ़ंक्शन को कॉल करने से वे अलग कैसे हैं? एक नौसिखिया प्रोग्रामर को उनकी शक्ति कैसे समझाया जा सकता है?


सादे अंग्रेजी में कॉलबैक की व्याख्या कैसे करें?

सादे अंग्रेजी में, एक कॉलबैक फ़ंक्शन एक ऐसे कार्यकर्ता की तरह होता है जो अपने कार्यकर्ता को "वापस कॉल" करता है जब उसने कार्य पूरा कर लिया हो।

कॉलिंग फ़ंक्शन से कुछ संदर्भ लेने वाले किसी अन्य फ़ंक्शन से एक फ़ंक्शन को कॉल करने से वे अलग कैसे हैं?

यह सच है कि आप किसी अन्य फ़ंक्शन से फ़ंक्शन को कॉल कर रहे हैं, लेकिन कुंजी यह है कि कॉलबैक को ऑब्जेक्ट की तरह माना जाता है, ताकि आप सिस्टम की स्थिति (जैसे रणनीति डिजाइन पैटर्न) के आधार पर कॉल करने के लिए कौन सा फ़ंक्शन कॉल कर सकें।

एक नौसिखिया प्रोग्रामर को उनकी शक्ति कैसे समझाया जा सकता है?

कॉलबैक की शक्ति आसानी से AJAX- शैली वाली वेबसाइटों में देखी जा सकती है जिन्हें सर्वर से डेटा खींचने की आवश्यकता होती है। नए डेटा को डाउनलोड करने में कुछ समय लग सकता है। कॉलबैक के बिना, आपका पूरा यूजर इंटरफेस नया डेटा डाउनलोड करते समय "फ्रीज" होगा, या आपको इसके केवल हिस्से के बजाय पूरे पृष्ठ को रीफ्रेश करना होगा। कॉलबैक के साथ, आप "अब लोडिंग" छवि डाल सकते हैं और इसे लोड होने के बाद इसे नए डेटा से बदल सकते हैं।

कॉलबैक के बिना कुछ कोड:

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

कॉलबैक के साथ:

JQuery के getJSON का उपयोग करके कॉलबैक के साथ एक उदाहरण यहां दिया गया है:

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
}

बंद करने के साथ:

अक्सर कॉलबैक को closure का उपयोग करके कॉलिंग फ़ंक्शन से state तक पहुंचने की आवश्यकता होती है, जो कि कार्यकर्ता को अपने कार्य को पूरा करने से पहले प्रबंधक से जानकारी प्राप्त करने की आवश्यकता होती है। closure करने के लिए, आप फ़ंक्शन को रेखांकित कर सकते हैं ताकि यह कॉलिंग संदर्भ में डेटा देख सके:

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

उपयोग:

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

समापन

अंत में, डगलस क्रॉकफ़ोर्ड से closure परिभाषा यहां दी गई है:

कार्यों को अन्य कार्यों के अंदर परिभाषित किया जा सकता है। आंतरिक कार्य में बाहरी कार्य के वर्रों और पैरामीटर तक पहुंच होती है। यदि एक आंतरिक कार्य का संदर्भ जीवित रहता है (उदाहरण के लिए, कॉलबैक फ़ंक्शन के रूप में), बाहरी फ़ंक्शन के वर्र्स भी जीवित रहते हैं।

यह भी देखें:


अक्सर एक आवेदन को इसके संदर्भ / राज्य के आधार पर विभिन्न कार्यों को निष्पादित करने की आवश्यकता होती है। इसके लिए, हम एक चर का उपयोग करते हैं जहां हम फ़ंक्शन के बारे में जानकारी संग्रहीत करेंगे। इसकी आवश्यकता के मुताबिक एप्लिकेशन इस चर को फ़ंक्शन के बारे में जानकारी के साथ सेट करेगा और उसी चर का उपयोग करके फ़ंक्शन को कॉल करेगा।

जावास्क्रिप्ट में, उदाहरण नीचे है। यहां हम विधि तर्क के रूप में विधि तर्क का उपयोग करते हैं जहां हम फ़ंक्शन के बारे में जानकारी संग्रहीत करते हैं।

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]

आप बीमार महसूस करते हैं ताकि आप डॉक्टर के पास जाएं। वह आपको जांचता है और निर्धारित करता है कि आपको कुछ दवा की जरूरत है। वह कुछ मेड निर्धारित करता है और पर्ची को आपकी स्थानीय फार्मेसी में बुलाता है। तुम घर जाओ। बाद में आपकी फार्मेसी आपको बताने के लिए कहती है कि आपका पर्चे तैयार है। तुम जाओ और इसे उठाओ।


आपके पास कुछ कोड है जिसे आप चलाना चाहते हैं। आम तौर पर, जब आप इसे कॉल करते हैं तो आप आगे बढ़ने से पहले इसे पूरा करने का इंतजार कर रहे हैं (जिससे आपके ऐप ग्रे हो सकते हैं / कर्सर के लिए कताई का समय उत्पन्न कर सकते हैं)।

इस कोड को समानांतर में चलाने और अपने काम के साथ चलने का एक वैकल्पिक तरीका है। लेकिन क्या होगा यदि आपके मूल कोड को कोड से प्रतिक्रिया के आधार पर अलग-अलग चीजें करने की ज़रूरत है? खैर, उस स्थिति में आप उस कोड के नाम / स्थान पर जा सकते हैं जिसे आप इसे कॉल करने के लिए कॉल करना चाहते हैं। यह एक "कॉल बैक" है।

सामान्य कोड: जानकारी के लिए पूछें-> प्रक्रिया की जानकारी-> प्रसंस्करण के परिणामों के साथ सौदा-> अन्य चीजों को जारी रखें।

कॉलबैक के साथ: जानकारी के लिए पूछें-> प्रक्रिया की जानकारी-> अन्य चीजें करना जारी रखें। और कुछ बाद के बिंदु पर-> प्रसंस्करण के परिणामों के साथ सौदा।


एक उदाहरण के साथ शुरू करने के लिए हमेशा बेहतर :)।

आइए मान लें कि आपके पास दो मॉड्यूल ए और बी हैं

मॉड्यूल ए को मॉड्यूल बी में कुछ घटना / स्थिति होने पर अधिसूचित किया जाना चाहिए। हालांकि, मॉड्यूल बी को आपके मॉड्यूल ए के बारे में कोई जानकारी नहीं है। यह सब एक फ़ंक्शन पॉइंटर के माध्यम से किसी विशेष फ़ंक्शन (मॉड्यूल ए के) का पता है मॉड्यूल ए द्वारा प्रदान की गई।

इसलिए सभी बी को अब करना है, मॉड्यूल ए में "कॉलबैक" है जब फ़ंक्शन पॉइंटर का उपयोग करके कोई विशेष ईवेंट / स्थिति होती है। कॉलबैक फ़ंक्शन के अंदर कोई और प्रोसेसिंग कर सकता है।

*) यहां एक स्पष्ट लाभ यह है कि आप मॉड्यूल बी से मॉड्यूल ए के बारे में सब कुछ बता रहे हैं। मॉड्यूल बी को परवाह नहीं है कि कौन सा मॉड्यूल ए है।


एक रूपक स्पष्टीकरण:

मेरे पास एक पार्सल है जिसे मैं किसी मित्र को पहुंचाता हूं, और मैं यह भी जानना चाहता हूं कि मेरे दोस्त को यह कब प्राप्त होता है।

तो मैं पार्सल को डाकघर में ले जाता हूं और उन्हें वितरित करने के लिए कहता हूं। अगर मैं जानना चाहता हूं कि मेरे दोस्त को पार्सल कब प्राप्त होता है, तो मेरे पास दो विकल्प हैं:

(ए) जब तक इसे डिलीवर नहीं किया जाता है तब तक मैं डाकघर में इंतजार कर सकता हूं।

(बी) इसे वितरित होने पर मुझे एक ईमेल प्राप्त होगा।

विकल्प (बी) कॉलबैक के समान है।


कल्पना कीजिए कि एक दोस्त आपका घर छोड़ रहा है, और आप उसे बताते हैं "जब आप घर आते हैं तो मुझे कॉल करें ताकि मुझे पता चले कि आप सुरक्षित रूप से पहुंचे"; वह (शाब्दिक) एक कॉल वापस है । भाषा के बावजूद, कॉलबैक फ़ंक्शन यही है। जब आप कुछ कार्य पूरा कर लेते हैं तो आप कुछ प्रक्रिया को वापस नियंत्रित करने की प्रक्रिया चाहते हैं, इसलिए आप इसे वापस कॉल करने के लिए उपयोग करने के लिए एक फ़ंक्शन देते हैं।

पायथन में, उदाहरण के लिए,

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

grabDBValue को केवल डेटाबेस से मूल्य प्राप्त करने के लिए लिखा जा सकता है और फिर आपको यह निर्दिष्ट करने देता है कि वास्तव में मूल्य के साथ क्या करना है, इसलिए यह एक फ़ंक्शन स्वीकार करता है। आप नहीं जानते कि कब या कब grabDBValue वापस आ जाएगा, लेकिन अगर / जब यह करता है, तो आप जानते हैं कि आप इसे क्या करना चाहते हैं। यहां, मैं एक अज्ञात फ़ंक्शन (या लैम्ब्डा ) में जाता हूं जो एक GUI विंडो में मान भेजता है। मैं इसे करके प्रोग्राम के व्यवहार को आसानी से बदल सकता हूं:

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

कॉलबैक उन भाषाओं में अच्छी तरह से काम करते हैं जहां फ़ंक्शन प्रथम श्रेणी मान होते हैं, जैसे कि सामान्य पूर्णांक, कैरेक्टर स्ट्रिंग्स, बूलियन इत्यादि। सी में, आप इसके लिए एक पॉइंटर पास करके चारों ओर एक फ़ंक्शन "पास" कर सकते हैं और कॉलर इसका उपयोग कर सकता है; जावा में, कॉलर एक निश्चित प्रकार के स्थिर वर्ग के लिए एक निश्चित विधि नाम के साथ पूछेगा क्योंकि कक्षाओं के बाहर कोई कार्य नहीं है ("विधियां," वास्तव में); और अधिकांश अन्य गतिशील भाषाओं में आप बस सरल वाक्यविन्यास के साथ एक समारोह पारित कर सकते हैं।

प्रो टिप:

शब्दावली स्कोपिंग (जैसे योजना या पर्ल) वाली भाषाओं में आप इस तरह की चाल खींच सकते हैं:

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 6 होगा क्योंकि कॉलबैक में व्याख्यात्मक वातावरण में घोषित चरों तक पहुंच है जहां इसे परिभाषित किया गया था। लेक्सिकल स्कोप और अनाम कॉलबैक एक शक्तिशाली संयोजन हैं जो नौसिखिया प्रोग्रामर के लिए आगे के अध्ययन की गारंटी देते हैं।


कॉलबैक एक ऐसा फ़ंक्शन है जिसे दूसरे फ़ंक्शन द्वारा बुलाया जाएगा। यह दूसरा फ़ंक्शन पहले से नहीं जानता कि यह कौन सा फ़ंक्शन कॉल करेगा। तो कॉलबैक फ़ंक्शन की पहचान कहीं भी संग्रहीत की जाती है, या दूसरे फ़ंक्शन को पैरामीटर के रूप में पास कर दी जाती है। प्रोग्रामिंग भाषा के आधार पर यह "पहचान", कॉलबैक का पता हो सकता है, या किसी अन्य प्रकार के पॉइंटर का हो सकता है, या यह फ़ंक्शन का नाम हो सकता है। प्रिंसिपल वही है, हम कुछ जानकारी स्टोर या पास करते हैं जो अनजाने में फ़ंक्शन की पहचान करता है।

जब समय आता है, तो दूसरा कार्य कॉलबैक को कॉल कर सकता है, उस पल में परिस्थितियों के आधार पर पैरामीटर की आपूर्ति कर सकता है। यह संभव कॉलबैक के सेट से कॉलबैक भी चुन सकता है। प्रोग्रामिंग भाषा को किसी अन्य प्रकार का वाक्यविन्यास प्रदान करना होगा ताकि दूसरे फ़ंक्शन को कॉलबैक को कॉल करने की अनुमति मिल सके, इसकी पहचान "पहचान" हो।

इस तंत्र में बहुत से संभावित उपयोग हैं। कॉलबैक के साथ, फ़ंक्शन के डिज़ाइनर को कॉलबैक प्रदान किए जाने पर इसे कॉल करके अनुकूलित किया जा सकता है। उदाहरण के लिए, एक सॉर्टिंग फ़ंक्शन पैरामीटर के रूप में कॉलबैक ले सकता है, और यह कॉलबैक दो तत्वों की तुलना करने के लिए एक फ़ंक्शन हो सकता है यह तय करने के लिए कि कौन सा पहले आता है।

वैसे, प्रोग्रामिंग भाषा के आधार पर, उपर्युक्त चर्चा में "फ़ंक्शन" शब्द को "ब्लॉक", "बंद करें," "लैम्ब्डा" आदि द्वारा प्रतिस्थापित किया जा सकता है।


कॉलबैक सिखाने के लिए, आपको पहले पॉइंटर सिखाना होगा। एक बार छात्र एक परिवर्तक के सूचक के विचार को समझने के बाद, कॉलबैक का विचार आसान हो जाएगा। मान लीजिए कि आप सी / सी ++ का उपयोग कर रहे हैं, इन चरणों का पालन किया जा सकता है।

  • सबसे पहले अपने छात्रों को सामान्य परिवर्तनीय पहचानकर्ताओं के उपयोग के साथ पॉइंटर्स का उपयोग करके चर का उपयोग और कुशलतापूर्वक उपयोग करने का तरीका दिखाएं।
  • फिर उन्हें सिखाएं कि ऐसी चीजें हैं जो केवल पॉइंटर्स के साथ ही की जा सकती हैं (जैसे संदर्भ द्वारा चर बदलना)।
  • फिर उन्हें बताएं कि कैसे निष्पादन योग्य कोड या फ़ंक्शंस स्मृति में कुछ अन्य डेटा (या चर) की तरह हैं। इसलिए, कार्यों में पते या पॉइंटर्स भी होते हैं।
  • फिर उन्हें दिखाएं कि फ़ंक्शन पॉइंटर्स के साथ फ़ंक्शंस को कैसे कॉल किया जा सकता है और इन्हें कॉलबैक कहा जाता है।
  • अब सवाल यह है कि कुछ कार्यों को बुलाए जाने के लिए ये सभी परेशानी क्यों? क्या फायदा है डेटा पॉइंटर्स की तरह, फ़ंक्शन पॉइंटर उर्फ ​​कॉलबैक के सामान्य पहचानकर्ताओं का उपयोग करने पर कुछ फायदे हैं।
  • पहला यह है कि फ़ंक्शन आइडेंटिफ़ायर या फ़ंक्शन नाम सामान्य डेटा के रूप में उपयोग नहीं किए जा सकते हैं। मेरा मतलब है, आप कार्यों के साथ डेटा संरचना नहीं बना सकते हैं (जैसे सरणी या कार्यों की एक लिंक की गई सूची)। लेकिन कॉलबैक के साथ, आप एक सरणी, एक लिंक्ड सूची बना सकते हैं या अन्य डेटा के साथ उनका उपयोग कर सकते हैं जैसे कुंजी-मूल्य जोड़े या पेड़, या किसी अन्य चीज के शब्दकोश में। यह एक शक्तिशाली लाभ है। और अन्य लाभ वास्तव में इस के बच्चे हैं।
  • कॉलबैक का सबसे आम उपयोग इवेंट ड्राइवर प्रोग्रामिंग में देखा जाता है। जहां कुछ आने वाले सिग्नल के आधार पर एक या अधिक फ़ंक्शन निष्पादित किए जाते हैं। कॉलबैक के साथ, कॉलबैक के साथ सिग्नल मैप करने के लिए एक शब्दकोश को बनाए रखा जा सकता है। फिर इनपुट सिग्नल रिज़ॉल्यूशन और संबंधित कोड का निष्पादन बहुत आसान हो जाता है।
  • मेरे दिमाग में आने वाले कॉलबैक का दूसरा उपयोग उच्च ऑर्डर फ़ंक्शन है। वे कार्य जो इनपुट तर्क के रूप में अन्य कार्यों को लेते हैं। और तर्क के रूप में कार्यों को भेजने के लिए, हमें कॉलबैक की आवश्यकता है। एक उदाहरण एक ऐसा फ़ंक्शन हो सकता है जो एक सरणी और कॉलबैक ले। फिर यह सरणी के प्रत्येक आइटम पर कॉलबैक करता है और परिणामों को किसी अन्य सरणी में वापस कर देता है। यदि हम फ़ंक्शन को दोगुना कॉलबैक पास करते हैं, तो हमें एक दोगुनी मूल्यवान सरणी मिलती है। यदि हम स्क्वायरिंग कॉलबैक पास करते हैं, तो हमें वर्ग मिलते हैं। वर्ग जड़ों के लिए, बस उचित कॉलबैक भेजें। This cannot be done with normal functions.

There might many more things. Involve the students and they will discover. उम्मीद है की यह मदद करेगा।


गैर-प्रोग्रामर शब्दों में, एक कॉलबैक एक प्रोग्राम में एक भर में खाली है।

कई पेपर फॉर्मों पर एक आम वस्तु "आपात स्थिति के मामले में कॉल करने वाला व्यक्ति" है। वहां एक खाली रेखा है। आप किसी के नाम और फोन नंबर में लिखते हैं। यदि कोई आपात स्थिति होती है, तो उस व्यक्ति को बुलाया जाता है।

  • हर कोई एक ही खाली रूप मिलता है, लेकिन
  • हर कोई एक अलग आपातकालीन संपर्क संख्या लिख ​​सकता है।

यह महत्वपूर्ण है। आप फॉर्म (कोड, आमतौर पर किसी और का) नहीं बदलते हैं। हालांकि आप जानकारी के गुम टुकड़े ( आपका नंबर) भर सकते हैं।

उदाहरण 1:

कॉलबैक का उपयोग किसी भी प्रोग्राम के व्यवहार को जोड़ने / बदलने के लिए संभवतः अनुकूलित विधियों के रूप में किया जाता है। उदाहरण के लिए, कुछ सी कोड लें जो फ़ंक्शन करता है, लेकिन यह नहीं जानता कि आउटपुट प्रिंट कैसे करें। यह सब एक स्ट्रिंग कर सकते हैं। जब यह पता लगाने की कोशिश करता है कि स्ट्रिंग के साथ क्या करना है, तो यह एक खाली रेखा को देखता है। लेकिन, प्रोग्रामर ने आपको अपनी कॉलबैक लिखने के लिए खाली दिया!

इस उदाहरण में, आप कागज की शीट पर रिक्त स्थान भरने के लिए एक पेंसिल का उपयोग नहीं करते हैं, तो आप function_print_callback set_print_callback(the_callback) फ़ंक्शन का उपयोग करते हैं।

  • मॉड्यूल / कोड में रिक्त चर रिक्त रेखा है,
  • set_print_callback पेंसिल है,
  • the_callback आपकी जानकारी है जिसे आप भर रहे हैं।

अब आपने कार्यक्रम में इस रिक्त रेखा को भर दिया है। जब भी इसे आउटपुट प्रिंट करने की आवश्यकता होती है, तो वह उस रिक्त रेखा को देखेगी, और वहां दिए गए निर्देशों का पालन करें (यानी आपके द्वारा रखे गए फ़ंक्शन को कॉल करें।) व्यावहारिक रूप से, यह स्क्रीन पर प्रिंट करने की संभावना, एक लॉग फ़ाइल में, प्रिंटर को, एक नेटवर्क कनेक्शन, या इसके किसी भी संयोजन पर। आप जो खाली करना चाहते हैं उसके साथ खाली हो गए हैं।

उदाहरण 2:

जब आपको बताया जाता है कि आपको किसी आपातकालीन नंबर पर कॉल करने की आवश्यकता है, तो आप पेपर फॉर्म पर जो लिखा है उसे पढ़ें और फिर पढ़े गए नंबर पर कॉल करें। यदि वह रेखा खाली है तो कुछ भी नहीं किया जाएगा।

गुई प्रोग्रामिंग एक ही तरह से काम करता है। जब कोई बटन क्लिक किया जाता है, तो प्रोग्राम को यह पता लगाने की आवश्यकता होती है कि आगे क्या करना है। यह जाता है और कॉलबैक की तलाश करता है। यह कॉलबैक एक खाली लेबल में होता है "बटन 1 क्लिक करते समय आप क्या करते हैं"

जब आप इसे पूछते हैं तो अधिकांश आईडीई स्वचालित रूप से आपके लिए खाली हो जाएंगे (मूल विधि लिखें) (उदाहरण के लिए button1_clicked )। हालांकि उस रिक्त स्थान में कोई भी विधि हो सकती है जिसे आप अच्छी तरह से छोड़ दें । जब तक आप उस कॉलबैक के नाम को उचित रिक्त स्थान पर butter_the_biscuits , तब तक आप run_computations या butter_the_biscuits विधि को कॉल कर सकते हैं। आप आपातकालीन संख्या में खाली "555-555-1212" डाल सकते हैं। यह ज्यादा समझ में नहीं आता है, लेकिन यह अनुमति है।

अंतिम नोट: उस रिक्त रेखा जिसे आप कॉलबैक के साथ भर रहे हैं? इसे मिटाया जा सकता है और इच्छा पर फिर से लिखा जा सकता है। (चाहे आपको एक और सवाल होना चाहिए या नहीं, लेकिन यह उनकी शक्ति का हिस्सा है)


मैं इतने बुद्धिमान लोगों को इस वास्तविकता पर बल देने में असफल रहा हूं कि "कॉलबैक" शब्द दो असंगत तरीकों से उपयोग किया जा रहा है।

दोनों तरीकों से मौजूदा कार्यक्षमता में अतिरिक्त कार्यक्षमता (एक फ़ंक्शन परिभाषा, अज्ञात या नामित) पास करके फ़ंक्शन का अनुकूलन शामिल होता है। अर्थात।

customizableFunc(customFunctionality)

यदि कस्टम कार्यक्षमता को कोड ब्लॉक में बस प्लग किया गया है, तो आपने इस तरह के फ़ंक्शन को कस्टमाइज़ किया है।

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

हालांकि इस प्रकार की इंजेक्शन कार्यक्षमता को अक्सर "कॉलबैक" कहा जाता है, इसके बारे में कुछ भी आकस्मिक नहीं है। एक बहुत ही स्पष्ट उदाहरण है प्रत्येक विधि के लिए जिसमें सरणी को संशोधित करने के लिए सरणी में प्रत्येक तत्व पर लागू होने के लिए एक तर्क के रूप में एक कस्टम फ़ंक्शन प्रदान किया जाता है।

लेकिन यह मूल रूप से एसिक्स या नोड.जेएस में या उपयोगकर्ता इंटरैक्शन ईवेंट (जैसे माउस क्लिक) की कार्यक्षमता को आवंटित करने में एसिंक्रोनस प्रोग्रामिंग के लिए "कॉलबैक" फ़ंक्शंस के उपयोग से अलग है। इस मामले में, संपूर्ण विचार कस्टम कार्यक्षमता निष्पादित करने से पहले एक आकस्मिक घटना का इंतजार करना है। यह उपयोगकर्ता इंटरैक्शन के मामले में स्पष्ट है, लेकिन आई / ओ (इनपुट / आउटपुट) प्रक्रियाओं में भी महत्वपूर्ण है जिसमें डिस्क से फ़ाइलों को पढ़ने जैसे समय लग सकता है। यह वह जगह है जहां "कॉलबैक" शब्द सबसे स्पष्ट समझ बनाता है। एक बार आई / ओ प्रक्रिया शुरू हो जाने के बाद (डिस्क से सर्वर को पढ़ने के लिए फ़ाइल या सर्वर अनुरोध से डेटा वापस करने के लिए पूछना) एक एसिंक्रोनस प्रोग्राम इसके खत्म होने के लिए चारों ओर इंतजार नहीं करता है। आगे बढ़ने वाले कार्यों के साथ आगे बढ़ सकते हैं, और केवल कस्टम कार्यक्षमता के साथ प्रतिक्रिया दे दी गई है जब इसे अधिसूचित किया गया है कि पठन फ़ाइल या http अनुरोध पूरा हो गया है (या यह विफल रहा है) और यह कि डेटा कस्टम कार्यक्षमता के लिए उपलब्ध है। यह फोन पर एक व्यवसाय को कॉल करने और अपना "कॉलबैक" नंबर छोड़ने जैसा है, इसलिए जब कोई आपको वापस आने के लिए उपलब्ध होता है तो वे आपको कॉल कर सकते हैं। यह लाइन पर लटकने से बेहतर है कि कौन जानता है कि कितने समय तक और अन्य मामलों में भाग लेने में सक्षम नहीं है।

असीमित उपयोग में मूल रूप से वांछित घटना (उदाहरण के लिए, i / o प्रक्रिया को पूरा करने) के कुछ साधन शामिल होते हैं ताकि जब ऐसा होता है (और केवल तब होता है) कस्टम "कॉलबैक" कार्यक्षमता निष्पादित की जाती है। स्पष्ट AJAX उदाहरण में, जब डेटा वास्तव में सर्वर से आता है, तो "कॉलबैक" फ़ंक्शन उस डेटा का उपयोग DOM को संशोधित करने के लिए ट्रिगर किया जाता है और इसलिए उस सीमा तक ब्राउज़र विंडो को फिर से चलाता है।

संक्षेप में दुहराना। कुछ लोग किसी भी प्रकार की कस्टम कार्यक्षमता को संदर्भित करने के लिए "कॉलबैक" शब्द का उपयोग करते हैं जिसे किसी मौजूदा फ़ंक्शन में तर्क के रूप में इंजेक्शन दिया जा सकता है। लेकिन, कम से कम मेरे लिए, शब्द का सबसे उचित उपयोग यह है कि इंजेक्शन "कॉलबैक" फ़ंक्शन को अतुल्यकालिक रूप से उपयोग किया जाता है - केवल उस घटना की घटना पर निष्पादित किया जा सकता है जिसे वह अधिसूचित करने का इंतजार कर रहा है।


मैं इस मृत को सरल रखने की कोशिश करने जा रहा हूं। एक "कॉलबैक" कोई भी फ़ंक्शन है जिसे किसी अन्य फ़ंक्शन द्वारा बुलाया जाता है जो पैरामीटर के रूप में पहला फ़ंक्शन लेता है। बहुत समय, एक "कॉलबैक" एक ऐसा कार्य होता है जिसे कुछ होता है जब बुलाया जाता है। प्रोग्रामर-बोलने में कुछ "ईवेंट" कहा जा सकता है।

इस परिदृश्य की कल्पना करें: आप कुछ दिनों में पैकेज की उम्मीद कर रहे हैं। पैकेज आपके पड़ोसी के लिए एक उपहार है। इसलिए, एक बार जब आप पैकेज प्राप्त कर लेंगे, तो आप इसे पड़ोसियों को लाएंगे। आप शहर से बाहर हैं, और इसलिए आप अपने पति / पत्नी के लिए निर्देश छोड़ देते हैं।

आप उन्हें पैकेज प्राप्त करने और पड़ोसियों को लाने के लिए कह सकते हैं। यदि आपका पति / पत्नी कंप्यूटर के रूप में बेवकूफ था, तो वे दरवाजे पर बैठे और पैकेज तक इंतजार कर रहे थे जब तक कि यह नहीं आया (कुछ भी नहीं कर रहा था) और फिर एक बार यह आने के बाद वे इसे पड़ोसियों के पास लाएंगे। लेकिन एक बेहतर तरीका है। अपने पति को बताएं कि एक बार उन्हें पैकेज प्राप्त होता है, उन्हें पड़ोसियों पर ले जाना चाहिए। फिर, जब तक वे पैकेज प्राप्त नहीं करते हैं, वे सामान्य रूप से जीवन के बारे में जा सकते हैं।

हमारे उदाहरण में, पैकेज प्राप्त करना "घटना" है और इसे पड़ोसियों को लाने के लिए "कॉलबैक" है। पैकेज आने पर पैकेज को लाने के लिए आपका पति / पत्नी आपके निर्देशों को "चलाता है"। काफी बेहतर!

इस तरह की सोच दैनिक जीवन में स्पष्ट है, लेकिन कंप्यूटरों में समान सामान्य ज्ञान नहीं है। गौर करें कि प्रोग्रामर सामान्य रूप से फ़ाइल में कैसे लिखते हैं:

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

यहां, हम इसे लिखने से पहले, फ़ाइल खोलने के लिए WAIT। यह निष्पादन के प्रवाह को "ब्लॉक" करता है, और हमारा कार्यक्रम अन्य किसी भी चीज को नहीं कर सकता है जिसे इसे करने की आवश्यकता हो सकती है! अगर हम इसके बजाय ऐसा कर सकते हैं तो क्या होगा:

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

यह पता चला है कि हम इसे कुछ भाषाओं और ढांचे के साथ करते हैं। यह बहुत अच्छा है! इस तरह की सोच के साथ कुछ वास्तविक अभ्यास पाने के लिए Node.js देखें।


“In computer programming, a callback is a reference to executable code, or a piece of executable code, that is passed as an argument to other code. This allows a lower-level software layer to call a subroutine (or function) defined in a higher-level layer.” - Wikipedia

Callback in C using Function Pointer

In C, callback is implemented using Function Pointer. Function Pointer - as the name suggests, is a pointer to a function.

For example, int (*ptrFunc) ();

Here, ptrFunc is a pointer to a function that takes no arguments and returns an integer. DO NOT forget to put in the parenthesis, otherwise the compiler will assume that ptrFunc is a normal function name, which takes nothing and returns a pointer to an integer.

Here is some code to demonstrate the function pointer.

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

Now let us try to understand the concept of Callback in C using function pointer.

The complete program has three files: callback.c, reg_callback.h and 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)();                               
}

If we run this program, the output will be

This is a program demonstrating function callback inside register_callback inside my_callback back inside main program

The higher layer function calls a lower layer function as a normal call and the callback mechanism allows the lower layer function to call the higher layer function through a pointer to a callback function.

Callback in Java Using Interface

Java does not have the concept of function pointer It implements Callback mechanism through its Interface mechanism Here instead of a function pointer, we declare an Interface having a method which will be called when the callee finishes its task

Let me demonstrate it through an example:

The Callback Interface

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

The Caller or the Higher Level Class

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

The Callee or the lower layer function

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 Using EventListener pattern

  • सामग्री सूचीबद्ध करें

This pattern is used to notify 0 to n numbers of Observers/Listeners that a particular task has finished

  • सामग्री सूचीबद्ध करें

The difference between Callback mechanism and EventListener/Observer mechanism is that in callback, the callee notifies the single caller, whereas in Eventlisener/Observer, the callee can notify anyone who is interested in that event (the notification may go to some other parts of the application which has not triggered the task)

Let me explain it through an example.

The Event Interface

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

Activity Class

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

Other Class

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

Main Class

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

As you can see from the above code, that we have an interface called events which basically lists all the events that may happen for our application. The Widget class is the base class for all the UI components like Button, Checkbox. These UI components are the objects that actually receive the events from the framework code. Widget class implements the Events interface and also it has two nested interfaces namely OnClickEventListener & OnLongClickEventListener

These two interfaces are responsible for listening to events that may occur on the Widget derived UI components like Button or Checkbox. So if we compare this example with the earlier Callback example using Java Interface, these two interfaces work as the Callback interface. So the higher level code (Here Activity) implements these two interfaces. And whenever an event occurs to a widget, the higher level code (or the method of these interfaces implemented in the higher level code, which is here Activity) will be called.

Now let me discuss the basic difference between Callback and Eventlistener pattern. As we have mentioned that using Callback, the Callee can notify only a single Caller. But in the case of EventListener pattern, any other part or class of the Application can register for the events that may occur on the Button or Checkbox. The example of this kind of class is the OtherClass. If you see the code of the OtherClass, you will find that it has registered itself as a listener to the ClickEvent that may occur in the Button defined in the Activity. Interesting part is that, besides the Activity ( the Caller), this OtherClass will also be notified whenever the click event occurs on the Button.


टेलीफोन सिस्टम के संदर्भ में कॉलबैक का सबसे आसानी से वर्णन किया जाता है। एक फ़ंक्शन कॉल किसी को टेलीफोन पर कॉल करने, उसे एक प्रश्न पूछने, उत्तर देने और लटकने के समान है; कॉलबैक जोड़ना समानता को बदलता है ताकि उसे एक प्रश्न पूछने के बाद, आप उसे अपना नाम और संख्या भी दें ताकि वह आपको जवाब के साथ वापस बुला सके। - पॉल Jakubik, "सी ++ में कॉलबैक कार्यान्वयन"


A callback is a method that is scheduled to be executed when a condition is met.

An "real world" example is a local video game store. You are waiting for Half-Life 3. Instead of going to the store every day to see if it is in, you register your email on a list to be notified when the game is available. The email becomes your "callback" and the condition to be met is the game's availability.

A "programmers" example is a web page where you want to perform an action when a button is clicked. You register a callback method for a button and continue doing other tasks. When/if the user cicks on the button, the browser will look at the list of callbacks for that event and call your method.

A callback is a way to handle events asynchronously. You can never know when the callback will be executed, or if it will be executed at all. The advantage is that it frees your program and CPU cycles to perform other tasks while waiting for the reply.


A callback is a self-addressed stamped envelope. When you call a function, that is like sending a letter. If you want that function to call another function you provide that information in the form of a reference or address.


I think it's an rather easy task to explain.

At first callback are just ordinary functions.
And the further is, that we call this function (let's call it A) from inside another function (let's call it B).

The magic about this is that I decide, which function should be called by the function from outside B.

At the time I write the function BI don't know which callback function should be called. At the time I call function BI also tell this function to call function A. That is all.


In plain english a callback is a promise. Joe, Jane, David and Samantha share a carpool to work. Joe is driving today. Jane, David and Samantha have a couple of options:

  1. Check the window every 5 minutes to see if Joe is out
  2. Keep doing their thing until Joe rings the door bell.

Option 1: This is more like a polling example where Jane would be stuck in a "loop" checking if Joe is outside. Jane can't do anything else in the mean time.

Option 2: This is the callback example. Jane tells Joe to ring her doorbell when he's outside. She gives him a "function" to ring the door bell. Joe does not need to know how the door bell works or where it is, he just needs to call that function ie ring the door bell when he's there.

Callbacks are driven by "events". In this example the "event" is Joe's arrival. In Ajax for example events can be "success" or "failure" of the asynchronous request and each can have the same or different callbacks.

In terms of JavaScript applications and callbacks. We also need to understand "closures" and application context. What "this" refers to can easily confuse JavaScript developers. In this example within each person's "ring_the_door_bell()" method/callback there might be some other methods that each person need to do based on their morning routine ex. "turn_off_the_tv()". We would want "this" to refer to the "Jane" object or the "David" object so that each can setup whatever else they need done before Joe picks them up. This is where setting up the callback with Joe requires parodying the method so that "this" refers to the right object.

उम्मीद है की वो मदद करदे!


Think of a method as giving a task to a coworker. A simple task might be the following:

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

Your coworker diligently does the math and gives you the following result:

x = -6
y = -4

But your coworker has a problem, he doesn't always understand notations, such as ^ , but he does understand them by their description. Such as exponent . Everytime he finds one of these you get back the following:

I don't understand "^"

This requires you to rewrite your entire instruction set again after explaining what the character means to your coworker, and he doesn't always remember in between questions. And he has difficulty remembering your tips as well, such as just ask me. He always follows your written directions as best he can however.

You think of a solution, you just add the following to all of your instructions:

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

Now whenever he has a problem he calls you and asks, rather than giving you a bad response and making the process restart.


This of it in terms of downloading a webpage:

Your program runs on a cellphone and is requesting the webpage http://www.google.com . If you write your program synchronously, the function you write to download the data will be running continuously until all the data is download. This means your UI will not refresh and will basically appear frozen. If you write your program using callbacks, you request the data and say "execute this function when you've finished." This allows the UI to still allow user interaction while the file is downloading. Once the webpage has finished downloading, your result function (callback) is called and you can handle the data.

असल में, यह आपको परिणाम का इंतजार करते समय कुछ अनुरोध करने और निष्पादन जारी रखने की अनुमति देता है। एक बार परिणाम कॉलबैक फ़ंक्शन के माध्यम से आपके पास वापस आ जाता है, तो आप उस ऑपरेशन को चुन सकते हैं जहां यह छोड़ा गया था।







callback