सिंक्रोनस नोड.जेएस से प्रश्न

अनुक्रमिक एसिंक्रोनस संचालन चलाने के लिए आप नोड.जेएस में कुछ डिज़ाइन पैटर्न का उपयोग कर सकते हैं। उन सभी में, आप कुछ होने की प्रतीक्षा में एक तंग लूप नहीं चला सकते हैं - आपको नोड.जेएस में एकल जावास्क्रिप्ट थ्रेड को चलाने देना होगा और इसे अधिक से अधिक चक्र देना होगा।

मैन्युअल पुनरावृत्ति

स्थानीय फ़ंक्शन में पुनरावृत्ति के लिए कोड डालें (मैं आमतौर पर इसे next() . कहता हूं ) और फिर जब एक पुनरावृत्ति अपने अंतिम समापन फ़ंक्शन को कॉल करती है, तो आप next() . पर कॉल कर सकते हैं अगला पुनरावृत्ति शुरू करने के लिए फिर से। आप किसी शर्त का परीक्षण करके और next() . पर कॉल न करके ऑपरेशन को पूरा कर सकते हैं अगर चीजें पूरी हो जाती हैं या next() . की पहली पंक्तियाँ यह देखने के लिए परीक्षण कर सकते हैं कि आपका काम हो गया है या नहीं।

मैन्युअल पुनरावृत्ति के साथ आपका कोड कैसा दिखेगा, इसके लिए नीचे दिया गया कोड उदाहरण देखें।

अनुक्रम वादे

यदि आप अपने अतुल्यकालिक संचालन के लिए वादों का उपयोग करते हैं, तो आप जंजीर वाले वादों को आपके लिए अपनी सभी अनुक्रमण करने दे सकते हैं जैसा कि p().then(f1).then(f2).then(f3) में है। . इसका एक उदाहरण आप इस उत्तर में देख सकते हैं:">async.each जैसे वादे ।

Async मॉड्यूल का उपयोग करें

Async मॉड्यूल कई async प्रबंधन कार्यों का समर्थन करता है। कई लोग इसे बहुत उपयोगी पाते हैं - अन्य समान समस्याओं को हल करने के लिए वादों का उपयोग करना पसंद करेंगे। किसी भी मामले में, अनुक्रमण के लिए इसके कई अलग-अलग कार्य हैं। उदाहरण के लिए यदि आप किसी सरणी को अतुल्यकालिक रूप से पुनरावृति करना चाहते हैं, तो आप कुछ इस तरह का उपयोग करेंगे:

async.eachSeries(hugeArray, function iterator(item, callback) {
  if (inCache(item)) {
    callback(null, cache[item]); // if many items are cached, you'll overflow
  } else {
    doSomeIO(item, callback);
  }
}, function done() {
  //...
});

यहां आपके कोड का एक संस्करण है जो एक कस्टम next() . का उपयोग करके मैन्युअल पुनरावृत्ति करता है पुनरावृत्ति समारोह।

function runQuery(callback) {
    mysql.getConnection(function(err, connection) {
        if (err) {
            connection.release();
            callback(err);
            return;
        }

        var array = [];
        var count = 10;
        var index = 0;

        function next() {
            if (index++ < count) {
                array.push([index, 'master']);
                console.log('100-elements');
                connection.beginTransaction(function(err) {
                    if (err) {
                        // can't throw here in an async function
                        // use callback to communicate error
                        callback(err);
                        return;
                    }

                    var query = "insert into users(username, password) values ?";
                    connection.query(query, [array], function(err, rows) {

                        if (!err) {
                            //commit start
                            connection.commit(function() {
                                if (err) {
                                    console.error(err);
                                    connection.rollback(function() {
                                        console.error('rollback error');
                                        callback(err);
                                        return;
                                    });
                                } else {
                                    console.log("Commit");
                                    // now do the next iteration
                                    next();
                                } // if err
                            }); //commit end
                        } else {
                            console.log(err);
                            connection.rollback(function() {
                                callback(err);
                                return;
                            });
                        } // if                    
                    });
                });
            }
        }
    });
}