Node.js
async.js

वाक्य - विन्यास

• प्रत्येक कॉलबैक को इस सिंटैक्स के साथ लिखा जाना चाहिए:

• फ़ंक्शन कॉलबैक (त्रुटि, परिणाम [, arg1 [, ...]])

• इस तरह, आपको पहले त्रुटि वापस करने के लिए मजबूर किया जाता है, और बाद में उन्हें संभालने की उपेक्षा नहीं कर सकता। त्रुटियों की अनुपस्थिति में null सम्मेलन है

• कॉलबैक (अशक्त, myResult);

• आपके कॉलबैक में इरेट और परिणाम की तुलना में अधिक तर्क हो सकते हैं, लेकिन यह केवल फ़ंक्शंस के एक विशिष्ट सेट (वाटरफॉल, सीवर, ...) के लिए उपयोगी है।

• कॉलबैक (अशक्त, myResult, myCustomArgument);

• और, बेशक, त्रुटियों को भेजें। आपको इसे करना होगा, और त्रुटियों को संभालना होगा (या कम से कम उन्हें लॉग इन करना होगा)।

• कॉलबैक (गलती);

समानांतर: मल्टी-टास्किंग

async.parallel (कार्य, afterTasksCallback) समानांतर में कार्यों का एक सेट निष्पादित करेगा और सभी कार्यों के अंत की प्रतीक्षा करेगा ( कॉलबैक फ़ंक्शन के कॉल द्वारा रिपोर्ट किया गया)।

जब कार्य समाप्त हो जाते हैं, तो async सभी त्रुटियों और कार्यों के सभी परिणामों के साथ मुख्य कॉलबैक कॉल करता है।

function shortTimeFunction(callback) {
  setTimeout(function() {
    callback(null, 'resultOfShortTime');
  }, 200);
}

function mediumTimeFunction(callback) {
  setTimeout(function() {
    callback(null, 'resultOfMediumTime');
  }, 500);
}

function longTimeFunction(callback) {
  setTimeout(function() {
    callback(null, 'resultOfLongTime');
  }, 1000);
}

async.parallel([
    shortTimeFunction,
    mediumTimeFunction,
    longTimeFunction
  ],
  function(err, results) {
    if (err) {
      return console.error(err);
    }

    console.log(results);
  });

परिणाम: ["resultOfShortTime", "resultOfMediumTime", "resultOfLongTime"] ।

किसी वस्तु के साथ async.parallel() को कॉल करें

आप किसी ऑब्जेक्ट द्वारा कार्य सरणी पैरामीटर को बदल सकते हैं। इस मामले में, परिणाम भी कार्यों की तुलना में समान कुंजी के साथ एक वस्तु होगी।

यह कुछ कार्यों की गणना करने और प्रत्येक परिणाम को आसानी से खोजने के लिए बहुत उपयोगी है।

async.parallel({
    short: shortTimeFunction,
    medium: mediumTimeFunction,
    long: longTimeFunction
  },
  function(err, results) {
    if (err) {
      return console.error(err);
    }

    console.log(results);
  });

परिणाम: {short: "resultOfShortTime", medium: "resultOfMediumTime", long: "resultOfLongTime"} ।

कई मूल्यों का समाधान

प्रत्येक समानांतर फ़ंक्शन को कॉलबैक दिया जाता है। यह कॉलबैक या तो पहले तर्क के रूप में एक त्रुटि लौटा सकता है या उसके बाद सफलता मान। यदि कॉलबैक को कई सफलता मान दिए जाते हैं, तो ये परिणाम एक सरणी के रूप में वापस आ जाते हैं।

async.parallel({
    short: function shortTimeFunction(callback) {
      setTimeout(function() {
        callback(null, 'resultOfShortTime1', 'resultOfShortTime2');
      }, 200);
    },
    medium: function mediumTimeFunction(callback) {
      setTimeout(function() {
        callback(null, 'resultOfMediumTime1', 'resultOfMeiumTime2');
      }, 500);
    }
  },
  function(err, results) {
    if (err) {
      return console.error(err);
    }

    console.log(results);
  });

परिणाम :

{
    short: ["resultOfShortTime1", "resultOfShortTime2"], 
    medium: ["resultOfMediumTime1", "resultOfMediumTime2"]
}

।

श्रृंखला: स्वतंत्र मोनो-टास्किंग

async.series (कार्य, afterTallsCallback) कार्यों का एक सेट निष्पादित करेगा। प्रत्येक कार्य को एक के बाद एक निष्पादित किया जाता है। यदि कोई कार्य विफल हो जाता है, तो async तुरंत निष्पादन बंद कर देता है और मुख्य कॉलबैक में कूद जाता है ।

जब कार्य सफलतापूर्वक समाप्त हो जाते हैं, तो async सभी त्रुटियों और कार्यों के सभी परिणामों के साथ "मास्टर" कॉलबैक कहता है।

function shortTimeFunction(callback) {
  setTimeout(function() {
    callback(null, 'resultOfShortTime');
  }, 200);
}

function mediumTimeFunction(callback) {
  setTimeout(function() {
    callback(null, 'resultOfMediumTime');
  }, 500);
}

function longTimeFunction(callback) {
  setTimeout(function() {
    callback(null, 'resultOfLongTime');
  }, 1000);
}

async.series([
    mediumTimeFunction,
    shortTimeFunction,
    longTimeFunction
  ],
  function(err, results) {
    if (err) {
      return console.error(err);
    }

    console.log(results);
  });

परिणाम: ["resultOfMediumTime", "resultOfShortTime", "resultOfLongTime"] ।

