So ersetzen Sie die Callback-Funktion im Code durch Promise-js-Tutorial-php.cn

Dieses Mal zeige ich Ihnen, wie Promise die Callback-Funktion im Code ersetzt. Welche Vorsichtsmaßnahmen gibt es, um die Callback-Funktion im Code durch Promise zu ersetzen? Fall. Schauen wir uns das einmal an.

Während ich Node.js lernte, stieß ich darauf, wie man Async zur Steuerung der Parallelität verwendet (verwenden Sie Async zur Steuerung der Parallelität).

Das Wesen von Async ist eine Prozesssteuerung. Tatsächlich gibt es in der asynchronen Programmierung ein klassischeres Modell namens Promise/Deferred-Modell (natürlich gibt es verwandte Lösungen wie Eventproxy, Co usw., wenn die Zeit gekommen ist, werden Sie Löcher graben)

Lassen Sie uns zunächst über ein typisches asynchrones Programmiermodell nachdenken. Betrachten Sie dieses Thema: Lesen Sie eine Datei und geben Sie den Inhalt der Datei auf der Konsole aus.

var fs = require('fs');
fs.readFile('1.txt', 'utf8', function (err, data) {
  console.log(data);
});

Nach dem Login kopieren

scheint sehr einfach zu sein. Gehen Sie noch einen Schritt weiter: Lesen Sie zwei Dateien, in Die Konsole gibt den Inhalt dieser beiden Dateien aus

var fs = require('fs');
fs.readFile('1.txt', 'utf8', function (err, data) {
  console.log(data);
  fs.readFile('2.txt', 'utf8', function (err, data) {
    console.log(data);
  });
});

Nach dem Login kopieren

Was passiert, wenn mehr Dateien gelesen werden

var fs = require('fs');
fs.readFile('1.txt', 'utf8', function (err, data) {
  fs.readFile('2.txt', 'utf8', function (err, data) {
    fs.readFile('3.txt', 'utf8', function (err, data) {
      fs.readFile('4.txt', 'utf8', function (err, data) {
        // ...
      });
    });
  });
});

Nach dem Login kopieren

Das ist die legendäre Rückrufhölle, aber in In diesem Fall möchten wir Promise/Defer verwenden, um es zu verbessern Alles in allem ist es ein Objekt, das sich nicht von gewöhnlichen JavaScript-Objekten unterscheidet. Gleichzeitig ist es eine einheitliche Schnittstelle für asynchrone Operationen und stellt das Endergebnis einer asynchronen Operation dar auf synchrone Weise und die ausgeführten Operationen sind asynchron, aber es stellt auch sicher, dass die Reihenfolge der Programmausführung synchron ist

1 Versprechen hat nur drei Zustände: unerfüllt, erfüllt und abgelehnt 2. Der Status des Versprechens kann „Unerfüllt“ sein. Konvertieren in „Abgeschlossen“ oder „Unvollständig“ in „Fehler“3. Der Zustandsübergang des Versprechens erfolgt nur einmal.Das Versprechen hat eine „Dann“-Methode, und die „Dann“-Methode kann 3 akzeptieren fungiert als Parameter. Die ersten beiden Funktionen entsprechen den Rückruffunktionen der beiden Versprechenszustände: erfüllt und abgelehnt. Die dritte Funktion dient zur Verarbeitung von Fortschrittsinformationen

Um sie zu verstehen, müssen einige wichtige Prinzipien beachtet werden: .then() gibt immer ein neues Versprechen zurück, wie im folgenden Code gezeigt:

var promise = readFile()
var promise2 = promise.then(readAnotherFile, console.error)

Nach dem Login kopieren

Hier stellen die Parameter readAnotherFile und console.error die Aktion onFulfilled dar, nachdem der asynchrone Vorgang erfolgreich war, oder die Aktion OnRejected nach dem Fehler. Das heißt, die Funktion readAnotherFile wird ausgeführt, nachdem die Datei erfolgreich gelesen wurde, andernfalls liegt ein Fehler vor wird bei einem Fehler ausgedruckt und aufgezeichnet. Diese Implementierung ist nur eine der beiden Möglichkeiten

