Analysieren von Rückrufen und Codeentwurfsmustern in Node.js asynchroner Programmierung_node.js

Das größte Verkaufsargument von NodeJS – der Ereignismechanismus und die asynchrone E/A – sind für Entwickler nicht transparent. Entwickler müssen Code asynchron schreiben, um dieses Verkaufsargument zu nutzen, das von einigen NodeJS-Gegnern kritisiert wurde. Aber egal was passiert, die asynchrone Programmierung ist in der Tat das größte Merkmal von NodeJS. Ohne die asynchrone Programmierung zu beherrschen, kann man nicht sagen, dass man NodeJS wirklich gelernt hat. In diesem Kapitel werden verschiedene Kenntnisse im Zusammenhang mit der asynchronen Programmierung vorgestellt.

Im Code sind Rückrufe die direkte Manifestation der asynchronen Programmierung. Die asynchrone Programmierung basiert auf Rückrufen, es kann jedoch nicht gesagt werden, dass das Programm nach der Verwendung von Rückrufen asynchron wird. Wir können uns zunächst den folgenden Code ansehen.

function heavyCompute(n, callback) {
 var count = 0,
  i, j;

 for (i = n; i > 0; --i) {
  for (j = n; j > 0; --j) {
   count += 1;
  }
 }

 callback(count);
}

heavyCompute(10000, function (count) {
 console.log(count);
});

console.log('hello');

100000000
hello

Wie Sie sehen können, wird die Rückruffunktion im obigen Code immer noch vor dem nachfolgenden Code ausgeführt. JS selbst wird in einem einzelnen Thread ausgeführt und es ist unmöglich, anderen Code auszuführen, bevor die Ausführung eines Teils des Codes abgeschlossen ist. Daher gibt es kein Konzept für die asynchrone Ausführung.

Wenn eine Funktion jedoch einen anderen Thread oder Prozess erstellt, etwas parallel zum JS-Hauptthread ausführt und den JS-Hauptthread benachrichtigt, wenn die Sache erledigt ist, dann ist die Situation anders. Schauen wir uns den folgenden Code an.

setTimeout(function () {
 console.log('world');
}, 1000);

console.log('hello');

hello
world

Diesmal können Sie sehen, dass die Rückruffunktion nach dem nachfolgenden Code ausgeführt wird. Wie oben erwähnt, ist JS selbst Single-Threaded und kann nicht asynchron ausgeführt werden. Daher können wir davon ausgehen, dass spezielle Funktionen, die von der Laufumgebung außerhalb der JS-Spezifikationen bereitgestellt werden, darin bestehen, einen parallelen Thread zu erstellen und sofort zurückzukehren JS-Master an Der Prozess kann dann nachfolgenden Code ausführen und die Rückruffunktion ausführen, nachdem er eine Benachrichtigung vom parallelen Prozess erhalten hat. Zusätzlich zu den gängigen Funktionen wie setTimeout und setInterval umfassen solche Funktionen auch von NodeJS bereitgestellte asynchrone APIs wie fs.readFile.

Darüber hinaus kommen wir immer noch auf die Tatsache zurück, dass JS in einem einzelnen Thread ausgeführt wird, was bedeutet, dass JS keinen anderen Code, einschließlich Rückruffunktionen, ausführen kann, bevor ein Teil des Codes ausgeführt wird. Mit anderen Worten: Selbst wenn der parallele Thread seine Arbeit abschließt und den JS-Hauptthread benachrichtigt, die Rückruffunktion auszuführen, beginnt die Rückruffunktion erst mit der Ausführung, wenn der JS-Hauptthread inaktiv ist. Das Folgende ist ein solches Beispiel.

function heavyCompute(n) {
 var count = 0,
  i, j;

 for (i = n; i > 0; --i) {
  for (j = n; j > 0; --j) {
   count += 1;
  }
 }
}

var t = new Date();

setTimeout(function () {
 console.log(new Date() - t);
}, 1000);

heavyCompute(50000);

8520

Wie Sie sehen können, verzögerte sich die tatsächliche Ausführungszeit der Callback-Funktion, die nach einer Sekunde aufgerufen werden sollte, erheblich, da der JS-Hauptthread damit beschäftigt war, anderen Code auszuführen.

Code-Designmuster
Asynchrone Programmierung verfügt über viele einzigartige Code-Entwurfsmuster. Um dieselbe Funktion zu erreichen, ist der im synchronen Modus und im asynchronen Modus geschriebene Code sehr unterschiedlich. Nachfolgend werden einige gängige Muster vorgestellt.

Funktionsrückgabewert
Es ist eine sehr häufige Anforderung, die Ausgabe einer Funktion als Eingabe einer anderen Funktion zu verwenden. Im synchronen Modus wird der Code im Allgemeinen wie folgt geschrieben:

var output = fn1(fn2('input'));
// Do something.

Da im asynchronen Modus das Ergebnis der Funktionsausführung nicht über den Rückgabewert, sondern über die Rückruffunktion übergeben wird, wird der Code im Allgemeinen wie folgt geschrieben:

fn2('input', function (output2) {
 fn1(output2, function (output1) {
  // Do something.
 });
});

Wie Sie sehen können, handelt es sich bei dieser Methode um eine in einer Callback-Funktion verschachtelte Callback-Funktion. Wenn es zu viele gibt, ist es einfach, Code in >-Form zu schreiben.

Das Array durchlaufen
Beim Durchlaufen eines Arrays ist es außerdem häufig erforderlich, eine Funktion zu verwenden, um die Datenelemente nacheinander zu verarbeiten. Wenn die Funktion synchron ausgeführt wird, wird im Allgemeinen der folgende Code geschrieben:

