来说说Promise和事件循环吧
Promise是什么?为什么要使用?
为什么使用Promise
这篇关于promise的blog其实已经是3年前写的了,但是一直在草稿状态。由于当时的项目开始使用ES6,我第一次接触到promise这个概念,当时还花了一点时间去了解。
现在每一个前台工作者一定非常熟习promise,它是用于解决异步的!那么,为什么要用promise呢?
首先看一个项目上的例子:
let submit = function(params){ validate(params, res=>{ if(res.data === "TRUE"){ submitData(params, res=>{ if(res.data === "TRUE"){ // other actions } }) } })}以上例子,实现一个表单提交功能,在真正把数据提交到后端之前,先要做一次校验,校验通过才允许客户提交。
再来看一下:
// 以下三个函数模拟异步方法function job1(fn){ setTimeout(() => { fn("job1 success"); }, 150);}function job2(fn){ setTimeout(() => { fn("job2 success"); }, 200);}function job3(fn){ setTimeout(() => { fn("job3 success!"); }, 100);}(function(){ job1((res=>{ console.log(res); })); job2((res=>{ console.log(res); })); job3((res=>{ console.log(res); }));})();以上输出:
job3 success
job1 success
job2 success
假如我们的需求是,job1, job2, job3必需按顺序执行,代码得改成:
(function(){ job1((res=>{ console.log(res); job2((res=>{ console.log(res); job3((res=>{ console.log(res); })); })); }));})();这里和上面的例子,都使用了嵌套的写法,假如逻辑再复杂一点,嵌套层数会更多,容易陷入回调地狱(callback hell)。
Ajax和Node.js的回调地狱例子就非常经典了。而promise就是为理解决这个问题。
promise是如何解决的呢?
假如可以写成 job1.then(job2).then(job3)… 是不是好多了?
把异步方法修改为Promise
function job1(){ return new Promise((resolve, reject)=>{ setTimeout(() => { console.log("job1 success"); resolve("job1 success"); }, 150); }) }function job2(){ return new Promise((resolve, reject)=>{ setTimeout(() => { console.log("job2 success"); resolve("job2 success"); }, 200); })}function job3(){ return new Promise((resolve, reject)=>{ setTimeout(() => { console.log("job3 success"); resolve("job3 success"); }, 100); })}这时候即可以使用链式方法调用了
(function(){ job1().then(job2).then(job3).then(res=>{console.log(res);})})();那么,一开始的例子也可以改写成
let submit = function(params){ validate(params) .then(submitData(params)) .then(res=>{ });}下面,我们一起来看看Promise是怎么实现的
什么是Promise
定义
Promise对象用于表示一个异步操作的最终完成 (或者失败)及其结果值。
状态
一个 Promise 必然处于这几种状态之一:pending(进行中)fulfilled(已成功)rejected(已失败)
状态的变化只有两种方法:pending变成fulfilled,pending变成rejected,状态变化时,有以下的方法来解决:
方法
then(onFulfilled, onRejected) 增加处理(fulfillment)和拒绝(rejection)回调到当前 promise, 返回一个新的 promise, 将以回调的返回值来resolvecatch(onRejected) 增加一个拒绝(rejection) 回调到当前 promise, 返回一个新的promisefinally(onFinally) 增加一个事件解决回调于当前promise对象,并且在原promise对象解析完毕后,返回一个新的promise对象。回调会在当前promise运行完毕后被调用,无论当前promise的状态是完成(fulfilled)还是失败(rejected)
// MDN上的例子const myPromise = (new Promise(myExecutorFunc)) .then(onFulfilledA,onRejectedA) .then(onFulfilledB,onRejectedB) .then(onFulfilledC,onRejectedC);或者者使用以下写法
const myPromise = (new Promise(myExecutorFunc)) .then(onFulfilledA) .then(onFulfilledB) .then(onFulfilledC) .catch(onRejectedAny);上面的例子,即可以写成:
let onFulfilled = (data)=>{ console.log("Fulfilled: ", data); }let onRejected = (error)=>{ console.log("Error: ", error); }let onFinally = ()=>{ console.log("Finally."); }(function(){ job1().then(job2).then(job3).then(onFulfilled) .catch(onRejected) .finally(onFinally);})();输出:
job1 success
job2 success
job3 success
Fulfilled: job3 success
Finally.
如果其中一个job有error,那么输出是
job1 success
job2 error
Error: job2 error
Finally.
可以看出,无论当前promise的状态是完成(fulfilled)还是失败(rejected),finally()都会被调用。
再来看看另一种写法:
(function(){ job1() .then(job2) .then(job3) .then(onFulfilled,onRejected) .finally(onFinally);})();使用then(onFulfilled,onRejected) 代替catch(onRejected),输出和以上例子一样,所以,catch(onRejected) 其实是把then(onFulfilled,onRejected)的预留参数onFulfilled省略了,没有本质上的区别。
再来做一点修改
(function(){ job1() .then(job2,onRejected) .then(job3,onRejected) .then(onFulfilled,onRejected) .finally(onFinally);})();输出:
job1 success (第二行 job1 的输出)
job2 error (第三行 job2的输出)
Error: job2 error (第四行 onRejected 的输出)
Fulfilled: undefined (第五行 onFulfilled 的输出)
Finally. (第六行 onFinally 的输出)
job2的promise调用了reject方法,状态变成rejected,所以在then()的时候调用了onRejected,但是promise的方法都会返回一个新的promise,所以在第五行的时候,then()对应的promise是上一行onRejected()返回的promise, 会调用onFulfilled()
任何不是 throw 的终止都会创立一个”已决议(resolved)”状态,而以 throw 终止则会创立一个”已拒绝”状态。
假如我们把onRejected()修改一下
let onRejected = (error)=>{ console.log("Error: ", error); throw new Error(error);}那么,上面的输出就变成:
job1 success (第二行 job1 的输出)
job2 error (第三行 job2的输出)
Error: job2 error (第四行 onRejected 的输出)
Error: Error: job2 error (第五行 onRejected 的输出) *
at onRejected (…/test.js:34:9)
at processTicksAndRejections (internal/process/task_queues.js:93:5)
Finally. (第六行 onFinally 的输出)*
静态方法
有一个使用得比较多的方法是Promise.all(),先来看代码
(function() { let p1 = job1(); let p2 = job2(); let p3 = job3(); Promise.all([p1, p2, p3]).then(values=>{ console.log(values); // })})();输出:
job3 success
job1 success
job2 success
[ ‘job1 success’, ‘job2 success’, ‘job3 success’ ]
Promise.all()方法接收一个promise的iterable类型(注:Array,Map,Set都属于ES6的iterable类型)的输入,并且只返回一个Promise实例, 那个输入的所有promise的resolve回调的结果是一个数组。
但是这里注意一下,和上面的比照,job1、job2、job3不是按顺序执行的。
我们是不是还可能用上面then(onFulfilled,onRejected)或者者catch(onRejected)来使用呢?
(function() { let p1 = job1(); let p2 = job2(); let p3 = job3(); Promise.all([p1, p2, p3]).then(onFulfilled, onRejected).finally(onFinally);})();// 或者者(function() { let p1 = job1(); let p2 = job2(); let p3 = job3(); Promise.all([p1, p2, p3]).then(onFulfilled).catch(onRejected).finally(onFinally);})();输入都是:
Error: job2 error
Finally.
Promise.all 在任意一个传入的 promise 失败时返回失败。
由于job2的状态是失败了,所以最后调用的是onRejected
Promise与事件循环
当涉及异步事件的时候,事件循环就成是了个很让人头大的问题。先来看看概念:
- 宏任务
- 主代码块
- setTimeout
- setInterval
- setImmediate ()-Node
- requestAnimationFrame ()-浏览器
- 微任务
- process.nextTick ()-Node
- Promise.then()
- catch
- finally
- Object.observe
- MutationObserver
为了更好了看出执行顺序,我们先来修改一下上面的job的定义
function job1(){ return new Promise((resolve, reject)=>{ console.log("job1 start...") setTimeout(() => { console.log("job1 success"); resolve(1); }, 150); //定时器,150ms后执行 })}function job2(){ return new Promise((resolve, reject)=>{ console.log("job2 start...") setTimeout(() => { console.log("job2 success"); resolve(2); }, 100); //定时器,100ms后执行 })}function job3(){ return new Promise((resolve, reject)=>{ console.log("job3 start...") setTimeout(() => { console.log("job3 success"); resolve(3); },0); })}调用方法如下
console.log("***** START ******");let p1 = job1();let p2 = p1.then(job2);let p3 = p2.then(job3);let p = p3.then(onFulfilled);console.log(p1, p2, p3, p);setTimeout(() => { console.log('500ms: the stack is now empty'); console.log(p1, p2, p3, p);},500);setTimeout(() => { console.log('0ms...');},0);setTimeout(() => { console.log('250ms...');},250);console.log("***** END ******");输入顺序会是怎么呢?
分析:
根据事件循环,
- 先执行同步方法
console.log("***** START ******"); - 构造函数
new Promise()是同步任务,所以执行 job1的console.log("job1 start...") - 遇到
setTimeout,移交给定时器线程,150ms后放入宏任务队列,到此job1结束 - 接下都是
Promise.then()的方法,是异步微任务,放入微任务队列 - 执行
console.log(p1, p2, p3, p);,这时,promise的状态都是pending - 遇到
setTimeout,移交给定时器线程,500ms后放入宏任务队列 - 遇到
setTimeout,移交给定时器线程,0ms后放入宏任务队列(即便是0,但是依然要按规矩) - 遇到
setTimeout,移交给定时器线程,250ms后放入宏任务队列 - 执行
console.log("***** END ******"),到这里主线程执行完毕 - 开始执行任务队列,
宏任务队列中根据时间顺序: [0ms, 200ms,250ms, 500ms]
a. 执行console.log('0ms...');
b. 执行console.log("job1 success");和resolve(1);
c. 执行console.log('250ms...');
d. 执行console.log('500ms: the stack is now empty'');和console.log(p1, p2, p3, p);
但是这里注意一下,当一个宏任务执行完,会在渲染前,将执行期间所产生的所有微任务都执行完 。b任务执行完的时候,p1.then(job2)会执行,即会执行console.log("job2 start..."),但是因为job2中也有setTimeout,根据时间放入宏任务队列
最后输出:
***** START ******job1 start...Promise { <pending> } Promise { <pending> } Promise { <pending> } Promise { <pending> }***** END ******0ms...job1 successjob2 start...job2 successjob3 start...250ms...job3 successFulfilled: 3500ms: the stack is now emptyPromise { 1 } Promise { 2 } Promise { 3 } Promise { 'Completed!' }最后所有promise都是fulfilled/rejected状态
Promise.all()的同步和异步
假如使用Promise.all()呢?
console.log("***** START ******");let p1 = job1();let p3 = job3();let p2 = job2();let p = Promise.all([p1, p2, p3]);let ep = Promise.all([]);console.log(p1, p2, p3);console.log(ep, p);setTimeout(() => { console.log('the stack is now empty'); console.log(p1, p2, p3, p);},500);setTimeout(() => { console.log('0ms...');},0);console.log("***** END ******")结果:
***** START ******job1 start...job3 start...job2 start...Promise { <pending> } Promise { <pending> } Promise { <pending> }Promise { [] } Promise { <pending> }***** END ******job3 success0ms...job2 successjob1 successthe stack is now emptyPromise { 1 } Promise { 2 } Promise { 3 } Promise { [ 1, 2, 3 ] }这里有一个注意点:
Promise.all当且仅当传入的可迭代对象为空时为同步
所以最开始的时候,console.log(ep, p);的输出一个是fulfilled,一个是pending
参考文章:
HTML Standard
MDN上的说明
Promise+
讲JS运行机制,事件循环讲得很清晰
1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是摆设,本站源码仅提供给会员学习使用!
7. 如遇到加密压缩包,请使用360解压,如遇到无法解压的请联系管理员
开心源码网 » 来说说Promise和事件循环吧