Detaillierte Erläuterung der asynchronen Verarbeitung mithilfe von Node Async

Dieses Mal werde ich Ihnen eine detaillierte Erklärung der asynchronen Verarbeitung von Knoten Async geben. Was sind die Vorsichtsmaßnahmen für die detaillierte Erklärung der asynchronen Verarbeitung von Knoten Async? Fall, werfen wir einen Blick darauf.

Ich habe kürzlich NodeJS studiert und bin zutiefst davon überzeugt, dass ... Menschen auf der Erde, die mit JS-Code vertraut sind, wissen, dass die Ladereihenfolge von JS sehr wichtig ist! Sehr wichtig! ! Dann kommt die Frage: Beim Schreiben von Knoten werden viele Schnittstellen im Hintergrund angefordert (unsere Firma überträgt Daten mit dem Java-Hintergrund) und die Schnittstelle wird einen Rückruf haben. Was soll ich mit so vielen Rückrufen tun? Der Umgang mit der Ladereihenfolge ist ein Problem ... Es ist unmöglich zu verschachteln ... Verschachteln ... Machen wir das, es wird sehr mühsam! ! Warum gibt es für ein so großes Problem keine Lösung?

Asynchrones asynchrones Verarbeitungsmodul!

Das Folgende ist das Verständnis des kleinen Sam:

Die Installation ist sehr einfach, genau wie ein normales Installationsmodul

Die Installation ist erfolgreich! Der nächste Schritt besteht darin, durch auf das Modul im Code zu verweisen:

var async = require('async');

Es ist in Ordnung, so zu zitieren! Sie können ganz einfach das asynchrone Objektmodul hinter dem Code verwenden!

Ich habe die offizielle Dokumentation überprüft und festgestellt, dass dieses Modul zu viele Methoden enthält! Es ist schwindelerregend zu sehen...

Lassen Sie uns über einige Methoden sprechen, die nach Ansicht des Herausgebers häufiger verwendet werden

Serie

1.series(tasks, [callback]) führt die Funktionen im Array und in der Sammlung nacheinander aus. Wenn die vorherige Funktion ausgeführt wird, wird die nächste Funktion sofort ausgeführt. Wenn die Funktion einen Fehler auslöst, kann dies in der Callback-Funktion überprüft werden , andernfalls werden weiterhin Aufgaben ausgeführt

Es ist sinnlos, zu viel zu reden, Code ist der wahre Vater

Anwendungsfall:

//tasks传的是一个数组函数
async.series([
  function(callback) {
  // do some stuff ...
  callback(null, 'one');
},
 function(callback) {
 // do some more stuff ...
 callback(null, 'two');
}],
// optional callback
//我觉得这里很重要err是上面两个函数的错误信息，而results这个参数是一个数组对象，它们的值是上面数组函数每个callback里面的参数。
function(err, results) {
// results is now equal to ['one', 'two']
});
// an example using an object instead of an          
//下面的代码其实跟上面的差不多，只是stasks传的是对象而不是数组
async.series({
one: function(callback) {
  setTimeout(function() {
    callback(null, 1);
  },
  200);
},
two: function(callback) {
  setTimeout(function() {
    callback(null, 2);
  },
  100);
 }
},
function(err, results) {
// results is now equal to: {one: 1, two: 2}
});

parallel

2.parallel(tasks, [callback])  Methoden in Arrays und Sammlungen parallel ausführen. Es ist nicht erforderlich, zu warten, bis die vorherige Funktion ausgeführt wird, bevor die nächste Funktion ausgeführt wird. Wenn die Funktion einen Fehler auslöst, kann dies überprüft werden Rückruffunktion

 async.parallel(
[
 function(callback) {
  setTimeout(function() {
     callback(null, 'one');
    },
  200);
 },
 function(callback) {
  setTimeout(function() {
    callback(null, 'two');
  },
  100);
 }
],
 // optional callback
 function(err, results) {
  // the results array will equal ['one','two'] even thoug
  // the second function had a shorter       
  timeout
 }
);

parallelLimit

3.parallelLimit(tasks, limit, [callback]) Die Verwendung ist die gleiche wie bei 2, außer dass es eine zusätzliche Beschränkung für die Anzahl der Aufgaben gibt, die maximale Anzahl von Aufgaben, die parallel ausgeführt werden dürfen

während

4.whilst(test, fn, callback)  Entspricht der Verwendung von while, der erste Parameter ist die Überprüfungsbedingung, der zweite Parameter ist die Ausführungsfunktion und der dritte Parameter ist die Rückruffunktion nach der Überprüfung schlägt im Allgemeinen fehl. Wird häufig in verzögerten Animationen verwendet

var count = 0;
 async.whilst(
 function () { return count < 5; },
 //验证成  功继续，失败进回调
 function (callback) {
   count++;
   setTimeout(callback, 1000);
 },
 function (err) {
   // 5 seconds have passed
 }
);

Wasserfall

5.waterfall(tasks, [callback]) Aufgaben werden nacheinander ausgeführt. Der Rückruf der vorherigen Funktion wird als Parameter der nächsten -Funktion verwendet. Wenn eine Aufgabe einen Fehlerrückruf übergibt, wird die nächste Funktion verwendet wird nicht ausgeführt

async.waterfall([
 function(callback){
   callback(null, 'one', 'two');
 },
 function(arg1, arg2, callback){
  // arg1 now equals 'one' and arg2 nowequals 'two'
   callback(null, 'three');
 },
 function(arg1, callback){
   // arg1 now equals 'three'
   callback(null, 'done');
 }
 ], function (err, result) {
  // result now equals 'done'  
});

Komponieren

6.compose(fn1, fn2...) Der Reihe nach zur Warteschlange hinzufügen, der Reihe nach ausführen und das Ergebnis der vorherigen Funktion als Wert der nächsten Funktion verwenden

 function add1(n, callback) {
 setTimeout(function () {
   callback(null, n + 1);
 }, 10);
 }
 function mul3(n, callback) {
 setTimeout(function () {
   callback(null, n * 3);
 }, 10);
}
var add1mul3 = async.compose(mul3, add1);
 add1mul3(4, function (err, result) {
// result now equals 15
});

Ich glaube, das haben Sie Lesen Sie den Fall in diesem Artikel. Nachdem Sie die Methode gemeistert haben, lesen Sie bitte andere verwandte Artikel auf der chinesischen PHP-Website, um weitere spannende Inhalte zu erhalten!

Empfohlene Lektüre:

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der asynchronen Verarbeitung mithilfe von Node Async. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!