यह नया jQuery.Callbacks ऑब्जेक्ट क्या है

JQuery 1.7 के बहुत पहले जारी किए गए संस्करण में, एक नया कॉलबैक ऑब्जेक्ट दिखाई दिया है, जिस पर आज चर्चा की जाएगी।
आधिकारिक jQuery.Callbacks प्रलेखन इसे एक बहुउद्देश्यीय वस्तु के रूप में वर्णित करता है, जो कॉलबैक फ़ंक्शन (कॉलबैक बस कॉलबैक कहलाता है) और इस सूची के प्रबंधन के लिए शक्तिशाली उपकरण की एक सूची है।

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

नियुक्ति

इस नए jQuery.Callbacks ऑब्जेक्ट का विस्तृत अध्ययन शुरू करने से पहले, मैं इस बात पर ध्यान देना चाहता हूं कि इस ऑब्जेक्ट की आवश्यकता क्यों है। अक्सर, जावास्क्रिप्ट कोड कॉलबैक का उपयोग करता है - फ़ंक्शन जब किसी घटना के होने पर कॉल किया जाता है, उदाहरण के लिए, एक कार्रवाई के पूरा होने के बाद, सबसे हड़ताली उदाहरण AJAX अनुरोध है। और एक ही समय में, अक्सर एक फ़ंक्शन को कॉल करने की आवश्यकता नहीं होती है, लेकिन एक बार में कई (यह अग्रिम में ज्ञात नहीं है कि कितने, शायद एक जोड़े, शायद एक दर्जन, या शायद कोई नहीं) - यह एक प्रसिद्ध और सरल "ऑब्जर्वर" पैटर्न है । और ऐसे मामलों के लिए, प्रश्न में jQuery.Callbacks ऑब्जेक्ट उपयोगी है। JQuery में, jQuery.Deferred और jQuery.ajax के अंदर इस ऑब्जेक्ट का उपयोग किया जाता है (संस्करण 1.7 के बाद से)। इसके अलावा, jQuery के लेखकों ने इस वस्तु को सार्वजनिक रूप से उपलब्ध कराया और इसे प्रलेखित किया ताकि अन्य डेवलपर्स अपने घटकों को लागू करते समय इसका उपयोग कर सकें।

निर्माता: jQuery.allbacks (झंडे)

कंस्ट्रक्टर को कॉल करके, कॉलबैक ऑब्जेक्ट बनाया जाता है, जिसमें कॉलबैक सूची के प्रबंधन के लिए कई तरीके हैं।
flags पैरामीटर वैकल्पिक है और आपको ऑब्जेक्ट के संचालन मापदंडों को सेट करने की अनुमति देता है, हम नीचे दिए गए पैरामीटर के संभावित मूल्यों पर विचार करेंगे।

 var callbacks = $.Callbacks(); 

निर्मित callbacks ऑब्जेक्ट के लिए, हम अब callbacks फ़ंक्शन को सूची में जोड़ सकते हैं, उन्हें हटा सकते हैं, उन्हें कॉल कर सकते हैं, उन्हें फिर से कॉल कर सकते हैं (यदि ऑब्जेक्ट बनाते समय यह निषिद्ध नहीं था), ऑब्जेक्ट की स्थिति की जांच करें (क्या पहले से कॉल था या अभी तक) ऑब्जेक्ट के ऐसे तरीकों का उपयोग करते हुए, जैसे add() , remove() , fire() , आदि कॉलबैक निष्पादित होते हैं, वैसे, जिस क्रम में उन्हें सूची में जोड़ा जाता है।

मैं ध्यान देता हूं कि यह वर्ग उदाहरण का "वास्तविक" निर्माता नहीं है, इसलिए new ऑपरेटर का उपयोग करते समय इसे कॉल करना आवश्यक नहीं है (और यहां तक ​​कि व्यर्थ)।

