NodeJs verarbeitet asynchrone Methoden über Async und Wait

Wenn wir das Express-Backend schreiben, müssen wir oft viele asynchrone E/A verarbeiten. In der Antike verwendeten wir alle die Chunk-Funktion, die Funktion, mit der wir am besten vertraut sind und deren standardmäßiger erster Parameter error ist. Lassen Sie uns den Betrieb einer Mongo-Datenbank simulieren und ein Gefühl dafür bekommen.

Dieser Artikel stellt hauptsächlich vor, wie NodeJs die asynchrone Verarbeitung durch async/await handhabt. Jetzt teile ich ihn mit Ihnen und hoffe, dass er Ihnen helfen kann.

mongoDb.open(function(err, db){
  if(!err){
    db.collection("users", function(err, collection){
      if(!err){
        let person = {name: "yika", age: 20};
        collection.insert(person, function(err, result){
          if(!err){
            console.log(result);
          }
        });
      }
    })
  }
});

Das ist es, was wir kritisiert haben callback hell, eine Ansammlung horizontaler Pyramiden, wenn Rückrufe in Funktionen aufgeteilt werden, werden sie sehr fragmentiert. Um zu verhindern, dass sich alle ekeln, habe ich nicht einmal über die Fehlerbehandlung geschrieben. Normalerweise muss jeder asynchrone Vorgang mit seinem error entsprechend angezeigt oder verarbeitet werden.

Promise-Ära

Später traten wir in eine bessere Ära von Promise ein, die wir auch Kettenoperationen nennen können. Bezüglich Promise habe ich bereits eine Reihe von Blog-Beiträgen geschrieben. Wenn Sie interessiert sind, können Sie diese noch einmal lesen. Werfen wir einen Blick auf die Situation, nachdem wir das oben Gesagte umgeschrieben haben.

let person = {name: "yika"};
mongoDb
  .open()
  .then(function(database){
   return database.collection("users");
  })
  .then(function(collection){
   return collection.insert(person);
  })
  .then(function(result){
   console.log(result);
  })
  .catch(function(e){
   throw new Error(e);
  })

Wir können sehen, dass wir die Pyramide zu einer linearen Struktur abgeflacht haben. Im Vergleich zur vorherigen Chunk-Funktion, die ekelhaft und schwer zu warten war, ist sie zu einer Versprechensfunktion geworden, und die Fehlerbehandlung ist sehr elegant geworden. Bestimmte Probleme können wir jedoch immer noch nicht ignorieren. Jede Funktion hat ihren eigenen unabhängigen Bereich und muss in der äußersten Ebene aufgehängt werden. Das Wichtigste ist, dass es sich immer noch von der synchronen Programmierung unterscheidet, mit der wir vertraut sind. then()

Generator-Ära

Master TJ war der erste, der durch den Generator-Iterator von ES6 die Synchronisationsfunktion der asynchronen Programmierung realisierte, die am bekanntesten ist uns

Bibliothek. Wir verwenden co, um die Funktion intern durch Iteratoren zu steuern. Und co(function *(){}) fungiert hier als Launcher. Das Gleiche habe ich in meinem vorherigen Blogbeitrag über Generator und Co gesagt. co

let co = require("co");

co(function *(){
  let db, collection, result; 
  let person = {name: "yika"};
  try{
    db = yield mongoDb.open();
    collection = yield db.collection("users");
    result = yield collection.insert(person);
  }catch(e){
    console.error(e.message);
  }
  console.log(result);
});

Wir sind der synchronen Programmierung sehr nahe. Innerhalb der in co verpackten Funktion wird nur eine asynchrone Ausführung abgeschlossen, bevor der folgende Code fortgesetzt wird ausgeführt werden. Und auch die Fehlerbehandlung wird durch

implementiert. Wir müssen jedoch zugeben, dass es für Asynchronität doch keine Iteratoren gibt. Die Semantik von try and catch und yield im Inneren stellt keine asynchronen Funktionsflags dar. Und der Iterator muss von co gesteuert werden, was sich ein wenig von der Funktion unterscheidet, die wir uns vorgestellt haben. *

async/await-Ära

