मैंने सुना है कि कॉलबैक ("कॉलबैक नरक") के विरोध में वादों को कोड में रैखिक माना जाता है।

हालांकि मेरे पास अभी भी कॉलबैक नरक के समान एक परिदृश्य है और उम्मीद के वादे अपना वादा कर सकते हैं और इस समस्या कोड के बराबर एक रैखिक वाक्यविन्यास है।

दिए गए वादे p(), q(),w() इस कोड पर विचार करें:

p().then(() => {
    q().then(() => {
       w().then(() => {
           // do something
       })
    })
})

क्या हम एक समान कोड बना सकते हैं जो हर नेस्टेड वादे के लिए इंडेंट नहीं है?

1
Aladin 31 पद 2020, 02:00

3 जवाब

सबसे बढ़िया उत्तर

आपको .then() हैंडलर को नेस्ट नहीं करना चाहिए, लेकिन प्रत्येक .then() को एक नया Promise. इस तरह इसे काम करने के लिए डिज़ाइन किया गया था, अन्यथा आप अभी भी कॉलबैक नरक में हैं, अब वादों वाला संस्करण। कोई बड़ा अंतर नहीं।

कोड इस तरह होना चाहिए:

p()
  .then(() => {
    return q();
  })
  .then(() => {
    return w();
  })
  .then(() => {
    // do something
  });

यदि .then() हैंडलर केवल अगले फ़ंक्शन को कॉल करने के लिए करते हैं, तो आप इसे सरल रूप में लिख सकते हैं (एरो फंक्शन):

p()
  .then(() => q())
  .then(() => w())
  .then(() => {
    // do something
  });

इससे भी अधिक, यदि q और w को बिना तर्क के कॉल किया जाता है, तो कोड इतना सरल हो सकता है:

p()
  .then(q)
  .then(w)
  .then(() => {
    // do something
  });

या आप .then() और .catch() आप का इस्तेमाल करते हैं await. कोड और भी स्पष्ट और पढ़ने में आसान हो जाता है:

try {
  await p();
  await q();
  await w();
  // do something
} catch (err) {
  // write here the code you would write in the handler you pass to `.catch()
  // in the approach that uses Promises
}

टिप्पणियां

यदि उपरोक्त कोड, await का उपयोग करते हुए, किसी फ़ंक्शन में उपयोग किया जाता है, तो वह फ़ंक्शन एक async फंक्शन (बस async को इसकी परिभाषा के सामने रखें)।

await का उपयोग करने वाला कोड हो सकता है या इसे चलाने के लिए आपके द्वारा उपयोग किए जाने वाले रनटाइम (ब्राउज़र, Node.js आदि) के आधार पर किसी फ़ंक्शन के बाहर (यानी मॉड्यूल के शीर्ष स्तर पर) उपयोग नहीं किया जा सकता है।

2
axiac 31 पद 2020, 02:27

जैसा कि एक अन्य उपयोगकर्ता ने उल्लेख किया है, आप async/await का उपयोग कर सकते हैं, लेकिन दूसरा विकल्प यह है कि आपके पास जो कुछ है उसे थोड़ा सा पुनर्गठित करें। यहां कुछ उदाहरण दिए गए हैं कि क्या काम कर सकता है - इस पर निर्भर करता है कि आपको डेटा के कुछ टुकड़ों की आवश्यकता कहां और कब है:

p()
  .then(q)
  .then(w)

// OR

p()
  .then(() => q())
  .then(() => w())

स्पष्ट रूप से यह थोड़ा अधिक जटिल हो जाता है यदि w() को p() और q() दोनों से डेटा की आवश्यकता होती है, लेकिन इसका सार यही है।

3
Pytth 31 पद 2020, 02:11

आप async/await का उपयोग करने का प्रयास कर सकते हैं, जो अधिक क्लीनर कोड छोड़ता है। यह इस प्रकार होगा:

(async () => {
    try {
        await p();
        await q();
        await w();
    } catch (e) {
        // handle error
    }
})()

यदि प्रत्येक वादे के बीच कोई निर्भरता नहीं है तो आप "सभी या कुछ नहीं" करने के लिए await Promise.all का उपयोग कर सकते हैं। किसी भी अन्य मामले में, आप लौटाए गए मूल्य को स्टोर कर सकते हैं और यदि आवश्यक हो तो उपयोग करने के लिए इसे अगले फ़ंक्शन में पास कर सकते हैं।

1
luckongas 31 पद 2020, 02:15