इस कारण से, यह सत्यापित करना संभव नहीं होगा कि ऑब्जेक्ट जेएस के लिए एक तरह से कॉलबैक का उदाहरण है या नहीं:

 if (obj instanceof $.Callbacks) { obj.add(fn); } 

के तहत एक अभिव्यक्ति अगर हमेशा झूठी लौट आती है। लेकिन आप इस ऑब्जेक्ट के ज्ञात तरीकों (या एक साथ कई) पर भरोसा कर सकते हैं, उदाहरण के लिए, आप इस तरह से जांच कर सकते हैं:

 if (obj.fire) { obj.add(fn); } 

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

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

 var c = $.Callbacks(), obj = {}; obj.register = c.add; obj.register(function() { console.log('fired'); }); c.fire(); // output: 'fired' 

झंडे

नोट : इसके बाद, " fire() कॉलिंग मेथड fire() मेथड" शब्द का अर्थ है, fireWith() मेथड सहित सूची से कॉलबैक निष्पादित करने के लिए कॉल।

flags कंस्ट्रक्टर पैरामीटर एक पंक्ति है जिसमें आप फ़्लैग निर्दिष्ट कर सकते हैं, रिक्त स्थान द्वारा अलग किए जा सकते हैं, विकल्प जिसके अनुसार बनाई गई callbacks ऑब्जेक्ट काम करेगी। निम्नलिखित झंडे समर्थित हैं:

एक बार - इंगित करता है कि कॉलबैक की सूची केवल एक बार ही की जा सकती है, दूसरी और बाद की कॉल fire() विधि अनिर्णायक होगी (जैसा कि आस्थगित वस्तु में किया गया है), यदि यह ध्वज निर्दिष्ट नहीं है, तो आप कई बार fire() विधि को कॉल कर सकते हैं।

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

अद्वितीय - इंगित करता है कि प्रत्येक कॉलबैक को केवल एक बार सूची में जोड़ा जा सकता है, कॉलबैक को सूची में जोड़ने का बार-बार प्रयास करने से कुछ नहीं होगा।

stopOnFalse - इंगित करता है कि सूची से कॉलबैक को रोक दिया जाना चाहिए यदि उनमें से एक fire() के चालू सत्र fire() कॉल के भीतर false । fire() लिए अगली कॉल fire() विधि एक नया कॉलबैक सूची निष्पादन सत्र शुरू करती है, और उन्हें तब तक फिर से निष्पादित किया जाएगा जब तक कि सूची में से एक false या समाप्त नहीं होता।

तरीकों

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

callbacks.add (कॉलबैक) रिटर्न: कॉलबैक - सूची में कॉलबैक जोड़ता है, आप इस विधि के तर्कों में कई फ़ंक्शन (कई तर्क) या फ़ंक्शन सरण (आप एक साथ दोनों) पारित कर सकते हैं, आप भी पास किए गए सरणियों को पास कर सकते हैं। सभी तर्क (या सरणी तत्व) जो कार्य नहीं हैं, उन्हें केवल अनदेखा कर दिया जाता है। एक विधि (यह और कुछ आगे) इसके कॉल के संदर्भ को लौटाता है, जिससे आप एक पंक्ति में एक वस्तु के कई तरीकों की कॉल की श्रृंखला को व्यवस्थित कर सकते हैं, जैसा कि jQuery में प्रथागत है।

callbacks.remove (कॉलबैक) रिटर्न: कॉलबैक - सूची से कॉलबैक हटाता है, और भले ही कॉलबैक दो बार जोड़ा गया हो, यह दोनों पदों से हटा दिया जाएगा। इस प्रकार यदि आप सूची से कुछ कॉलबैक को हटाने की विधि को कॉल करते हैं, तो आप यह सुनिश्चित कर सकते हैं कि यह सूची में नहीं है, चाहे कितनी बार जोड़ा जाए। आप एक ही समय में एक से अधिक तर्कों के साथ कई फ़ंक्शन पास कर सकते हैं, आप सरणियाँ पास नहीं कर सकते, गैर-फ़ंक्शंस के सभी तर्कों को अनदेखा किया जाता है।