Wir haben auf ES7s async/await-Ära geachtet, nur um festzustellen, dass es das ist, was wir wollen! Lassen Sie uns den obigen Code etwas umschreiben.

async function insertData(person){
  let db, collection, result; 
  try{
    db = await mongoDb.open();
    collection = await db.collection("users");
    result = await collection.insert(person);
  }catch(e){
    console.error(e.message);
  }
  console.log(result);
} 

insertData({name: "yika"});

Wir sehen, dass

eine echte Funktion ist, die wir direkt aufrufen können, ohne dass ein Launcher-Treiber erforderlich ist. Natürlich können wir intern auch spüren, dass es keinen großen Unterschied gibt, außer dass inserData in yield geändert wurde. async/await entspricht eher der Semantik unserer asynchronen Programmierung. await

Dann ist die Frage, wie man es verwendet?

Verwendung

Wie wir am Anfang sagten, unterstützt Babel bereits die asynchrone Transformation. Also einfach Führen Sie Babel ein, wenn wir es verwenden. Natürlich können die Serverseite und die Browserseite unterschiedliche Verarbeitungsmethoden haben. Bevor wir beginnen, müssen wir das folgende Paket vorstellen: Preset-stage-3 enthält die async/await-kompilierten Dateien, die wir benötigen.

$ npm install babel-core --save
$ npm install babel-preset-es2015 --save
$ npm install babel-preset-stage-3 --save

Browserseite

Babel schien ursprünglich dazu da, alten Browsern die Unterstützung neuer ES6-Funktionen zu verbessern unsere Entwicklungserfahrung. So kann Babel von Anfang an über das Babel-Cli-Terminal kompiliert werden. Oder führen Sie Babel-Dateien ein, die auf der Browserseite kompiliert werden sollen. Natürlich sind dies nicht meine am meisten empfohlenen, also lasse ich sie einfach weg. Bei der Konfiguration statischer Front-End-Ressourcen ist Webpack jetzt eine bessere Lösung. Es unterstützt Modulabhängigkeiten von statischen Ressourcen, Paketierung und Zusammenführung sowie Sprachvorverarbeitung.

// webpack.config.js
// 省略上面的文件输入输出的配置，直接看模块加载器的配置
module: {
  loaders: [
    {
      test: /\.js$/,
      exclude: /(node_modules|bower_components)/,
      loader: "babel",
      query: {
       presets: ['es2015', 'stage-3']
      }
    },
  ]
}

Auf diese Weise können wir es gerne nutzen.

Serverseite

Relativ gesehen muss das Back-End viel mehr asynchrone E/A-Orte verarbeiten als das Front-End, und es braucht dies auch mehr. Wie führen wir Babel auf der Serverseite ein?

Tatsächlich besteht die einfachste und mühsamste Methode darin, die JS-Datei direkt über Babel zu kompilieren, um eine neue Datei zu erstellen und diese dann zu verwenden. Natürlich sind redundante Dateien unvermeidlich. Aus den Augen, aus dem Sinn, versuchen wir es mit einer anderen Methode.

Wir verwenden die offiziell bereitgestellte Require-Hook-Methode. Nach dem Eingang über Require werden die nächsten Dateien von Babel verarbeitet, wenn sie benötigt werden. Da wir wissen, dass CommonJs eine synchrone Modulabhängigkeit ist, ist es auch eine praktikable Methode. Für den Start benötigen wir noch eine weitere js-Datei, eine js-Datei, die das Programm tatsächlich ausführt.

// index.js 
// 用于引入babel，并且启动app.js

require("babel-core/register");
require("./app.js");

配置完hook之后，我们就配置babel的.babelrc文件，它是一个json格式的文件。es2015看情况配置，如果是已经是Node5.0版本，就无需再进行编译。

{
 "presets": ["stage-3", "es2015"]
}

最后我们的异步函数代码，写在app.js里即可。

相关推荐：

小程序开发之利用co处理异步流程的实例教程

如何处理异步队列出错？

以jQuery中$.Deferred对象为例讲解promise对象是如何处理异步问题_jquery

Das obige ist der detaillierte Inhalt vonNodeJs verarbeitet asynchrone Methoden über Async und Wait. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!