kann auch als verstanden werden:

promiseSomething().then(function (fulfilled) {
  // 当 promise 状态变成 fulfilled 时，调用此函数
}, function (rejected) {
  // 当 promise 状态变成 rejected 时，调用此函数
}, function (progress) {
  // 当返回进度信息时，调用此函数
});

Nach dem Login kopieren

Das Promise-Gesetz besteht aus zwei Teilen, die getrennt werden müssen:

1. ist immer Gibt jedes Mal, wenn Sie es aufrufen, ein neues Versprechen zurück. Es spielt keine Rolle, was der Rückruf tut, da .then() Ihnen vor dem Aufruf des Rückrufs ein Versprechen gegeben hat, wirkt sich das Verhalten des Rückrufs nur auf die Implementierung des Versprechens aus Wenn der Rückruf einen Wert zurückgibt, verwendet das Versprechen diesen Wert. Wenn der Wert ein Versprechen ist, geben Sie den Wert zurück, nachdem das Versprechen auf diesen Wert implementiert wurde. Wenn der Rückruf einen Fehler auslöst, lehnt das Versprechen den Fehler ab >

2. Von .then() Das zurückgegebene Versprechen ist ein neues Versprechen, das sich von dem Versprechen unterscheidet, auf dem .then() aufgerufen wurde. Lange Versprechenketten verbergen ohnehin die Tatsache, dass jedes .then(). Wenn der Aufruf ein neues Versprechen generiert, müssen Sie bedenken, dass Ihr letzter Aufruf von .then() möglicherweise einen Fehler darstellt. Wenn Sie diesen Fehler also nicht erkennen, wird er leicht zu Ihrem Fehler führen Ausnahme zum Verschwinden

Schauen wir uns einen Exploit an. Ein einfaches Beispiel für die Verwendung von q zur Lösung dieses Problems:

var Q = require('q');
var defer = Q.defer();
/**
 * 获取初始 promise
 * @private
 */
function getInitialPromise() {
  return defer.promise;
}
 
/**
 * 为 promise 设置三种状态的回调函数
 */
getInitialPromise().then(function (success) {
  console.log(success);
}, function (error) {
  console.log(error);
}, function (progress) {
  console.log(progress);
});
defer.notify('in progress'); // 控制台打印 in progress
defer.resolve('resolve');   // 控制台打印 resolve
defer.reject('reject');    // 没有输出。promise 的状态只能改变一次

Nach dem Login kopieren

Übergabe eines Versprechens

Dann gibt die Methode ein Versprechen zurück. Im folgenden Beispiel verwenden wir „outputPromise“, um auf das bis dahin zurückgegebene Versprechen zu verweisen.

var outputPromise = getInputPromise().then(function (fulfilled) {
 
  }, function (rejected) {
 
  });

Nach dem Login kopieren

Jetzt wird OutputPromise zu einem Versprechen, das durch Funktion (erfüllt) oder Funktion (abgelehnt) gesteuert wird. Die einfache Bedeutung ist: Wenn eine Funktion (erfüllt) oder eine Funktion (abgelehnt) einen Wert zurückgibt, z. B. eine Zeichenfolge, ein Array, ein Objekt usw., wird der Status von „outputPromise“ erfüllt.

Im folgenden Beispiel können wir sehen, dass die Konsolenausgaben erfüllt sind, wenn wir den Status von inputPromise über defer.resovle() in „erfüllt“ ändern.

Wenn wir den Status von inputPromise in ändern erfüllt Der Status ändert sich durch defer.reject() zu „Abgelehnt“ und die Konsole gibt „Abgelehnt“ aus

var Q = require('q');
var defer = Q.defer();
/**
 * 通过 defer 获得 promise
 * @private
 */
function getInputPromise() {
  return defer.promise;
}
 
