von Neil Lobo, Softwareentwickler

Ein Teil der Popularität von Node.js ist die Ereignisschleife. Anstatt den Multithreading-Ansatz herkömmlicher Frameworks zu verfolgen, verwendet Node.js ein ereignisgesteuertes, nicht blockierendes I/O-Modell. Dies ermöglicht einen geringeren Speicherbedarf, ist leichter und effizienter und skaliert gut für datenintensive Echtzeitanwendungen.

Dieser ereignisgesteuerte Non-Blocking-Ansatz eignet sich gut für Anwendungen, bei denen der Engpass I/O oder Netzwerkaktivität ist. Im Gegensatz dazu, wenn die Anwendung CPU-intensive Aufgaben erfordert, dann ist Node.js wahrscheinlich eine schlechte Wahl.

Die Arbeit mit barem Node.js erfordert jedoch die Verwendung von asynchronen Rückrufen, die zu der berüchtigten Callback-Hölle führen. Dies führt zu einer Logik, die schwer zu folgen ist.

//Callback Soup/Spiral Callback of Doom
function doAsync1(function () {
    doAsync2(function () {
      doAsync3(function () {
        doAsync4(function () {
          //finally do something });
        });
      });
  });

Fehlerbehandlung und verschachtelte Rückrufe sind unangenehm zu schreiben, und ihre Existenz macht es schwierig, Code zu pflegen und zu skalieren. Es gibt einige Techniken, um diese Probleme zu überwinden, wobei die beliebtesten Fasern und Versprechungen sind. Ich möchte das erstere besprechen, da Meteor Fasern verwendet, um synchronen wie Code über die Ereignisschleife zu erreichen.

Fasern

Für diejenigen, die damit nicht vertraut sind, ist Fibers ein Informatik-Konstrukt, das ein Modell des kooperativen Multitasking verwendet (im Gegensatz zu Threads mit präventivem Multitasking).

Threaded Code kann zu jedem Zeitpunkt unterbrochen werden, auch in der Mitte der Auswertung eines Ausdrucks, um CPU-Zyklen für Code zu erhalten, der in einem anderen Thread läuft. Bei Fasern werden diese Unterbrechungen und Kontextwechsel nicht von der CPU oder einem Prozess auf niedrigerer Ebene bestimmt, sondern vom Programmierer, der entscheidet, wo sein Code hinführt und CPU-Zyklen an andere Fasern weitergibt.

Hier ist ein Beispiel für typischen Node.js-Code, der eine Callback-Funktion verwendet, die als Ergebnis übergeben wird.

getDataFromDisk = function(Dateiname, Schlüssel, callbackFunction) { 

  var-Ergebnis; 

  fs.readFile('/path/fileName', function(err, res) {
    if (err) console.log(err); else {
    result = transform(res, key);
    callbackFunction(result);
  }}};

Lasst uns versuchen zu schreiben, dass dies in einem synchroneren Stil geschieht.

getDataFromDisk = function(fileName, key) {
  var result;
  fs.readFile('/path/fileName', function(err, res) {
    if (err) console.log(err);    else result = transform(res, key); 

  }
  return result;// wird immer undefiniert sein.
};
/ / Wir versuchen, getDataFromDisk zu verwenden, geben den Wert zurück, dann
// Drucken Sie es aus, alle synchron.
var Ergebnis = getDataFromDisk('helloWorld',key);
console.log(result);
// undefiniert

Der obige Code wird immer undefiniert zurückgegeben, da die Ereignisschleife zur Ergebniszeile (*) übergeht, ohne auf das Ergebnis des Rückrufs zu warten.

Verwendung von Fasern

Fibers sind eine Klasse von Containerfunktionen, die verwendet werden können, um eine Unterroutine zu blockieren, während sie auf eine I/O- oder Netzwerkaktivität warten, ohne den gesamten Prozess zu blockieren.

var Fiber = Npm.require('fibers');// getDataFromDisk function using Fibers
getDataFromDisk = function(filename, key) {var fiber = Fiber.current; //get the current Fiber
fs.readFile('/path/fileName', function(err, res) {
if (err) console.log(err); else{
/* Resume execution of this fiber. What’s passed to fiber.run will become the value returned by Fiber.yield below */
fiber.run( transform(res, key) );
var result = Fiber.yield();
return result;};
// Finally we wrap our code in a Fiber, then run it
Fiber(function() { 

var Ergebnis = getDataFromDisk('helloWorld', Schlüssel);
console.log(result);
}).run();

Presto, wir haben synchron aussehenden Code, der immer noch asynchron auf der Ereignisschleife ausgeführt wird.

Für weitere Informationen über Fasern siehe unten (https://github.com/laverdet/node-fibers)