rappel nodejs trop profond

En développement, on rencontre souvent l'enfer des callbacks, notamment lors de la programmation avec Node.js. Callback Hell fait référence à plusieurs couches de fonctions de rappel imbriquées, ce qui rend difficile la maintenance du code, le débogage et la résolution des erreurs. Cet article analysera les causes du problème de l'enfer de rappel de Node.js et comment résoudre cette situation.

1. Pourquoi le problème de l'enfer de rappel se produit-il ?

Node.js est un modèle de programmation asynchrone piloté par les événements. Dans ce modèle, les opérations d'E/S telles que les requêtes réseau, la lecture et l'écriture de fichiers et les requêtes de base de données sont toutes non bloquantes, c'est-à-dire exécutées de manière asynchrone et n'interrompront pas l'exécution du processus principal. Cela peut éviter de perdre du temps à attendre les opérations d'E/S et améliorer les performances du programme. Mais l’inconvénient de la programmation asynchrone est qu’elle est sujette à des problèmes de rappel infernaux.

Les principales raisons du problème de l'enfer des rappels sont les suivantes :

(1) Node.js adopte un modèle à thread unique et des rappels sont nécessaires lors de l'exécution de plusieurs I/ O opérations. fonction pour attendre le retour du résultat. Le traitement des données et de la logique dans plusieurs fonctions de rappel imbriquées augmente la complexité du code.

(2) De nombreux modules et bibliothèques Node.js sont conçus sur la base de fonctions de rappel asynchrones, et la fonction de rappel est l'interface principale de ces modules et bibliothèques. Lorsque nous utilisons ces modules et bibliothèques, des appels imbriqués aux fonctions de rappel doivent également être effectués.

(3) Dans le modèle de programmation asynchrone, en raison de l'exécution asynchrone des opérations d'E/S, l'ordre d'exécution des fonctions de rappel n'est pas l'ordre attendu, ce qui entraîne une augmentation de la complexité du logique du code.

2. Comment résoudre le problème de l'enfer des rappels ?

Afin de résoudre le problème de l'enfer des rappels, nous devons comprendre certains modèles et solutions de programmation asynchrone.

(1) Utiliser Promise

Promise est un modèle de programmation asynchrone qui peut transmettre des valeurs entre les fonctions de rappel et peut être appelé dans une chaîne. Grâce à Promise, plusieurs fonctions de rappel imbriquées peuvent être combinées dans une chaîne Promise, rendant le code plus concis et plus lisible. Ce qui suit est un exemple de code refactorisé à l'aide de Promise :

const fs = require('fs');

function readFilePromise(filename) {
  return new Promise((resolve, reject) => {
    fs.readFile(filename, 'utf-8', (err, data) => {
      if(err) reject(err);
      else resolve(data);
    });
  });
}

readFilePromise('file1.txt')
.then(data => {
  console.log(data);
  return readFilePromise('file2.txt');
})
.then(data => {
  console.log(data);
  return readFilePromise('file3.txt');
})
.then(data => {
  console.log(data);
})
.catch(err => console.log(err));

Dans le code ci-dessus, Promise est utilisé pour encapsuler l'opération asynchrone de lecture de fichiers, et les appels en chaîne sont utilisés pour connecter plusieurs opérations ensemble, ce qui rend le code Plus d'imbrication, plus facile à lire et à entretenir.

(2) Utiliser async/await

async/await est une nouvelle solution de programmation asynchrone dans ES2017, qui est implémentée sur la base de Promise. La fonction asynchrone peut rendre la logique du code plus claire et conforme à la logique de la pensée humaine. Voici un exemple de code refactorisé à l'aide de async/await :

const fs = require('fs');

function readFilePromise(filename) {
  return new Promise((resolve, reject) => {
    fs.readFile(filename, 'utf-8', (err, data) => {
      if(err) reject(err);
      else resolve(data);
    });
  });
}

async function readFiles() {
  try {
    const data1 = await readFilePromise('file1.txt');
    console.log(data1);
    const data2 = await readFilePromise('file2.txt');
    console.log(data2);
    const data3 = await readFilePromise('file3.txt');
    console.log(data3);
  } catch(err) {
    console.log(err);
  }
}

readFiles();

Dans le code ci-dessus, plusieurs opérations asynchrones sont exécutées en série à l'aide de async/await, et le mot-clé wait est utilisé avant chaque code de pause d'opération asynchrone. exécution et attendez que l’objet Promise renvoie le résultat.

(3) Utilisez le module asynchrone

async est une bibliothèque de contrôle de processus qui fournit certaines fonctions pour rendre la programmation asynchrone plus simple et plus pratique. La bibliothèque asynchrone fournit plusieurs fonctions de flux de contrôle (telles que parallèle, cascade, série, etc.), qui peuvent permettre à plusieurs opérations asynchrones d'être exécutées en parallèle ou en série, et les résultats peuvent être renvoyés à la fonction de rappel. Voici un exemple de code utilisant le module async :

const async = require('async');
const fs = require('fs');

function readFile(filename, callback) {
  fs.readFile(filename, 'utf-8', (err, data) => {
    if(err) callback(err);
    else callback(null, data);
  });
}

async.series([
  function(callback) {
    readFile('file1.txt', callback);
  },
  function(callback) {
    readFile('file2.txt', callback);
  },
  function(callback) {
    readFile('file3.txt', callback);
  },
], function(err, results) {
  if(err) console.log(err);
  else console.log(results);
});

Dans le code ci-dessus, la fonction de flux de contrôle async.series est utilisée pour effectuer plusieurs opérations asynchrones en série et transmettre les résultats à la fonction de rappel.

3. Summary

Callback hell est un problème courant dans la programmation Node.js, ce qui rend difficile la maintenance du code, le débogage et le dépannage des erreurs. Difficultés et autres problèmes. Pour le problème de l'enfer des rappels, nous pouvons utiliser diverses solutions telles que les modules Promise, async/await et async pour optimiser la programmation asynchrone, rendre le code plus concis et lisible et améliorer l'efficacité du développement et la qualité 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!