var len = arr.length,
 i = 0;

for (; i < len; ++i) {
 arr[i] = sync(arr[i]);
}

// All array items have processed.

Wenn die Funktion asynchron ausgeführt wird, kann der obige Code nicht garantieren, dass alle Array-Mitglieder nach Ende der Schleife verarbeitet wurden. Wenn die Array-Mitglieder seriell nacheinander verarbeitet werden müssen, wird asynchroner Code im Allgemeinen wie folgt geschrieben:

(function next(i, len, callback) {
 if (i < len) {
  async(arr[i], function (value) {
   arr[i] = value;
   next(i + 1, len, callback);
  });
 } else {
  callback();
 }
}(0, arr.length, function () {
 // All array items have processed.
}));

Wie Sie sehen können, übergibt der obige Code erst das nächste Array-Mitglied und startet die nächste Ausführungsrunde, nachdem die asynchrone Funktion einmal ausgeführt wurde, und gibt das Ausführungsergebnis zurück, bis alle Array-Mitglieder verarbeitet sind, die Ausführung des nachfolgenden Codes wird durch Rückrufe ausgelöst.

Wenn Array-Mitglieder parallel verarbeitet werden können, nachfolgender Code jedoch dennoch die Verarbeitung aller Array-Mitglieder vor der Ausführung erfordert, wird der asynchrone Code an die folgende Form angepasst:

(function (i, len, count, callback) {
 for (; i < len; ++i) {
  (function (i) {
   async(arr[i], function (value) {
    arr[i] = value;
    if (++count === len) {
     callback();
    }
   });
  }(i));
 }
}(0, arr.length, 0, function () {
 // All array items have processed.
}));

Wie Sie sehen können, verarbeitet der obige Code im Vergleich zur asynchronen seriellen Traversal-Version alle Array-Mitglieder parallel und verwendet die Zählervariable, um zu bestimmen, wann alle Array-Mitglieder verarbeitet wurden.

Ausnahmebehandlung
Der von JS selbst bereitgestellte Mechanismus zum Abfangen und Behandeln von Ausnahmen – try..catch.. – kann nur für synchron ausgeführten Code verwendet werden. Unten finden Sie ein Beispiel.

function sync(fn) {
 return fn();
}

try {
 sync(null);
 // Do something.
} catch (err) {
 console.log('Error: %s', err.message);
}

Error: object is not a function

Wie Sie sehen können, brodelt die Ausnahme entlang des Codeausführungspfads, bis sie beim Auftreffen auf die erste try-Anweisung abgefangen wird. Da asynchrone Funktionen jedoch den Codeausführungspfad unterbrechen, werden Ausnahmen, die während und nach der Ausführung der asynchronen Funktion generiert werden, bis zu der Stelle, an der der Ausführungspfad unterbrochen wird, als globale Ausnahme ausgelöst, wenn keine try-Anweisung angetroffen wird . Unten finden Sie ein Beispiel.

function async(fn, callback) {
 // Code execution path breaks here.
 setTimeout(function ()　{
  callback(fn());
 }, 0);
}

try {
 async(null, function (data) {
  // Do something.
 });
} catch (err) {
 console.log('Error: %s', err.message);
}

/home/user/test.js:4
  callback(fn());
     ^
TypeError: object is not a function
 at null._onTimeout (/home/user/test.js:4:13)
 at Timer.listOnTimeout [as ontimeout] (timers.js:110:15)

因为代码执行路径被打断了，我们就需要在异常冒泡到断点之前用 try 语句把异常捕获住，并通过回调函数传递被捕获的异常。于是我们可以像下边这样改造上边的例子。

function async(fn, callback) {
 // Code execution path breaks here.
 setTimeout(function ()　{
  try {
   callback(null, fn());
  } catch (err) {
   callback(err);
  }
 }, 0);
}

async(null, function (err, data) {
 if (err) {
  console.log('Error: %s', err.message);
 } else {
  // Do something.
 }
});

Error: object is not a function

可以看到，异常再次被捕获住了。在 NodeJS 中，几乎所有异步 API 都按照以上方式设计，回调函数中第一个参数都是 err。因此我们在编写自己的异步函数时，也可以按照这种方式来处理异常，与 NodeJS 的设计风格保持一致。

有了异常处理方式后，我们接着可以想一想一般我们是怎么写代码的。基本上，我们的代码都是做一些事情，然后调用一个函数，然后再做一些事情，然后再调用一个函数，如此循环。如果我们写的是同步代码，只需要在代码入口点写一个 try 语句就能捕获所有冒泡上来的异常，示例如下。

function main() {
 // Do something.
 syncA();
 // Do something.
 syncB();
 // Do something.
 syncC();
}

try {
 main();
} catch (err) {
 // Deal with exception.
}

但是，如果我们写的是异步代码，就只有呵呵了。由于每次异步函数调用都会打断代码执行路径，只能通过回调函数来传递异常，于是我们就需要在每个回调函数里判断是否有异常发生，于是只用三次异步函数调用，就会产生下边这种代码。

function main(callback) {
 // Do something.
 asyncA(function (err, data) {
  if (err) {
   callback(err);
  } else {
   // Do something
   asyncB(function (err, data) {
    if (err) {
     callback(err);
    } else {
     // Do something
     asyncC(function (err, data) {
      if (err) {
       callback(err);
      } else {
       // Do something
       callback(null);
      }
     });
    }
   });
  }
 });
}

main(function (err) {
 if (err) {
  // Deal with exception.
 }
});

可以看到，回调函数已经让代码变得复杂了，而异步方式下对异常的处理更加剧了代码的复杂度。