कॉमन जावास्क्रिप्ट प्रॉमिस मैटर एब्रीब्यूड एबाउट नो हाउट नो अबाउट

शुभ दिन, दोस्तों!

मैं आपल शाह के लेख का अनुवाद आपके सामने प्रस्तुत करता हूं, "सामान्य जावास्क्रिप्ट प्रॉमिस करें कि हर शुरुआत को जानना और टालना चाहिए । "

कॉमन जावास्क्रिप्ट प्रॉमिस मैटर एब्रीब्यूड एबाउट नो हाउट नो अबाउट

जब मैंने जावास्क्रिप्ट और वादों का अध्ययन किया तो मैं इन त्रुटियों के बारे में जानना चाहूंगा।

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

इसलिए, इस लेख में मैं जेएस में वादों के साथ काम करते समय सबसे सामान्य त्रुटियों के बारे में बात करना चाहूंगा, जिन पर कई लोग ध्यान नहीं देते हैं।

गलती # 1. एक वादा के अंदर एक कोशिश / पकड़ ब्लॉक का उपयोग करना

वादे के अंदर ट्राइ / कैच ब्लॉक का उपयोग करना अव्यावहारिक है, क्योंकि यदि आपका कोड एक त्रुटि (वादे के अंदर) फेंकता है, तो यह वादे के त्रुटि हैंडलर द्वारा बाधित किया जाएगा।

इस बारे में यह है:

