En savoir plus sur les objets Promise dans Nodejs

Cet article vous fera découvrir l'objet Promise dans Nodejs. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il sera utile à tout le monde.

Recommandations associées : "Tutoriel nodejs"

Objet de promesse

1. A quoi sert la promesse ?

Notre exigence est d'exécuter le code asynchrone une fois

Notre approche est dans la fonction de rappel une fois la requête asynchrone réussie, exécuter la prochaine requête asynchrone

Mais cela conduit à l'enfer du rappel (la fonction de rappel est imbriquée dans la fonction de rappel, la lisibilité du code est faible, la maintenance est inchangée, et c'est effrayant à regarder) )

la promesse est utilisée pour résoudre l'enfer des rappels

Exemple d'enfer des rappels :

// 需求：一次的读取a,b,c这三个文件
const fs = require("fs");

// 读a文件
fs.readFile(`${__dirname}/etc/a.txt`, "utf-8", (err, data) => {
  if (err) {
    console.log(err);
  } else {
    console.log(data);
    // 读b文件
    fs.readFile(`${__dirname}/etc/b.txt`, "utf-8", (err, data) => {
      if (err) {
        console.log(err);
      } else {
        console.log(data);
        // 读c文件
        fs.readFile(`${__dirname}/etc/c.txt`, "utf-8", (err, data) => {
          if (err) {
            console.log(err);
          } else {
            console.log(data);
          }
        });
      }
    });
  }
});

2. Workflow de promesse

Syntaxe es6, es6.ruanyifeng.com

L'objet Promise est un constructeur, utilisé pour générer des instances de promesse

Le constructeur Promise accepte une fonction en paramètre

Cette fonction en tant que paramètre a deux paramètres , Ces deux paramètres sont résolus et rejetés. 🎜>La méthode solve() est appelée une fois l'opération asynchrone réussie. Elle appelle en interne la première fonction paramètre dans then()

La méthode rejet() est appelée une fois l'opération asynchrone réussie, il appelle la deuxième fonction paramètre dans then() en interne >L'objet Promise représente une opération asynchrone.

en a trois. états : en attente (en cours), réalisé (réussi) et rejeté (échoué)

Il n'y a que deux possibilités pour que l'état de l'objet Promise change : de en attente à réalisé et de en attente de rejet.

Seul le résultat du fonctionnement asynchrone peut déterminer l'état actuel, et aucune autre opération ne peut changer cet état

Si le fonctionnement asynchrone s'il réussit (lecture du fichier avec succès), elle passe de en attente (en cours) à remplie (réussie

Si l'opération asynchrone échoue (la lecture du fichier échoue), elle passe d'en attente (); En cours) devient rejeté (échec)

Si le statut a été déterminé, il ne sera plus modifié

4 Caractéristiques de la promesse et leur encapsulation

La promesse sera exécutée immédiatement après sa création

Alors ne l'écrivez pas dans la promesse. Pour les autres codes, écrivez simplement le code de cette opération asynchrone

const fs = require("fs");
// 调用Promise构造函数，创建一个promise的实例
let p = new Promise((resolve, reject) => {
  // 写异步操作（读文件）
  fs.readFile(`${__dirname}/etc/a.txt`, "utf-8", (err, data) => {
    if (!err) {
      // 操作成功（读文件成功）
      resolve(data); // 调用resolve方法
      // 调用then()里面的第一个参数函数
    } else {
      reject(err); // 调用reject方法
      // 调用then()里面的第二个参数函数
    }
  });
});

p.then(
  (data) => {
    console.log(data);
  },
  (err) => {
    console.log(err);
  }
);

5 La bonne façon d'écrire la promesse

Comment promise résout l'enfer des rappels

-" La programmation en chaîne résout

** Le problème que nous utilisons promise pour résoudre : laisser les opérations asynchrones avoir de l'ordre, et là ne peut pas être un enfer de rappel**

L'essence de rendre les opérations asynchrones séquentielles est la suivante :