/**
 * 当 inputPromise 状态由未完成变成 fulfil 时，调用 function(fulfilled)
 * 当 inputPromise 状态由未完成变成 rejected 时，调用 function(rejected)
 * 将 then 返回的 promise 赋给 outputPromise
 * function(fulfilled) 和 function(rejected) 通过返回字符串将 outputPromise 的状态由
 * 未完成改变为 fulfilled
 * @private
 */
var outputPromise = getInputPromise().then(function (fulfilled) {
  return 'fulfilled';
}, function (rejected) {
  return 'rejected';
});
 
/**
 * 当 outputPromise 状态由未完成变成 fulfil 时，调用 function(fulfilled)，控制台打印 'fulfilled: fulfilled'。
 * 当 outputPromise 状态由未完成变成 rejected, 调用 function(rejected), 控制台打印 'rejected: rejected'。
 */
outputPromise.then(function (fulfilled) {
  console.log('fulfilled: ' + fulfilled);
}, function (rejected) {
  console.log('rejected: ' + rejected);
});
 
/**
 * 将 inputPromise 的状态由未完成变成 rejected
 */
defer.reject(); // 输出 fulfilled: rejected
 
/**
 * 将 inputPromise 的状态由未完成变成 fulfilled
 */
//defer.resolve(); // 输出 fulfilled: fulfilled

Nach dem Login kopieren

当 function(fulfilled) 或者 function(rejected) 抛出异常时，那么 outputPromise 的状态就会变成 rejected

var Q = require('q'); var fs = require('fs'); var defer = Q.defer(); /** * 通过 defer 获得 promise * @private */ function getInputPromise() {   return defer.promise; } /** * 当 inputPromise 状态由未完成变成 fulfil 时，调用 function(fulfilled) * 当 inputPromise 状态由未完成变成 rejected 时，调用 function(rejected) * 将 then 返回的 promise 赋给 outputPromise * function(fulfilled) 和 function(rejected) 通过抛出异常将 outputPromise 的状态由 * 未完成改变为 reject * @private */ var outputPromise = getInputPromise().then(function (fulfilled) {   throw new Error('fulfilled'); }, function (rejected) {   throw new Error('rejected'); }); /** * 当 outputPromise 状态由未完成变成 fulfil 时，调用 function(fulfilled)。 * 当 outputPromise 状态由未完成变成 rejected, 调用 function(rejected)。 */ outputPromise.then(function (fulfilled) {   console.log('fulfilled: ' + fulfilled); }, function (rejected) {   console.log('rejected: ' + rejected); }); /** * 将 inputPromise 的状态由未完成变成 rejected */ defer.reject();   // 控制台打印 rejected [Error:rejected] /** * 将 inputPromise 的状态由未完成变成 fulfilled */ //defer.resolve(); // 控制台打印 rejected [Error:fulfilled]
Nach dem Login kopieren

当 function(fulfilled) 或者 function(rejected) 返回一个 promise 时，outputPromise 就会成为这个新的 promise.

这样做的意义在于聚合结果 (Q.all)，管理延时，异常恢复等等

比如说我们想要读取一个文件的内容，然后把这些内容打印出来。可能会写出这样的代码：

// 错误的写法 var outputPromise = getInputPromise().then(function (fulfilled) {   fs.readFile('test.txt', 'utf8', function (err, data) {     return data;   }); });
Nach dem Login kopieren

然而这样写是错误的，因为 function(fulfilled) 并没有返回任何值。需要下面的方式:

var Q = require('q'); var fs = require('fs'); var defer = Q.defer(); /** * 通过 defer 获得promise * @private */ function getInputPromise() {   return defer.promise; } /** * 当 inputPromise 状态由未完成变成 fulfil时，调用 function(fulfilled) * 当 inputPromise 状态由未完成变成 rejected时，调用 function(rejected) * 将 then 返回的 promise 赋给 outputPromise * function(fulfilled) 将新的 promise 赋给 outputPromise * 未完成改变为 reject * @private */ var outputPromise = getInputPromise().then(function (fulfilled) {   var myDefer = Q.defer();   fs.readFile('test.txt', 'utf8', function (err, data) {     if (!err && data) {       myDefer.resolve(data);     }   });   return myDefer.promise; }, function (rejected) {   throw new Error('rejected'); }); /** * 当 outputPromise 状态由未完成变成 fulfil 时，调用 function(fulfilled)，控制台打印 test.txt 文件内容。 * */ outputPromise.then(function (fulfilled) {   console.log(fulfilled); }, function (rejected) {   console.log(rejected); }); /** * 将 inputPromise 的状态由未完成变成 rejected */ //defer.reject(); /** * 将 inputPromise 的状态由未完成变成 fulfilled */ defer.resolve(); // 控制台打印出 test.txt 的内容
Nach dem Login kopieren

