nodejs SQL-Prozesssteuerung-Front-End-Fragen und Antworten-php.cn

Wenn Node.js eine relationale Datenbank verwendet, müssen häufig asynchrone Vorgänge ausgeführt werden, z. B. das Abrufen und Verarbeiten von Daten aus der Datenbank. Zu diesem Zeitpunkt müssen wir die Prozesssteuerung verwenden.

Prozesssteuerung wird verwendet, um Code in verschiedenen Zuständen zu steuern, z. B. sequentielle Ausführung, parallele Ausführung, Ausnahmebehandlung usw. Zu den gängigen Prozesssteuerungen in Node.js gehören Rückruffunktionen, Promise, Async/Await und Generatoren. Bei der Verwendung von Node.js zur Verbindung mit einer relationalen Datenbank sind Callback-Funktionen, Promise und Async/Await besonders wichtig. Die Verwendung der drei Prozesssteuerungen wird im Folgenden ausführlich vorgestellt.

1. Callback-Funktion

Die Callback-Funktion ist die klassische Prozesssteuerungsmethode in Node.js. Die Rückruffunktion ist eine Funktion, die ausgeführt werden kann, nachdem die aktuelle Funktion ausgeführt wurde, und das Ergebnis wird als Parameter übergeben, um eine asynchrone Steuerung zu erreichen. Einige Funktionsbibliotheken in Node.js und einige Datenbanktreiber bieten Rückruffunktionen zur Implementierung asynchroner Aufrufe. Beispielsweise kann im nativen Dateimodul fs in Node.js der Dateiinhalt über die Rückruffunktion gelesen werden:

const fs = require('fs');
fs.readFile('./file.txt', 'utf8', (err, data) => {
  if (err) return console.error(err);
  console.log(data);
});

Nach dem Login kopieren

Wenn der Vorgang readFile abgeschlossen ist, wird die Rückruffunktion aufgerufen und die Das Ergebnis wird als Parameter an die Callback-Funktion übergeben. Der erste Parameter in der Rückruffunktion stellt normalerweise die Fehlermeldung dar, und der zweite Parameter stellt normalerweise das Operationsergebnis dar. readFile操作完成后，会调用回调函数，并将结果作为参数传递给回调函数。回调函数中的第一个参数通常表示错误信息，第二个参数通常表示操作结果。

但是，当遇到嵌套的异步操作时，回调函数的嵌套会变得非常繁琐。这时候可以使用Promise来优化代码。

二、Promise

Promise是一种用来避免回调函数嵌套的方式。Promise表示一个异步操作的最终结果，可以通过它的状态了解该操作是成功还是失败。Promise支持链式调用，可以在非常方便的情况下进行异常处理，从而避免回调函数的嵌套。

在Node.js中，可以使用第三方Promise库bluebird来管理Promise对象。例如，我们可以使用Promise来读取文件内容：

const Promise = require('bluebird');
const fs = Promise.promisifyAll(require('fs'));

fs.readFileAsync('./file.txt', 'utf8')
  .then(data => {
    console.log(data);
  })
  .catch(err => {
    console.error(err);
  });

Nach dem Login kopieren

在使用bluebird之后，可以使用promisifyAll方法将原生的fs模块中的方法变成Promise对象，从而可以使用Promise的链式调用方式进行操作。

在上面的示例中，使用then方法来获取异步操作成功的结果，使用catch方法来获取异步操作失败的结果。

在使用Promise时，如果遇到多个异步操作需要串联起来的情况，使用链式调用可以让代码更加简洁：

fs.readFileAsync('./file.txt', 'utf8')
  .then(data => {
    console.log(data);
    return fs.writeFileAsync('./file-copy.txt', data);
  })
  .then(() => {
    console.log('文件写入成功');
  })
  .catch(err => {
    console.error(err);
  });

Nach dem Login kopieren

上述代码中，首先读取文件，然后将文件内容写入新的文件中，最后输出文件写入成功的信息。

三、async/await

async/await是ES2017中引入的异步操作语法。它可以让异步代码看起来像同步代码，但又不阻塞进程。async函数在执行时，会自动返回一个Promise对象，async函数内部使用await关键字等待Promise对象返回结果。如果操作成功，会返回异步操作的结果，否则抛出错误。

在使用Node.js连接数据库时，我们经常需要进行异步操作，例如从数据库中获取数据并进行处理。下面是一个基于MySQL模块的例子：

const mysql = require('mysql');
const connection = mysql.createConnection({
  host: 'localhost',
  user: 'root',
  password: 'password',
  database: 'test'
});