callbacks.has (कॉलबैक) रिटर्न: बूलियन - चेकबैक सूची में निर्दिष्ट फ़ंक्शन है या नहीं, इसकी जांच करता है।

callbacks.empty () रिटर्न: कॉलबैक - कॉलबैक सूची को साफ़ करता है।

callbacks.disable () रिटर्न: कॉलबैक - कॉलबैक ऑब्जेक्ट को "डिस्कनेक्ट" करता है, इसके साथ सभी क्रियाएं असफल होंगी। इस मामले में, सभी विधियां बिल्कुल काम करना बंद कर देती हैं: add - कुछ भी नहीं करता है, has - हमेशा false लौटता false , आदि।

callbacks.disabled () रिटर्न: बूलियन - चेक करता है कि क्या कॉलबैक ऑब्जेक्ट अक्षम है, कॉलिंग disable() होने के बाद disable() true हो जाएगा।

callbacks.lock () रिटर्न: callbacks - कॉलबैक सूची के मापदंडों और निष्पादन स्थिति के सापेक्ष कॉलबैक ऑब्जेक्ट की वर्तमान स्थिति को कैप्चर करता है। मेमोरी फ्लैग का उपयोग करते समय यह विधि मान्य है और इसका उद्देश्य केवल बाद की कॉल को fire() रोकना है fire() , अन्य मामलों में यह disable() कॉलिंग disable() बराबर है।

विस्तार से, यह विधि इस तरह से काम करती है: यदि मेमोरी फ़्लैग निर्दिष्ट नहीं है या fire() विधि को कभी भी कॉल नहीं किया गया है या पिछले कॉलबैक सत्र को उनमें false एक false वापस करने पर बाधित किया गया था, तो lock() कॉल disable() कॉल disable() बराबर है (इसे कहा जाता है) अंदर) और इस मामले में disabled() में कॉल true हो जाएगी, अन्यथा केवल बाद की कॉल fire() अवरुद्ध हो जाएगी - वे न तो कॉलबैक का निष्पादन करेंगे, न ही अतिरिक्त कॉलबैक के निष्पादन मापदंडों के परिवर्तन ( स्मृति ध्वज की उपस्थिति में)।

callbacks.locked () रिटर्न: बूलियन - जाँचता है कि क्या कॉलबैक ऑब्जेक्ट lock() विधि का उपयोग करके lock() , तो disable() होने के बाद भी true हो जाता disable() कहा जाता है।

callbacks.fireWith ([संदर्भ] [, args]) रिटर्न: कॉलबैक - निर्दिष्ट संदर्भ और तर्कों के साथ सूची में सभी कॉलबैक का निष्पादन शुरू करता है। संदर्भ - कॉलबैक निष्पादन (फ़ंक्शन के अंदर इसके माध्यम से सुलभ एक वस्तु) के संदर्भ को इंगित करता है। आर्ग्स - कॉलबैक को पास किए गए तर्कों की एक सरणी (अर्थात् एक सरणी)।

callbacks.fire (तर्क) रिटर्न: कॉलबैक - इस पद्धति के कॉल संदर्भ और तर्कों के साथ सूची में सभी कॉलबैक का निष्पादन शुरू करता है। तर्कों - तर्कों की एक सूची (सरणी नहीं, जैसे कि fireWith() विधि में)। यानी कॉल संदर्भ और कॉलबैक तर्क fire() विधि के संदर्भ और तर्क हैं।