方法传递

方法传递有些类似于 Java 中的 try 和 catch。当一个异常没有响应的捕获时，这个异常会接着往下传递

方法传递的含义是当一个状态没有响应的回调函数，就会沿着 then 往下找

没有提供 function(rejected)

var outputPromise = getInputPromise().then(function (fulfilled) { })
Nach dem Login kopieren

如果 inputPromise 的状态由未完成变成 rejected, 此时对 rejected 的处理会由 outputPromise 来完成

var Q = require('q'); var fs = require('fs'); var defer = Q.defer(); /** * 通过defer获得promise * @private */ function getInputPromise() {   return defer.promise; } /** * 当 inputPromise 状态由未完成变成 fulfil 时，调用 function(fulfilled) * 当 inputPromise 状态由未完成变成 rejected 时，这个 rejected 会传向 outputPromise */ var outputPromise = getInputPromise().then(function (fulfilled) {   return 'fulfilled' }); outputPromise.then(function (fulfilled) {   console.log('fulfilled: ' + fulfilled); }, function (rejected) {   console.log('rejected: ' + rejected); }); /** * 将 inputPromise 的状态由未完成变成 rejected */ defer.reject('inputpromise rejected'); // 控制台打印 rejected: inputpromise rejected /** * 将 inputPromise的状态由未完成变成fulfilled */ //defer.resolve();
Nach dem Login kopieren

没有提供 function(fulfilled)

var outputPromise = getInputPromise().then(null, function (rejected) { })
Nach dem Login kopieren

如果 inputPromise 的状态由未完成变成 fulfilled, 此时对 fulfil 的处理会由 outputPromise 来完成

var Q = require('q'); var fs = require('fs'); var defer = Q.defer(); /** * 通过defer获得promise * @private */ function getInputPromise() {   return defer.promise; } /** * 当 inputPromise 状态由未完成变成 fulfil时，传递给 outputPromise * 当 inputPromise 状态由未完成变成 rejected时，调用 function(rejected) * function(fulfilled) 将新的 promise 赋给 outputPromise * 未完成改变为 reject * @private */ var outputPromise = getInputPromise().then(null, function (rejected) {   return 'rejected'; }); outputPromise.then(function (fulfilled) {   console.log('fulfilled: ' + fulfilled); }, function (rejected) {   console.log('rejected: ' + rejected); }); /** * 将 inputPromise 的状态由未完成变成 rejected */ // defer.reject('inputpromise rejected'); /** * 将 inputPromise 的状态由未完成变成fulfilled */ defer.resolve('inputpromise fulfilled'); // 控制台打印fulfilled: inputpromise fulfilled
Nach dem Login kopieren

可以使用 fail(function(error)) 来专门针对错误处理，而不是使用 then(null,function(error))

var outputPromise = getInputPromise().fail(function (error) { })
Nach dem Login kopieren

看这个例子：

var Q = require('q'); var fs = require('fs'); var defer = Q.defer(); /** * 通过defer获得promise * @private */ function getInputPromise() {   return defer.promise; } /** * 当 inputPromise 状态由未完成变成 fulfil 时，调用 then(function(fulfilled)) * 当 inputPromise 状态由未完成变成 rejected 时，调用 fail(function(error)) * function(fulfilled) 将新的 promise 赋给 outputPromise * 未完成改变为reject * @private */ var outputPromise = getInputPromise().then(function (fulfilled) {   return fulfilled; }).fail(function (error) {   console.log('fail: ' + error); }); /** * 将 inputPromise 的状态由未完成变成 rejected */ defer.reject('inputpromise rejected');// 控制台打印 fail: inputpromise rejected /** * 将 inputPromise 的状态由未完成变成 fulfilled */ //defer.resolve('inputpromise fulfilled');
Nach dem Login kopieren