new Promise((resolve, reject) => { try { const data = someFunction() //   resolve() } catch(e) { reject(e) } }) .then(data => console.log(data)) .catch(error => console.log(error)) 

इसके बजाय, कोड को वादे के बाहर त्रुटि को संभालने दें:

 new Promise((resolve, reject) => { const data = someFunction() //   resolve(data) }) .then(data => console.log(data)) .catch(error => console.log(error)) 

यह हमेशा काम करेगा, सिवाय नीचे वर्णित के।

गलती नंबर 2. एक वादा के अंदर एक अतुल्यकालिक समारोह का उपयोग करना

एसिंक्रोनस फ़ंक्शन का उपयोग करते समय, कुछ अप्रिय दुष्प्रभाव प्रॉमिस के भीतर होते हैं।

मान लीजिए कि आप कुछ अतुल्यकालिक कार्य करने का निर्णय लेते हैं, तो वचन में "async" कीवर्ड जोड़ें, और आपका कोड एक त्रुटि फेंकता है। हालाँकि, अब आप .catch () या प्रतीक्षा के साथ इस त्रुटि को संभाल नहीं सकते हैं:

 //       new Promise(async() => { throw new Error('message') }).catch(e => console.log(e.message)) //        (async() => { try { await new Promise(async() => { throw new Error('message') }) } catch(e) { console.log(e.message) } })(); 

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

 new Promise(async(resolve, reject) => { try { throw new Error('message') } catch(error) { reject(error) } }).catch(e => console.log(e.message)) //   async/await (async() => { try { await new Promise(async(resolve, reject) => { try { throw new Error('message') } catch(error) { reject(error) } }) } catch(e) { console.log(e.message) } })(); 

गलती संख्या 3. .के बारे में भूल जाओ ()

यह उन त्रुटियों में से एक है जो परीक्षण शुरू होने तक आपके पास भी मौजूद नहीं हैं। या, यदि आप किसी भी नास्तिक हैं जो परीक्षणों में विश्वास नहीं करते हैं, तो आपका कोड निश्चित रूप से उत्पादन में दुर्घटनाग्रस्त हो जाएगा। क्योंकि उत्पादन सख्ती से मर्फी के नियम का पालन करता है , जिसमें कहा गया है: "जो कुछ भी गलत हो सकता है वह गलत होगा" - लगभग।

कोड को और अधिक सुरुचिपूर्ण बनाने के लिए, आप .then ()। Catch () का उपयोग करने के बजाय वादे को कोशिश / पकड़ में लपेट सकते हैं।

त्रुटि संख्या 4. Promise.all () का उपयोग न करें

Promise.all () आपका मित्र है।

यदि आप एक पेशेवर डेवलपर हैं, तो आप शायद समझें कि मैं क्या कहना चाहता हूं। यदि आपके पास एक-दूसरे पर निर्भर न करने के कई वादे हैं, तो आप उन्हें उसी समय निष्पादित कर सकते हैं। डिफ़ॉल्ट रूप से, वादों को समानांतर में निष्पादित किया जाता है, हालांकि यदि आपको उन्हें क्रमिक रूप से निष्पादित करने की आवश्यकता है (प्रतीक्षा का उपयोग करके), तो इसमें बहुत समय लगेगा। Promise.all () विलंबता को बहुत कम कर सकता है:

 const {promisify} = require('util') const sleep = promisify(setTimeout) async function f1() { await sleep(1000) } async function f2() { await sleep(2000) } async function f3() { await sleep(3000) } //   (async() => { console.time('sequential') await f1() await f2() await f3() console.timeEnd('sequential') //  6  })(); 

अब Promise.all के साथ ():

 (async() => { console.time('concurrent') await Promise.all([f1(), f2(), f3()]) console.timeEnd('concurrent') //  3  })(); 

गलती नं। 5. वादाखिलाफी का अनुचित उपयोग ()

Promise.race () हमेशा आपके कोड को तेज नहीं बनाता है।

यह अजीब लग सकता है, लेकिन यह वास्तव में है। मैं यह नहीं कह रहा हूं कि Promise.race () एक बेकार विधि है, लेकिन आपको स्पष्ट रूप से समझना चाहिए कि आप इसका उपयोग क्यों कर रहे हैं।

उदाहरण के लिए, आप किसी भी वादे को हल करने के बाद कोड को चलाने के लिए Promise.race () का उपयोग कर सकते हैं। लेकिन इसका मतलब यह नहीं है कि वादों का पालन करने वाले कोड का निष्पादन उनमें से किसी एक के समाधान के तुरंत बाद शुरू होगा। Promise.race () सभी वादों को हल करने के लिए प्रतीक्षा करेगा और उसके बाद ही धारा जारी करेगा:

 const {promisify} = require('util') const sleep = promisify(setTimeout) async function f1() { await sleep(1000) } async function f2() { await sleep(2000) } async function f3() { await sleep(3000) } (async() => { console.time('race') await Promise.race([f1(), f2(), f3()]) })(); process.on('exit', () => { console.timeEnd('race') //  3 ,    ! }) 

गलती नंबर 6. वादों का दुरुपयोग

वादे कोड को धीमा बनाते हैं, इसलिए उनका दुरुपयोग न करें।

अक्सर आपको अपने कोड को बेहतर बनाने के लिए एक लंबी .then () श्रृंखला का उपयोग करते हुए डेवलपर्स को देखना होगा। आपके पास आंख झपकाने का समय नहीं होगा, क्योंकि यह श्रृंखला बहुत लंबी हो जाती है। ऐसी स्थिति के नकारात्मक परिणामों को नेत्रहीन रूप से सत्यापित करने के लिए, यह आवश्यक है (आगे की प्रक्रिया मैं मूल पाठ से थोड़ा सा हटा दूंगा ताकि लेख की तुलना में अधिक विस्तार से प्रक्रिया का वर्णन किया जा सके। लगभग)।

1) निम्नलिखित सामग्री (अतिरिक्त वादों के साथ) के साथ एक script.js फ़ाइल बनाएँ:

 new Promise((resolve) => { //  ,    const user = { name: 'John Doe', age: 50, } resolve(user) }).then(userObj => { const {age} = userObj return age }).then(age => { if(age > 25) { return true } throw new Error('Age is less than 25') }).then(() => { console.log('Age is greater than 25') }).catch(e => { console.log(e.message) }) 

2) कमांड लाइन खोलें (विंडोज उपयोगकर्ताओं के लिए: वांछित फ़ाइल के साथ फ़ोल्डर में कमांड लाइन खोलने के लिए, Shift दबाए रखें, राइट-क्लिक करें, "ओपन कमांड विंडो" का चयन करें), निम्न कमांड का उपयोग करके script.js चलाएं (नोड स्थापित होना चाहिए। जे एस):

 node --trace-events-enabled script.js 

3) Node.js स्क्रिप्ट के साथ फ़ोल्डर में एक लॉग फ़ाइल (मेरे मामले में node_trace.1.txt) बनाता है;

4) ओपन क्रोम (क्योंकि यह केवल इसमें काम करता है), एड्रेस बार में "क्रोम: // ट्रेसिंग" दर्ज करें;

5) लोड पर क्लिक करें, Node.js द्वारा बनाई गई लॉग फ़ाइल को लोड करें;

6) वादा टैब खोलें।

हम कुछ इस तरह देखते हैं:


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

हम script.js को फिर से लिखते हैं:

 new Promise((resolve, reject) => { const user = { name: 'John Doe', age: 50, } if(user.age > 25) { resolve() } else { reject('Age is less than 25') } }).then(() => { console.log('Age is greater than 25') }).catch(e => { console.log(e.message) }) 

"ट्रेस" दोहराएं।

हम निम्नलिखित देखते हैं:


कम हरे रंग के ब्लॉक (वादे) हैं, जिसका अर्थ है कि कोड निष्पादन का समय कम हो गया है।

इस प्रकार, आपको कई वादों का उपयोग केवल तभी करना चाहिए जब आपको कुछ अतुल्यकालिक कोड निष्पादित करने की आवश्यकता हो।

आपका ध्यान के लिए धन्यवाद। एक अच्छा सप्ताहांत है! मुझे किसी भी टिप्पणी पर खुशी होगी।