आप समान रूप से एक ही पैरामीटर और संदर्भ के साथ कॉलबैक निष्पादित करना कैसे शुरू कर सकते हैं इसका एक उदाहरण:

 var callbacks = $.Callbacks(), context = { test: 1 }; callbacks.add(function(p, t) { console.log(this.test, p, t); }); callbacks.fireWith(context, [ 2, 3 ]); // output: 1 2 3 context.fire = callbacks.fire; context.fire(2, 3); // output: 1 2 3 

सूची से कॉलबैक को उस क्रम में निष्पादित किया जाता है जिसमें उन्हें इस सूची में जोड़ा गया था। कॉलबैक को एक बार निर्दिष्ट ध्वज के साथ निष्पादित किए जाने के बाद , सूची को साफ़ कर दिया जाएगा, और यदि मेमोरी फ़्लैग निर्दिष्ट नहीं किया गया है या false वापस करके कॉलबैक को बाधित किया गया है, तो कॉलबैक ऑब्जेक्ट को disable() विधि द्वारा अक्षम कर दिया जाएगा।

उदाहरण

आइए देखें कि झंडे उदाहरणों पर कैसे काम करते हैं। सभी उदाहरण निम्नलिखित कार्यों का उपयोग करते हैं:

 function fn1( value ){ console.log( value ); } function fn2( value ){ fn1("fn2 says:" + value); return false; } 

$। कॉलबैक ():

 var callbacks = $.Callbacks(); callbacks.add( fn1 ); callbacks.fire( "foo" ); callbacks.add( fn2 ); callbacks.add( fn1 ); callbacks.fire( "bar" ); callbacks.remove( fn2 ); callbacks.fire( "foobar" ); console.log(callbacks.disabled()); /* output: foo bar fn2 says:bar bar foobar foobar false */ 

कोई ध्वज संकेत नहीं दिया - काफी अपेक्षित व्यवहार।

$। कॉलबैक ('एक बार'):

 var callbacks = $.Callbacks( "once" ); callbacks.add( fn1 ); callbacks.fire( "foo" ); callbacks.add( fn2 ); callbacks.add( fn1 ); callbacks.fire( "bar" ); callbacks.remove( fn2 ); callbacks.fire( "foobar" ); console.log(callbacks.disabled()); /* output: foo true */ 

यहां सब कुछ स्पष्ट है - एक बार जब उन्होंने पूरा कर लिया, तो कुछ भी नहीं हुआ, चाहे उन्होंने कुछ भी किया हो, क्योंकि सूची पहले से ही अक्षम है।

$। कॉलबैक ('मेमोरी'):

 var callbacks = $.Callbacks( "memory" ); callbacks.add( fn1 ); callbacks.fire( "foo" ); callbacks.add( fn2 ); callbacks.add( fn1 ); callbacks.fire( "bar" ); callbacks.remove( fn2 ); callbacks.fire( "foobar" ); console.log(callbacks.disabled()); /* output: foo fn2 says:foo foo bar fn2 says:bar bar foobar foobar false */ 

यहां, ऐसा लगता है, कुछ भी जटिल नहीं है - पहले निष्पादन के बाद, कॉलबैक के प्रत्येक जोड़ के कारण इसे तुरंत निष्पादित किया जाता है, और फिर हम पूरी सूची के निष्पादन को कहते हैं। उसी समय, हमने सूची में एक फ़ंक्शन को दो बार जोड़ा - यह दो बार काम करता है।

$। कॉलबैक ('अद्वितीय'):

 var callbacks = $.Callbacks( "unique" ); callbacks.add( fn1 ); callbacks.fire( "foo" ); callbacks.add( fn2 ); callbacks.add( fn1 ); callbacks.fire( "bar" ); callbacks.remove( fn2 ); callbacks.fire( "foobar" ); console.log(callbacks.disabled()); /* output: foo bar fn2 says:bar foobar false */ 

और इस मामले में, फ़ंक्शन fn1 के दोहराए गए जोड़ को अनदेखा किया गया था।

