contrôle de processus SQL nodejs

Lorsque Node.js utilise une base de données relationnelle, il doit souvent effectuer des opérations asynchrones, telles que l'obtention de données de la base de données et leur traitement. Les résultats du traitement affecteront l'opération suivante. À ce stade, nous devons utiliser le contrôle de processus.

Le contrôle de processus est utilisé pour contrôler le code dans différents états, tels que l'exécution séquentielle, l'exécution parallèle, la gestion des exceptions, etc. Dans Node.js, les contrôles de processus courants incluent les fonctions de rappel, Promise, async/await et les générateurs. Lorsque vous utilisez Node.js pour vous connecter à une base de données relationnelle, les fonctions de rappel, Promise et async/await sont particulièrement importantes. L'utilisation des trois contrôles de processus sera présentée en détail ci-dessous.

1. Fonction de rappel

La fonction de rappel est la méthode classique de contrôle de processus dans Node.js. La fonction de rappel est une fonction qui peut être exécutée après l'exécution de la fonction actuelle, et le résultat est passé comme paramètre pour obtenir un contrôle asynchrone. Certaines bibliothèques de fonctions dans Node.js et certains pilotes de base de données fournissent des fonctions de rappel pour implémenter des appels asynchrones. Par exemple, dans le module de fichiers natif fs de Node.js, le contenu du fichier peut être lu via la fonction de rappel :

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

Lorsque l'opération readFile est terminée, la fonction de rappel sera appelée et le le résultat sera passé en paramètre à la fonction de rappel. Le premier paramètre de la fonction de rappel représente généralement le message d'erreur et le deuxième paramètre représente généralement le résultat de l'opération. 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);
  });

在使用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);
  });

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

三、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);
  }
})();

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

Cependant, face à des opérations asynchrones imbriquées, l'imbrication des fonctions de rappel peut devenir très lourde. À l’heure actuelle, Promise peut être utilisé pour optimiser le code.

2. Promise

La promesse est un moyen d'éviter l'imbrication des fonctions de rappel. La promesse représente le résultat final d'une opération asynchrone. Vous pouvez savoir si l'opération a réussi ou échoué grâce à son statut. Promise prend en charge les appels chaînés, qui peuvent gérer les exceptions dans des situations très pratiques, évitant ainsi l'imbrication des fonctions de rappel. 🎜🎜Dans Node.js, vous pouvez utiliser la bibliothèque tierce Promise bluebird pour gérer les objets Promise. Par exemple, nous pouvons utiliser Promise pour lire le contenu du fichier : 🎜rrreee🎜Après avoir utilisé bluebird, vous pouvez utiliser la méthode promisifyAll pour transformer les méthodes du module fs natif en objets Promise, afin de pouvoir utilisez la méthode Promise Chain Call pour fonctionner. 🎜🎜Dans l'exemple ci-dessus, utilisez la méthode then pour obtenir le résultat d'une opération asynchrone réussie, et utilisez la méthode catch pour obtenir le résultat d'une opération asynchrone ayant échoué. 🎜🎜Lors de l'utilisation de Promise, si vous rencontrez plusieurs opérations asynchrones qui doivent être connectées en série, l'utilisation d'appels en chaîne peut rendre le code plus concis : 🎜rrreee🎜Dans le code ci-dessus, le fichier est d'abord lu, puis le contenu du fichier est écrit dans un nouveau Dans le fichier, le fichier de sortie final est écrit avec succès. 🎜🎜3. async/await🎜🎜async/await est la syntaxe d'opération asynchrone introduite dans ES2017. Il peut faire ressembler le code asynchrone à du code synchrone sans bloquer le processus. Lorsque la fonction asynchrone est exécutée, elle renvoie automatiquement un objet Promise. Le mot-clé wait est utilisé dans la fonction asynchrone pour attendre que l'objet Promise renvoie le résultat. Si l'opération réussit, le résultat de l'opération asynchrone sera renvoyé, sinon une erreur sera générée. 🎜🎜Lorsque nous utilisons Node.js pour nous connecter à la base de données, nous devons souvent effectuer des opérations asynchrones, telles que récupérer des données de la base de données et les traiter. Voici un exemple basé sur le module MySQL : 🎜rrreee🎜Dans le code ci-dessus, async/await est utilisé pour interroger les utilisateurs de plus de 18 ans à partir de la base de données MySQL et afficher les résultats. Dans la fonction query, Promise est utilisé pour encapsuler l'opération de requête MySQL, afin que le mot-clé wait puisse être utilisé pour effectuer des opérations asynchrones en séquence. 🎜🎜Résumé🎜🎜Le contrôle des processus est un concept très important dans Node.js. Un contrôle raisonnable des processus peut améliorer la lisibilité et la maintenabilité du code. Dans Node.js, les méthodes courantes de contrôle de processus incluent les fonctions de rappel, Promise, async/await et les générateurs. Lors de l'utilisation de bases de données relationnelles, les fonctions de rappel, Promise et async/await sont les méthodes de contrôle de processus les plus couramment utilisées. Nous pouvons utiliser ces méthodes de manière flexible pour gérer les opérations asynchrones et améliorer la lisibilité et la maintenabilité du code. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!