可以使用 progress(function (progress)) 来专门针对进度信息进行处理，而不是使用 then(function (success) { }, function (error) { }, function (progress) { })

var Q = require('q'); var defer = Q.defer(); /** * 获取初始 promise * @private */ function getInitialPromise() {   return defer.promise; } /** * 为 promise 设置 progress 信息处理函数 */ var outputPromise = getInitialPromise().then(function (success) { }).progress(function (progress) {   console.log(progress); }); defer.notify(1); defer.notify(2); // 控制台打印 1，2
Nach dem Login kopieren

promise 链

promise 链提供了一种让函数顺序执行的方法

函数顺序执行是很重要的一个功能。比如知道用户名，需要根据用户名从数据库中找到相应的用户，然后将用户信息传给下一个函数进行处理

var Q = require('q'); var defer = Q.defer(); // 一个模拟数据库 var users = [{ 'name': 'andrew', 'passwd': 'password' }]; function getUsername() {   return defer.promise; } function getUser(username) {   var user;   users.forEach(function (element) {     if (element.name === username) {       user = element;     }   });   return user; } // promise 链 getUsername().then(function (username) {   return getUser(username); }).then(function (user) {   console.log(user); }); defer.resolve('andrew');
Nach dem Login kopieren

我们通过两个 then 达到让函数顺序执行的目的。

then 的数量其实是没有限制的。当然，then 的数量过多，要手动把他们链接起来是很麻烦的。比如

foo(initialVal).then(bar).then(baz).then(qux)
Nach dem Login kopieren

这时我们需要用代码来动态制造 promise 链

var funcs = [foo, bar, baz, qux] var result = Q(initialVal) funcs.forEach(function (func) {   result = result.then(func) }) return result
Nach dem Login kopieren

当然，我们可以再简洁一点

var funcs = [foo, bar, baz, qux] funcs.reduce(function (pre, current),Q(initialVal){   return pre.then(current) })
Nach dem Login kopieren

看一个具体的例子

function foo(result) {   console.log(result);   return result + result; } // 手动链接 Q('hello').then(foo).then(foo).then(foo); // 控制台输出： hello // hellohello // hellohellohello // 动态链接 var funcs = [foo, foo, foo]; var result = Q('hello'); funcs.forEach(function (func) {   result = result.then(func); }); // 精简后的动态链接 funcs.reduce(function (prev, current) {   return prev.then(current); }, Q('hello'));
Nach dem Login kopieren

对于 promise 链，最重要的是需要理解为什么这个链能够顺序执行。如果能够理解这点，那么以后自己写 promise 链可以说是轻车熟路啊

promise 组合

回到我们一开始读取文件内容的例子。如果现在让我们把它改写成 promise 链，是不是很简单呢？

var Q = require('q'),   fs = require('fs'); function printFileContent(fileName) {   return function () {     var defer = Q.defer();     fs.readFile(fileName, 'utf8', function (err, data) {       if (!err && data) {         console.log(data);         defer.resolve();       }     })     return defer.promise;   } } // 手动链接 printFileContent('sample01.txt')()   .then(printFileContent('sample02.txt'))   .then(printFileContent('sample03.txt'))   .then(printFileContent('sample04.txt'));  // 控制台顺序打印 sample01 到 sample04 的内容
Nach dem Login kopieren

很有成就感是不是。然而如果仔细分析，我们会发现为什么要他们顺序执行呢，如果他们能够并行执行不是更好吗? 我们只需要在他们都执行完成之后，得到他们的执行结果就可以了

我们可以通过 Q.all([promise1,promise2...]) 将多个 promise 组合成一个 promise 返回。注意：

1. 当 all 里面所有的 promise 都 fulfil 时，Q.all 返回的 promise 状态变成 fulfil