$। कॉलबैक ('स्टॉपऑनफ्लेस'):

 var callbacks = $.Callbacks( "stopOnFalse" ); callbacks.add( fn1 ); callbacks.fire( "foo" ); callbacks.add( fn2 ); callbacks.add( fn1 ); callbacks.fire( "bar" ); callbacks.remove( fn2 ); callbacks.fire( "foobar" ); console.log(callbacks.disabled()); /* output: foo bar fn2 says:bar foobar foobar false */ 

fn2 निष्पादन श्रृंखला को बाधित करता है, क्योंकि false लौटता false ।

ये सरल उदाहरण हैं, और अब आइए ध्वज संयोजन के साथ खेलने की कोशिश करें - यह थोड़ा और दिलचस्प होगा:

$। कॉलबैक ('एक बार मेमोरी'):

 var callbacks = $.Callbacks( "once memory" ); callbacks.add( fn1 ); callbacks.fire( "foo" ); callbacks.add( fn2 ); callbacks.add( fn1 ); callbacks.fire( "bar" ); callbacks.remove( fn2 ); callbacks.fire( "foobar" ); console.log(callbacks.disabled()); /* output: foo fn2 says:foo foo false */ 

हम देखते हैं कि केवल पहली fire() ने काम किया और नई कॉलबैक के अलावा पहले fire() के मापदंडों के साथ उनके तत्काल निष्पादन का नेतृत्व किया।

$। कॉलबैक ('एक बार मेमोरी यूनिक'):

 var callbacks = $.Callbacks( "once memory unique" ); callbacks.add( fn1 ); callbacks.fire( "foo" ); callbacks.add( fn2 ); callbacks.add( fn1 ); callbacks.fire( "bar" ); callbacks.remove( fn2 ); callbacks.fire( "foobar" ); console.log(callbacks.disabled()); /* output: foo fn2 says:foo foo false */ 

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

 callbacks.add( fn2, fn2, fn2 ); 

$। कॉलबैक ('एक बार मेमोरी स्टॉपऑनल्स'):

 var callbacks = $.Callbacks( "once memory stopOnFalse" ); callbacks.add( fn1 ); callbacks.fire( "foo" ); callbacks.add( fn2 ); callbacks.add( fn1 ); callbacks.fire( "bar" ); callbacks.remove( fn2 ); callbacks.fire( "foobar" ); console.log(callbacks.disabled()); /* output: foo fn2 says:foo true */ 

बाद के सभी कॉलबैक को false ब्लॉक करना और यदि एक बार ध्वज मौजूद है, तो यह आमतौर पर कॉलबैक ऑब्जेक्ट को निष्क्रिय कर देता है।

मैं झंडे के सभी संभावित संयोजनों पर विचार नहीं करूंगा, मैंने सबसे दिलचस्प (बहुत सरल नहीं) चुनने और कॉलबैक के व्यवहार की व्याख्या करने की कोशिश की। शेष संयोजनों को स्वतंत्र रूप से परीक्षण किया जा सकता है, उदाहरण के लिए, रिक्त का उपयोग करके: http://jsfiddle.net/zandroid/JXqzB/

सुधार का वादा किया

सुधार, ज़ाहिर है, सभी अनिवार्य नहीं है और यहां तक ​​कि, शायद, कुछ हद तक दूर-दूर तक, सख्ती से न्याय नहीं करते हैं।
सुधार का विचार fire() विधि कॉल को छोड़ना है, और इसके बजाय कॉलबैक ऑब्जेक्ट को फ़ंक्शन के रूप में उपयोग करना है। ऐसा करने के लिए, इस फ़ंक्शन को लिखें:

 (function($, undefined){ $.FCallbacks = function(flags, fns) { var i = $.type(flags) === 'string' ? 1 : 0, callbacks = $.Callbacks(i ? flags : undefined); callbacks.add(Array.prototype.slice.call(arguments, i)) return $.extend(callbacks.fire, callbacks, { fcallbacks: true }); }; })(jQuery); 