ऑब्जेक्ट के साथ async.series() को कॉल करें

आप किसी ऑब्जेक्ट द्वारा कार्य सरणी पैरामीटर को बदल सकते हैं। इस मामले में, परिणाम भी कार्यों की तुलना में समान कुंजी के साथ एक वस्तु होगी।

यह कुछ कार्यों की गणना करने और प्रत्येक परिणाम को आसानी से खोजने के लिए बहुत उपयोगी है।

async.series({
    short: shortTimeFunction,
    medium: mediumTimeFunction,
    long: longTimeFunction
  },
  function(err, results) {
    if (err) {
      return console.error(err);
    }

    console.log(results);
  });

परिणाम: {short: "resultOfShortTime", medium: "resultOfMediumTime", long: "resultOfLongTime"} ।

झरना: आश्रित मोनो-टास्किंग

async.waterfall (कार्यों, afterTallsCallback) कार्यों के एक सेट को निष्पादित करेगा। प्रत्येक कार्य को एक के बाद एक निष्पादित किया जाता है , और एक कार्य का परिणाम अगले कार्य को पारित किया जाता है । Async.series () के रूप में , यदि कोई कार्य विफल हो जाता है, तो async निष्पादन को रोक देता है और तुरंत मुख्य कॉलबैक कहता है।

जब कार्य सफलतापूर्वक समाप्त हो जाते हैं, तो async सभी त्रुटियों और कार्यों के सभी परिणामों के साथ "मास्टर" कॉलबैक कहता है।

function getUserRequest(callback) {
  // We simulate the request with a timeout
  setTimeout(function() {
    var userResult = {
      name : 'Aamu'
    };

    callback(null, userResult);
  }, 500);
}

function getUserFriendsRequest(user, callback) {
  // Another request simulate with a timeout
  setTimeout(function() {
    var friendsResult = [];

    if (user.name === "Aamu"){
        friendsResult = [{
          name : 'Alice'
        }, {
          name: 'Bob'
        }];
    }
    
    callback(null, friendsResult);
  }, 500);
}

async.waterfall([
    getUserRequest,
    getUserFriendsRequest
  ],
  function(err, results) {
    if (err) {
      return console.error(err);
    }

    console.log(JSON.stringify(results));
  });

परिणाम: results में झरने के अंतिम कार्य का दूसरा कॉलबैक पैरामीटर होता है, जो उस स्थिति में friendsResult है।

async.times (बेहतर तरीके से लूप को संभालने के लिए)

नोड में एक फंक्शन को निष्पादित करने के लिए। नोड्स में, लूप्स के for लूप का उपयोग करना ठीक है। लेकिन लूप लंबा है, लूप के for उपयोग करने से प्रसंस्करण का समय बढ़ जाएगा जो नोड प्रक्रिया को लटका सकता है। ऐसे परिदृश्यों में, आप उपयोग कर सकते हैं: asycn.times

function recursiveAction(n, callback)
{
    //do whatever want to do repeatedly
    callback(err, result);
}
async.times(5, function(n, next) {
    recursiveAction(n, function(err, result) {
        next(err, result);
    });
}, function(err, results) {
    // we should now have 5 result
});

इसे समानांतर में कहा जाता है। जब हम इसे एक बार में कॉल करना चाहते हैं, तो उपयोग करें: async.timesSeries

async.each (कुशलता से डेटा की सरणी को संभालने के लिए)

जब हम डेटा की सरणी को संभालना चाहते हैं, तो इसका उपयोग async.each करना बेहतर है। जब हम सभी डेटा के साथ कुछ करना चाहते हैं और सब कुछ हो जाने के बाद अंतिम कॉलबैक प्राप्त करना चाहते हैं, तो यह विधि उपयोगी होगी। इसे समानांतर तरीके से संभाला जाता है।

function createUser(userName, callback)
{
    //create user in db
    callback(null)//or error based on creation
}

var arrayOfData = ['Ritu', 'Sid', 'Tom'];
async.each(arrayOfData, function(eachUserName, callback) {

    // Perform operation on each user.
    console.log('Creating user '+eachUserName);
    //Returning callback is must. Else it wont get the final callback, even if we miss to return one callback
    createUser(eachUserName, callback);
  
}, function(err) {
    //If any of the user creation failed may throw error.
    if( err ) {
      // One of the iterations produced an error.
      // All processing will now stop.
      console.log('unable to create user');
    } else {
      console.log('All user created successfully');
    }
});

एक समय में एक करने के लिए async.eachSeries का उपयोग कर सकते हैं

async.series (एक-एक करके घटनाओं को संभालने के लिए)

/ Async.series में, सभी फ़ंक्शन श्रृंखला में निष्पादित किए जाते हैं और प्रत्येक फ़ंक्शन के समेकित आउटपुट को अंतिम कॉलबैक में पारित किया जाता है। उदा /

var async = आवश्यकता ('async'); async.series ([फंक्शन (कॉलबैक) {कंसोल.लॉग ('फर्स्ट एक्सक्यूट ..'); कॉलबैक (अशक्त, 'यूजरपर्सलडैटा');}; फंक्शन (कॉलबैक) {कंसोल.लॉग ('दूसरा एग्ज्यूट ..'); कॉलबैक (अशक्त, 'userD dependentData');}], फ़ंक्शन (इरेट, परिणाम) {कंसोल. (परिणाम);});

// आउटपुट:

पहला प्रदर्शन .. दूसरा निष्पादन .. ['userPersonalData', 'userD dependentData'] // परिणाम