const query = async (sql) => {
  return new Promise((resolve, reject) => {
    connection.query(sql, (err, rows) => {
      if (err) reject(err);
      else resolve(rows);
    });
  });
};

(async () => {
  try {
    const users = await query('SELECT * FROM users WHERE age > 18');
    console.log(users);
  } catch (err) {
    console.error(err);
  }
})();

Nach dem Login kopieren

上面的代码中，使用async/await实现了从MySQL数据库中查询年龄大于18岁的用户，并输出结果。在query

Bei verschachtelten asynchronen Vorgängen kann die Verschachtelung von Rückruffunktionen jedoch sehr umständlich werden. Zu diesem Zeitpunkt kann Promise zur Optimierung des Codes verwendet werden.

2. Promise

Promise ist eine Möglichkeit, die Verschachtelung von Rückruffunktionen zu vermeiden. Promise stellt das Endergebnis eines asynchronen Vorgangs dar. Anhand seines Status können Sie erkennen, ob der Vorgang erfolgreich war oder fehlgeschlagen ist. Promise unterstützt verkettete Aufrufe, die in sehr praktischen Situationen Ausnahmen behandeln können und so eine Verschachtelung von Rückruffunktionen vermeiden. 🎜🎜In Node.js können Sie die Promise-Bibliothek Bluebird eines Drittanbieters verwenden, um Promise-Objekte zu verwalten. Zum Beispiel können wir Promise verwenden, um den Dateiinhalt zu lesen: 🎜rrreee🎜Nach der Verwendung von Bluebird können Sie die Methode promisifyAll verwenden, um die Methoden im nativen fs-Modul in Promise-Objekte umzuwandeln, sodass Sie dies tun können Verwenden Sie zum Betrieb die Promise-Chain-Call-Methode. 🎜🎜Im obigen Beispiel verwenden Sie die Methode then, um das Ergebnis einer erfolgreichen asynchronen Operation abzurufen, und verwenden Sie die Methode catch, um das Ergebnis einer fehlgeschlagenen asynchronen Operation abzurufen. 🎜🎜Wenn Sie bei Verwendung von Promise auf mehrere asynchrone Vorgänge stoßen, die in Reihe geschaltet werden müssen, kann die Verwendung von Kettenaufrufen den Code prägnanter machen: 🎜rrreee🎜Im obigen Code wird zuerst die Datei und dann der Dateiinhalt gelesen in eine neue Datei geschrieben, die endgültige Ausgabedatei wurde erfolgreich geschrieben. 🎜🎜3. async/await🎜🎜async/await ist die in ES2017 eingeführte asynchrone Operationssyntax. Es kann asynchronen Code wie synchronen Code aussehen lassen, ohne den Prozess zu blockieren. Wenn die asynchrone Funktion ausgeführt wird, gibt sie automatisch ein Promise-Objekt zurück. Das Schlüsselwort „await“ wird innerhalb der asynchronen Funktion verwendet, um darauf zu warten, dass das Promise-Objekt das Ergebnis zurückgibt. Wenn die Operation erfolgreich ist, wird das Ergebnis der asynchronen Operation zurückgegeben, andernfalls wird ein Fehler ausgegeben. 🎜🎜Wenn wir Node.js zum Herstellen einer Verbindung zur Datenbank verwenden, müssen wir häufig asynchrone Vorgänge ausführen, z. B. Daten aus der Datenbank abrufen und verarbeiten. Das Folgende ist ein Beispiel basierend auf dem MySQL-Modul: 🎜rrreee🎜Im obigen Code wird async/await verwendet, um Benutzer, die älter als 18 Jahre sind, aus der MySQL-Datenbank abzufragen und die Ergebnisse auszugeben. In der Funktion query wird Promise verwendet, um den MySQL-Abfragevorgang zu umschließen, sodass das Schlüsselwort „await“ verwendet werden kann, um asynchrone Vorgänge nacheinander auszuführen. 🎜🎜Zusammenfassung🎜🎜Prozesskontrolle ist ein sehr wichtiges Konzept in Node.js. Eine angemessene Prozesskontrolle kann die Lesbarkeit und Wartbarkeit des Codes verbessern. Zu den gängigen Prozesssteuerungsmethoden in Node.js gehören Rückruffunktionen, Promise, Async/Await und Generatoren. Bei Verwendung einer relationalen Datenbank sind Callback-Funktionen, Promise und Async/Await die am häufigsten verwendeten Prozesssteuerungsmethoden. Wir können diese Methoden flexibel verwenden, um asynchrone Vorgänge zu verwalten und die Lesbarkeit und Wartbarkeit des Codes zu verbessern. 🎜

Das obige ist der detaillierte Inhalt vonnodejs SQL-Prozesssteuerung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!