2. 当任意一个 promise 被 reject 时，Q.all 返回的 promise 状态立即变成 reject

我们来把上面读取文件内容的例子改成并行执行吧

var Q = require('q'); var fs = require('fs'); /** *读取文件内容 *@private */ function printFileContent(fileName) {   // Todo: 这段代码不够简洁。可以使用 Q.denodeify 来简化   var defer = Q.defer();   fs.readFile(fileName, 'utf8', function (err, data) {     if (!err && data) {       console.log(data);       defer.resolve(fileName + ' success ');     } else {       defer.reject(fileName + ' fail ');     }   })   return defer.promise; } Q.all([printFileContent('sample01.txt'), printFileContent('sample02.txt'), printFileContent('sample03.txt'), printFileContent('sample04.txt')])   .then(function (success) {     console.log(success);   }); // 控制台打印各个文件内容顺序不一定
Nach dem Login kopieren

现在知道 Q.all 会在任意一个 promise 进入 reject 状态后立即进入 reject 状态。如果我们需要等到所有的 promise 都发生状态后(有的 fulfil, 有的 reject)，再转换 Q.all 的状态, 这时我们可以使用 Q.allSettled

var Q = require('q'),   fs = require('fs'); /** *读取文件内容 *@private */ function printFileContent(fileName) {   // Todo: 这段代码不够简洁。可以使用Q.denodeify来简化   var defer = Q.defer();   fs.readFile(fileName, 'utf8', function (err, data) {     if (!err && data) {       console.log(data);       defer.resolve(fileName + ' success ');     } else {       defer.reject(fileName + ' fail ');     }   })   return defer.promise;     } Q.allSettled([printFileContent('nosuchfile.txt'), printFileContent('sample02.txt'), printFileContent('sample03.txt'), printFileContent('sample04.txt')])   .then(function (results) {     results.forEach(       function (result) {         console.log(result.state);       }     );   });
Nach dem Login kopieren

结束 promise 链

通常，对于一个 promise 链，有两种结束的方式。第一种方式是返回最后一个 promise

如 return foo().then(bar);

第二种方式就是通过 done 来结束 promise 链

如 foo().then(bar).done()

为什么需要通过 done 来结束一个 promise 链呢? 如果在我们的链中有错误没有被处理，那么在一个正确结束的 promise 链中，这个没被处理的错误会通过异常抛出

var Q = require('q'); function getPromise(msg, timeout, opt) {   var defer = Q.defer();   setTimeout(function () {     console.log(msg);     if (opt)       defer.reject(msg);     else       defer.resolve(msg);   }, timeout);   return defer.promise; } /** * 没有用 done() 结束的 promise 链 * 由于 getPromse('2',2000,'opt') 返回 rejected, getPromise('3',1000) 就没有执行 * 然后这个异常并没有任何提醒，是一个潜在的 bug */ getPromise('1', 3000)   .then(function () { return getPromise('2', 2000, 'opt') })   .then(function () { return getPromise('3', 1000) }); /** * 用 done() 结束的 promise 链 * 有异常抛出 */ getPromise('1', 3000)   .then(function () { return getPromise('2', 2000, 'opt') })   .then(function () { return getPromise('3', 1000) })   .done();
Nach dem Login kopieren

附录：一个 Promise 简单的应用（Node.js笔记（5）promise）

附：Promises/A+ 规范

promise 代表一个异步操作的最终结果。主要通过 promise 的 then 方法订阅其最终结果的处理回调函数，和订阅因某原因无法成功获取最终结果的处理回调函数。

更对详细见：Promises/A+

A 与 A+ 的不同点

A+ 规范通过术语 thenable 来区分 promise 对象

A+ 定义 onFulfilled/onRejectd 必须是作为函数来调用，而且调用过程必须是异步的

A+ 严格定义了 then 方法链式调用时，onFulfilled/onRejectd 的调用顺序

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

React Navigation实战中有哪些注意事项

JS callback回调函数使用案例详解

Das obige ist der detaillierte Inhalt vonSo ersetzen Sie die Callback-Funktion im Code durch Promise. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!