ऐसा लगता है कि यहां कुछ भ्रम है कि कैसे कई स्तरों पर वादों का सही उपयोग किया जाए।
कॉलबैक और प्रॉमिस का गलत इस्तेमाल किया जा रहा है
यदि फ़ंक्शन को कॉलबैक स्वीकार करना है, तो वादा वापस न करें। यदि फ़ंक्शन को वादा वापस करना है, तो वादा द्वारा दिए गए कॉलबैक का उपयोग करें:
const transactionSession = await mongoose.startSession()
await transactionSession.withTransaction( (tSession) => {
return new Promise( (resolve, reject) => {
//using Node-style callback
doSomethingAsync( (err, testData) => {
if(err) {
reject(err);
} else {
resolve(testData); //this is the equivalent of cb(null, "Any test data")
}
});
})
आइए इसे और विस्तार से देखें:
return new Promise( (resolve, reject) => {
यह एक नया वादा बनाता है, और वादा आपको उपयोग करने के लिए दो कॉलबैक दे रहा है। resolve
सफलता का संकेत देने के लिए एक कॉलबैक है। आप इसे वह ऑब्जेक्ट पास करते हैं जिसे आप वापस करना चाहते हैं। ध्यान दें कि मैंने async
को हटा दिया है कीवर्ड (इस पर बाद में)।
उदाहरण के लिए:
const a = new Promise( (resolve, reject) => resolve(5) );
a.then( (result) => result == 5 ); //true
(err, testData) => {
इस फ़ंक्शन का उपयोग नोड-शैली को मैप करने के लिए किया जाता है cb(err, result)
प्रॉमिस के कॉलबैक के लिए।
कोशिश/पकड़ने का गलत उपयोग किया जा रहा है।
ट्राई/कैच का उपयोग केवल सिंक्रोनस स्टेटमेंट के लिए किया जा सकता है। आइए एक सिंक्रोनस कॉल, एक नोड-शैली (यानी cb(err, result)
की तुलना करें। ) अतुल्यकालिक कॉलबैक, एक वादा, और प्रतीक्षा का उपयोग करना:
- तुल्यकालिक:
try {
let a = doSomethingSync();
} catch(err) {
handle(err);
}
- असिंक:
doSomethingAsync( (err, result) => {
if (err) {
handle(err);
} else {
let a = result;
}
});
- वादा:
doSomethingPromisified()
.then( (result) => {
let a = result;
})
.catch( (err) => {
handle(err);
});
- प्रतीक्षा करें। प्रतीक्षा का उपयोग किसी भी फ़ंक्शन के साथ किया जा सकता है जो एक वादा लौटाता है, और आपको कोड को इस तरह से संभालने देता है जैसे कि यह तुल्यकालिक था:
try {
let a = await doSomethingPromisified();
} catch(err) {
handle(err);
}
अतिरिक्त जानकारी
Promise.resolve()
Promise.resolve()
एक नया वादा बनाता है और उस वादे को एक अपरिभाषित मूल्य के साथ हल करता है। यह इसके लिए आशुलिपि है:
new Promise( (resolve, reject) => resolve(undefined) );
इसका कॉलबैक समतुल्य होगा:
cb(err, undefined);
async
async
साथ जाता है await
. यदि आप await
का उपयोग कर रहे हैं किसी फ़ंक्शन में, उस फ़ंक्शन को async
. घोषित किया जाना चाहिए ।
ठीक वैसे ही जैसे await
एक वादा खोलता है (resolve
एक मान में, और reject
एक अपवाद में), async
लपेटता है एक वादे में कोड। एक return value
कथन का अनुवाद Promise.resolve(value)
. में हो जाता है , और एक फेंका हुआ अपवाद throw e
Promise.reject(e)
. में अनुवादित हो जाता है ।
निम्नलिखित कोड पर विचार करें
async () => {
return doSomethingSync();
}
उपरोक्त कोड इसके बराबर है:
() => {
const p = new Promise(resolve, reject);
try {
const value = doSomethingSync();
p.resolve(value);
} catch(e) {
p.reject(e);
}
return p;
}
यदि आप उपरोक्त कार्यों में से किसी एक को await
के बिना कॉल करते हैं , आपको एक वादा वापस मिलेगा। अगर आप await
उनमें से कोई भी, आपको एक मान वापस कर दिया जाएगा, या एक अपवाद फेंक दिया जाएगा।