और आगे की हलचल के बिना, आइए उपयोग का एक उदाहरण देखें:

 function fn1(p1, p2) { console.log('fn1 says:', this, p1, p2); } function fn2(p1, p2) { console.log('fn2 says:', this, p1, p2); } var callbacks = $.FCallbacks('once', fn1, rn2); callbacks.add(fn2); callbacks(2, 3); 

साथ ही, नए "कंस्ट्रक्टर" को अतिरिक्त कॉल को add() बिना पैरामीटर में प्रारंभिक कॉलबैक को तुरंत पारित करने का अवसर भी था।
खैर, काम पर: jsfiddle.net/zandroid/RAVtF

आगामी छुट्टियों के साथ, आपका ध्यान देने के लिए धन्यवाद।

युपीडी:
टिप्पणियों से देखते हुए, मैं अभी भी व्यर्थ जानकारी के बारे में है कि यह वस्तु jQuery के अंदर कैसे उपयोग की जाती है। "बने हुए स्थगित - और यह इस तरह के और इस तरह के ढांचे में इस तरह की एक दोहरी है" या "इस कॉलबैक की आवश्यकता क्यों है" के बारे में टिप्पणियां - केवल jQuery पुस्तकालय को अधिक वजनदार बनाता है, लेकिन असली अनुप्रयोगों के साथ नहीं आता है "- ये, मेरी राय में, टिप्पणी नहीं हैं मामले के सार को समझना। नीचे, मैं इस बिंदु को स्पष्ट करना चाहता हूं।

वास्तविक उपयोग

कॉलबैक वास्तव में अब बहुत सारे jQuery 1.7+ उपयोगकर्ताओं द्वारा उपयोग किया जाता है और विकास टीम द्वारा आसान नहीं बनाया गया था क्योंकि वे एक नई सुविधा बनाना चाहते थे। देखें, इस प्रश्न की श्रृंखला और तर्क बहुत सरल है:

लाइब्रेरी में $.ajax() पद्धति लागू की गई थी, जो इसकी प्रकृति द्वारा एक निश्चित Deferred पर ऐड-ऑन से अधिक कुछ नहीं है - डेवलपर्स ने कोड में सुधार किया, इसे मुख्य $.ajax() कोड (पुन: उपयोग और परीक्षण के सरलीकरण की संभावना के लिए $.ajax() से अलग कर दिया। फैसला किया, क्यों नहीं इस कोड को प्रकाशित किया जाए (लाइब्रेरी उपयोगकर्ताओं को इसे एक्सेस करें और इसे दस्तावेज दें) - यह $.Deferred बाहर हो गया।

बदले में, $.Deferred शुरू में दो होते हैं ( done() और fail() , और अब कॉलबैक पर तीन (+ अभी भी progress() ) ऐड-ऑन हैं, जिसे $.Deferred आंतरिक कोड के रूप में बनाया गया था। और फिर, डेवलपर्स ने इस कोड को $.Deferred से बेहतर बनाया और अलग किया। बाद वाले को $.Callbacks (वैसे, $.Deferred का स्रोत कोड एक ही समय में अधिक स्पष्ट और पठनीय हो गया) को लागू करके अलग कर दिया।

निष्कर्ष: डेवलपर्स अपने मुख्य लक्ष्य को नई "बेकार" सुविधाओं के अतिरिक्त के रूप में सेट नहीं करते हैं, वे मौजूदा आंतरिक कोड का अनुकूलन करते हैं, साथ ही साथ माध्यमिक प्रकाशित करते हैं, लेकिन इस परिणाम से कम उपयोगी नहीं है। और हर बार जब आप $.ajax() उपयोग करते हैं - आप जानते हैं, आप $.Deferred और इसलिए $.Callbacks । $.Callbacks । यह वास्तविक उपयोग का एक उदाहरण है।