कोणीय.जेएस में वादे का समुचित उपयोग

कोणीय.जे का उपयोग करने की प्रक्रिया में $ क्यू ऑब्जेक्ट के बिना करना मुश्किल है (यह भी एक वादा / स्थगित है), क्योंकि यह पूरे ढांचे को रेखांकित करता है। आस्थगित तंत्र एक बहुत ही सरल और शक्तिशाली उपकरण है जो आपको संक्षिप्त कोड लिखने की अनुमति देता है। लेकिन वास्तव में इस शक्ति का उपयोग करने के लिए, आपको इस उपकरण की सभी विशेषताओं के बारे में जानना होगा।

यहां कुछ बिंदु दिए गए हैं जिनके बारे में आप नहीं जानते होंगे।

---

1. फिर हमेशा एक नया वादा वापस करता है

एक उदाहरण देखें:

function asyncFunction() { var deferred = $q.defer(); doSomethingAsync().then(function(res) { res = asyncManipulate(res); deferred.resolve(res); }, function(err) { deferred.reject(err); }); return deferred.promise; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

$q.defer()



का एक नया वादा निरर्थक रूप से यहां बनाया गया है। कोड के लेखक को स्पष्ट रूप से नहीं पता था कि तब वह एक वादा वापस करेगा। कोड में सुधार करने के लिए, बस तत्कालीन परिणाम लौटाएँ:

 function asyncFunction() { return doSomethingAsync().then(function(res) { return asyncManipulate(res); }); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

2. वादे का परिणाम "हारा नहीं है"

एक उदाहरण फिर से:

 function asyncFunction() { return doSomethingAsync().then(function(res) { return asyncManipulate(res); }, function(err) { return $q.reject(err); }); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

doSomethingAsync



फ़ंक्शन doSomethingAsync



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

 function asyncFunction() { return doSomethingAsync().then(function(res) { return asyncManipulate(res); }); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यदि आप केवल अस्वीकार मामले को हैंडल करना चाहते हैं, तो आप रिज़ॉल्यूशन प्रोसेसिंग को भी छोड़ सकते हैं:

 function asyncFunction() { return doSomethingAsync().then(null, function(err) { return errorHandler(err); }); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

वैसे, इस तरह के एक मामले के लिए, सिंटैक्टिक चीनी है:

 function asyncFunction() { return doSomethingAsync().catch(function(err) { return errorHandler(err); }); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

3. आप केवल $ q.reject () लौटाकर अस्वीकृत हैंडलर प्राप्त कर सकते हैं

कोड:

 asyncFunction().then(function (res) { // some code return res; }, function (res) { // some code }).then(function (res) { console.log('in resolve'); }, function (res) { console.log('in reject'); });
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस उदाहरण में, कोई फर्क नहीं पड़ता कि कैसे asyncFunction



फ़ंक्शन asyncFunction



, कंसोल में हम ' asyncFunction



' में देखेंगे। ऐसा इसलिए है क्योंकि अस्वीकार हैंडलर में समाप्त होने का केवल एक ही तरीका है - $ q.reject () लौटें। किसी भी अन्य मामलों में, संकल्प हैंडलर को बुलाया जाएगा। हम कोड को फिर से लिखते हैं ताकि हम कंसोल में 'अस्वीकार में' देखें यदि asyncFunction



रिटर्न अस्वीकार करता है:

 asyncFunction().then(function (res) { // some code return res; }, function (res) { // some code return $q.reject(res); }).then(function (res) { console.log('in resolve'); }, function (res) { console.log('in reject'); });
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

4. आखिरकार वादे का नतीजा नहीं बदलता

 asyncFunction().then(function (res) { importantFunction(); return res; }, function (err) { importantFunction(); return $q.reject(err); }).then(function (res) { // some resolve code }, function (err) { // some reject code })
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

 asyncFunction().finally(function () { importantFunction(); }).then(function (res) { // some resolve code }, function (err) { // some reject code })
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यदि अंत में हैंडलर $ q.reject () लौटाता है, तो अस्वीकार हैंडलर को अगला कहा जाएगा। संकल्प हैंडलर को कॉल करने का कोई गारंटी तरीका नहीं है।

5. $ q.all समानांतर में कार्य करता है

नेस्टेड कॉल चेन पर विचार करें:

 loadSomeInfo().then(function(something) { loadAnotherInfo().then(function(another) { doSomethingOnThem(something, another); }); });
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

doSomethingOnThem



फ़ंक्शन को loadSomeInfo



और loadAnotherInfo



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



फ़ंक्शन को कॉल किया जाए। इसका मतलब है कि इन कार्यों को समानांतर में कहा जा सकता है। लेकिन इस कोड के लेखक को स्पष्ट रूप से $ q.all पद्धति के बारे में नहीं पता था। हम फिर से लिखते हैं:

 $q.all([loadSomeInfo(), loadAnotherInfo()]).then(function (results) { doSomethingOnThem(results[0], results[1]); });
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

$ q.all समानांतर में चलाए जाने वाले कार्यों की एक सरणी को स्वीकार करता है। $ Q.all द्वारा दिए गए वादे को तब कहा जाएगा जब सरणी के सभी कार्य पूरे हो जाएंगे। परिणाम परिणाम की एक सरणी के रूप में उपलब्ध होगा, जिसमें क्रमशः सभी कार्यों के परिणाम शामिल हैं।

इसलिए, $ q.all पद्धति का उपयोग उन मामलों में किया जाना चाहिए जहां अतुल्यकालिक कार्यों के निष्पादन को सिंक्रनाइज़ करना आवश्यक है।

6. $ q.when एक वादे में सब कुछ बदल देता है

ऐसी परिस्थितियाँ होती हैं जब कोड एसिंक्रोनस फ़ंक्शन पर निर्भर हो सकता है, और सिंक्रोनस पर निर्भर हो सकता है। और फिर आप कोड में व्यवस्था बनाए रखने के लिए सिंक्रोनस फ़ंक्शन पर एक आवरण बनाते हैं:

 var promise; if (isAsync){ promise = asyncFunction(); } else { var localPromise = $q.defer(); promise = localPromise.promise; localPromise.resolve(42); } promise.then(function (res) { // some code });
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस कोड में कुछ भी गलत नहीं है। लेकिन इसे साफ करने का एक तरीका है:

 $q.when(isAsync? asyncFunction(): 42).then(function (res) { // some code });
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

$ q.when एक प्रकार का प्रॉक्सी फ़ंक्शन है जो वादे या नियमित मूल्य को स्वीकार करता है, और हमेशा वादा वापस करता है।

7. वादा में सही त्रुटि को संभालने

आइए एक अतुल्यकालिक फ़ंक्शन में त्रुटि से निपटने के एक उदाहरण को देखें:

 function asyncFunction(){ return $timeout(function meAsynk(){ throw new Error('error in meAsynk'); }, 1); } try{ asyncFunction(); } catch(err){ errorHandler(err); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

क्या आपको यहां कोई समस्या दिखाई देती है? कोशिश / कैच ब्लॉक केवल उन त्रुटियों को पकड़ लेगा जो तब होती हैं जब asyncFunction



फ़ंक्शन asyncFunction



। लेकिन, $timeout



शुरू होने के बाद, कॉलबैक फ़ंक्शन meAsynk



शुरू होता है, वहां होने वाली सभी त्रुटियां meAsynk



एप्लिकेशन त्रुटियों (एप्लिकेशन के अनक्रेडेड अपवाद हैंडलर) के हैंडलर में गिर जाएंगी। इस हिसाब से हमारे कैच हैंडलर को कोई पहचान नहीं पाता है।

इसलिए, कोशिश / पकड़ने में अतुल्यकालिक कार्यों को लपेटना बेकार है। लेकिन ऐसी स्थितियों में क्या करना है? ऐसा करने के लिए, एसिंक्रोनस फ़ंक्शंस में त्रुटियों को संभालने के लिए एक विशेष कॉलबैक होना चाहिए। $ Q में, ऐसा हैंडलर अस्वीकार हैंडलर है।

हम कोड को फिर से करेंगे ताकि त्रुटि हैंडलर में दिखाई दे (हम ऊपर वर्णित catch



चीनी का उपयोग करते हैं):

 function asyncFunction(){ return $timeout(function meAsynk(){ throw new Error('error in meAsynk'); }, 1); } asyncFunction().catch(function (err) { errorHandler(err); });
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक अन्य उदाहरण पर विचार करें:

 function asyncFunction() { var promise = doSomethingAsync(); promise.then(function() { return somethingAsyncAgain(); }); return promise; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस कोड में एक समस्या है: अगर somethingAsyncAgain



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

 function asyncFunction() { return doSomethingAsync().then(function() { return somethingAsyncAgain(); }); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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



आइए इस उदाहरण को देखें:

 asyncFunction().then( function() { return somethingElseAsync(); }, function(err) { errorHandler(err); });
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ऐसा लगता है कि इस बार सब कुछ सही है। लेकिन अगर फंक्शन में somethingElseAsync



, तो वह किसी को भी प्रोसेस नहीं करेगा। हम कोड को फिर से लिखते हैं ताकि अस्वीकार हैंडलर अलग हो जाए:

 asyncFunction().then(function() { return somethingElseAsync(); }).catch(function(err) { errorHandler(err); });
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अब जो भी त्रुटि होगी, उस पर कार्रवाई की जाएगी।

पुनश्च

$ Q सेवा वादों / A + मानक का कार्यान्वयन है। गहरी समझ के लिए, मैं इस मानक को पढ़ने की सलाह देता हूं।

यह भी ध्यान देने योग्य है कि jQuery में वादा कार्यान्वयन वादा / ए + मानक से अलग है। जो लोग इन अंतरों में रुचि रखते हैं वे इस लेख से खुद को परिचित कर सकते हैं।