Les opérations asynchrones sont en fait désordonnées

Renvoyer une autre promesse dans la fonction de rappel une fois l'opération asynchrone réussie et appeler sa méthode then

const fs = require("fs");
function getPromise(filename) {
  // 调用Promise构造函数，创建一个promise的实例
  return new Promise((resolve, reject) => {
    // 写异步操作（读文件）
    fs.readFile(`${__dirname}/etc/${filename}.txt`, "utf-8", (err, data) => {
      if (!err) {
        // 操作成功（读文件成功）
        resolve(data); // 调用resolve方法
        // 调用then()里面的第一个参数函数
      } else {
        reject(err); // 调用reject方法
        // 调用then()里面的第二个参数函数
      }
    });
  });
}

// console.log(getPromise("a"));
getPromise("a").then(
  (data) => {
    console.log(data);
  },
  (err) => {
    console.log(err);
  }
);

Autres méthodes de promesse

catch()

peut attraper le mauvais

const fs = require("fs");
function getPromise(filename) {
  // 调用Promise构造函数，创建一个promise的实例
  return new Promise((resolve, reject) => {
    // 写异步操作（读文件）
    fs.readFile(`${__dirname}/etc/${filename}.txt`, "utf-8", (err, data) => {
      if (!err) {
        // 操作成功（读文件成功）
        resolve(data); // 调用resolve方法
        // 调用then()里面的第一个参数函数
      } else {
        reject(err); // 调用reject方法
        // 调用then()里面的第二个参数函数
      }
    });
  });
}

// console.log(getPromise("a"));
getPromise("a")
  .then((data) => {
    console.log(data);
    //调用函数得到一个读b文件的promise对象并返回
    return getPromise("b");
  })
  .then((data) => {
    console.log(data);
    //调用函数得到一个读c文件的promise对象并返回
    return getPromise("c");
  })
  .then((data) => {
    console.log(data);
  });

tous()

const fs = require("fs");
function getPromise(filename) {
  // 调用Promise构造函数，创建一个promise的实例
  return new Promise((resolve, reject) => {
    // 写异步操作（读文件）
    fs.readFile(`${__dirname}/etc/${filename}.txt`, "utf-8", (err, data) => {
      if (!err) {
        // 操作成功（读文件成功）
        resolve(data); // 调用resolve方法
        // 调用then()里面的第一个参数函数
      } else {
        reject(err); // 调用reject方法
        // 调用then()里面的第二个参数函数
      }
    });
  });
}

// console.log(getPromise("a"));
getPromise("a")
  .then((data) => {
    console.log(data);
    //调用函数得到一个读b文件的promise对象并返回
    return getPromise("b");
  })
  .then((data) => {
    console.log(data);
    //调用函数得到一个读c文件的promise对象并返回
    return getPromise("c");
  })
  .then((data) => {
    console.log(data);
  })
  .catch((err) => {
    console.log(err);
  });

• course

  const fs = require("fs");
  function getPromise(filename) {
    // 调用Promise构造函数，创建一个promise的实例
    return new Promise((resolve, reject) => {
      // 写异步操作（读文件）
      fs.readFile(`${__dirname}/etc/${filename}.txt`, "utf-8", (err, data) => {
        if (!err) {
          // 操作成功（读文件成功）
          resolve(data); // 调用resolve方法
          // 调用then()里面的第一个参数函数
        } else {
          reject(err); // 调用reject方法
          // 调用then()里面的第二个参数函数
        }
      });
    });
  }
  
  let p1 = getPromise("a");
  let p2 = getPromise("b");
  let p3 = getPromise("c");
  
  // Promise.all()方法用于将多个 Promise 实例，包装成一个新的 Promise 实例
  let pAll = Promise.all([p1, p2, p3]);
  // 一个都不能少，每一个promise都要读取成功才会成功，相当于是并且
  pAll.then((data) => {
    console.log(data);
  });

  Plus Pour plus de connaissances sur la programmation, veuillez visiter :

  Vidéo de programmation ! !

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!