Erfahren Sie mehr über Promise-Objekte in Nodejs

Dieser Artikel führt Sie durch das Promise-Objekt in Nodejs. Es hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen. Ich hoffe, es wird für alle hilfreich sein.

Verwandte Empfehlungen: „nodejs-Tutorial“

Promise-Objekt

1 Wofür wird Promise verwendet?

Unsere Anforderung besteht darin, asynchronen Code sofort auszuführen

Unser Ansatz besteht darin, die nächste asynchrone Anforderung in der Rückruffunktion auszuführen, nachdem die asynchrone Anforderung erfolgreich ist. Dies führt jedoch zur Rückrufhölle (Der Rückruf Die Funktion ist in der Rückruffunktion verschachtelt. Die Lesbarkeit des Codes ist gering und die Wartung ist unverändert, was den Leuten Angst macht

2. Promise-Workflow

es6-Syntax, es6.ruanyifeng.com

Das Promise-Objekt ist ein Konstruktor, der zum Generieren von Promise-Instanzen verwendet wird

Diese Funktion hat als Parameter zwei weitere Parameter: Auflösung und Ablehnung. Diese beiden Parameter sind ebenfalls Funktionen, aber diese beiden Funktionen werden von der Javascript-Engine bereitgestellt, sodass Sie sie nicht selbst bereitstellen müssen

Nachdem die asynchrone Operation erfolgreich war, wird die Methode „reject()“ intern aufgerufen ruft die erste Parameterfunktion in then() auf. , erfüllt (erfolgreich) und abgelehnt (fehlgeschlagen)

Es gibt nur zwei Möglichkeiten für die Zustandsänderung des Promise-Objekts: von ausstehend nach erfüllt und von ausstehend nach abgelehnt.

Nur das Ergebnis der asynchronen Operation kann den aktuellen Status bestimmen, und keine andere Operation kann diesen Status ändern

Wenn die asynchrone Operation erfolgreich ist (die Datei wurde erfolgreich gelesen), ändert sie sich von „Ausstehend“ (in Bearbeitung). ) ist erfüllt (erfolgreich);

Wenn der asynchrone Vorgang fehlschlägt (das Lesen der Datei schlägt fehl), wechselt er von „Ausstehend“ (in Bearbeitung) zu „Abgelehnt“ (fehlgeschlagen);

Wenn der Status ermittelt wurde, wird dies der Fall sein nicht Lassen Sie uns diesen Status erneut ändern

4. Versprechensfunktionen und Kapselung

Das Versprechen wird sofort nach der Erstellung ausgeführt

Schreiben Sie also keinen anderen Code in das Versprechen, sondern schreiben Sie diesen einfach asynchron Operation Der Code reicht aus

// 需求：一次的读取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);
          }
        });
      }
    });
  }
});

5. Richtige Schreibweise von Versprechen

Wie Versprechen die Rückrufhölle löst

-》Kettenprogrammierung löst

**Das Problem, das wir mit Versprechen lösen: lass asynchrone Operationen Es gibt Ordnung, und es kann keine Rückrufhölle geben**

Die Essenz der Reihenfolge asynchroner Vorgänge ist:

Asynchrone Vorgänge sind eigentlich ungeordnet

Gib nach dem ein weiteres Versprechen in der Rückruffunktion zurück Wenn der asynchrone Vorgang erfolgreich ist, rufen Sie seine Methode then auf.

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);
  }
);

6 alle( )

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);
  }
);

race

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);
  });

Weitere Programmierkenntnisse finden Sie unter: Programmiervideo! !

Das obige ist der detaillierte Inhalt vonErfahren Sie mehr über Promise-Objekte in Nodejs. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!