लेन-देन सहायक के साथ नेवला पास डेटा

ऐसा लगता है कि यहां कुछ भ्रम है कि कैसे कई स्तरों पर वादों का सही उपयोग किया जाए।

कॉलबैक और प्रॉमिस का गलत इस्तेमाल किया जा रहा है

यदि फ़ंक्शन को कॉलबैक स्वीकार करना है, तो वादा वापस न करें। यदि फ़ंक्शन को वादा वापस करना है, तो वादा द्वारा दिए गए कॉलबैक का उपयोग करें:

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 उनमें से कोई भी, आपको एक मान वापस कर दिया जाएगा, या एक अपवाद फेंक दिया जाएगा।