学习promise

总概括

• promise是js异步编程的一种解决方案
• 我对promise的认识（通俗）：给一个承诺promise，如果未来发生的事情（异步操作）是符合满足相应条件，则接受resolve，否则失败reject。这个决定是一旦做了，就不会发生改变。根据接受或失败承诺来决定下一步then应该做什么
• promise的基本使用
• 调用new Promise(func)构造函数，func是一个函数，会立即执行（和一般回调用不同）
• 一个promise的决议是一次且不可更改的
• 一个promise只有三种状态：pending, rejected, fulfilled
• resolve, reject不会终结函数的执行，只是设置了一下状态
• promise.then是promise决议后的下一步操作，它的返回仍是一个Promise对象

 1 //通过构造函数创建一个Promise对象
 2 //构造函数的参数是一个函数，该函数参数为resovle和reject
 3 //异步操作成功时调用resolve，失败时调用reject
 4 var promise = new Promise(function(resolve, reject){
 5     if(/*异步成功*/){
 6         resolve(value);//调用resolve，将promise状态置为接受
 7     }
 8     else{
 9         reject(error);//调用reject，将promise状态置为拒绝
10     }
11 });
12 //根据上面promise决议的结果，then决定下一步怎么做
13 promise
14 .then(
15     function(){/*promise决议结果为resolved*/},
16     function(){/*promise决议结果为rejected*/}
17 )

• Promise.prototype.then()决议后下一步的回调
• Promise.prototype.catch()决议中出现异常错误时的回调
• Promise.all([p1,p2...])参数为多个promise构成的数组，一个rejected则全部rejected，所有fulfilled才fulfilled
• Promise.race([p1,p2...])参数为多个promise构成的可枚举对象（如数组），以最先完成的为准
• Promise.resolve(), Promise.reject()：直接返回决议fulfilled或rejected的promise

Promise的决议

• promise只有三种状态：pending（未决议），fulfilled（成功），rejected（失败）
• 只决议一次，无法修改，无法中途取消或修改

 1 var promise = new Promise(function(resolve, reject){
 2     setTimeout(function(){
 3         resolve('resolve');
 4         reject('reject');//这次的决议会被忽略
 5     }, 3000);
 6 })
 7 promise.then(
 8     function(){
 9         console.log('第一次resolve');//setTimeout后，决议结果为resolve。虽然promise在下面会指向另一个rejected的对象
10     },
11     function(){
12         console.log('第一次reject');
13     }
14 )
15 //把promise指向另一个对象（决议失败）
16 promise = new Promise(function(resolve, reject){
17     reject();
18 })
19 promise.then(
20     function(){
21         conosle.log('第二次resolve');
22     },
23     function(){
24         console.log('第二次reject');
25     }
26 )

Promise.prototype.then()

• promise状态改变时的回调函数，接受两个参数，第一个是fulfilled回调，第二个是rejected回调
• 如果promise状态是pending的话，then里面的操作是不会执行的
• 仍然返回一个Promise对象，不是原来那个！
• 基于第二点，可以链式执行then。promise.then().then()...
• 对一个promise决议结果注册多个then，执行时按注册顺序执行（链式也是先执行完第一次注册的）

 1 var promise = new Promise((resolve, reject)=>{
 2     resolve('resolve');
 3 })
 4 var p1 = promise.then(()=>{
 5     console.log('第一个resolve then');
 6 })
 7 .then(function(){
 8     console.log('第一个resolve then后继续执行then')
 9 })
10 var p2 = promise.then(()=>{
11     console.log('第二个resolve then');
12 })
13 .then(()=>{
14     console.log('第二个resolve then后继续执行then');
15 })
16 //执行结果
17 //第一个resolve then
18 //第二个resolve then
19 //第一个resolve then后继续执行then
20 //第二个resolve then后继续执行then

Promise.prototype.catch()

• 用于指定发生错误时的回调函数，是.then(null, function(err){})的别名，也是返回一个promise(fulfilled)
• 在运行中抛出错误，状态会变成rejected。先注册了reject，则执行reject，若reject中无错则不再执行catch。否则执行catch
• 先resolve（状态已经确定），之后抛出错误，不会被catch捕获
• Promise 会吃掉错误：在promise内部的错误不会被外部发现

 1 //catch会捕获错误
 2 var promise = new Promise((resolve, reject)=>{
 3     throw new Error('promise error');
 4 });
 5 // promise.then(null, ()=>{
 6 //     console.log('故意throw Error，注册的reject回调');
 7 // })
 8 promise
 9 .catch((err)=>{
10     console.log('故意throw Error catch error: ', err);
11     console.log(promise);
12 })
13 //Promise会吃掉错误
14 promise = new Promise((resolve, reject)=>{
15     resolve();
16     throw new Error('promise error');//这个错误不会在外部被发现
17     console.log('抛出错误后的部分');//这里也不会执行
18 });
19 promise.then(()=>{//虽然throw错误了，但还是会执行这个resolve回调
20     console.log('resolve后，throw Error，注册的resolve回调');
21 })
22 .catch((err)=>{//并不能捕获上面resolve后的错误
23     console.log('resolve后，throw Error，注册的catch回调: ', err);
24 })

 Promise.all([p1, p2, p3])

• 当参数中所有promise都是fulfilled，才返回fulfilled promise
• 当出现一个rejected，则直接返回rejected promise。即使其它还在pending
• 参数中promise间不互相影响。如果前一个异常，后面也不会停止

 function tickPromise(index, t){
     return new Promise((resolve, reject)=>{
         setTimeout(function(){
             resolve();
             console.log('Promise.all 这是第' + index + '个promise');
         }, t);
     })
 }
 Promise.all([Promise.reject('reject'), tickPromise(1, 1000)])
 .then(
     function(){
         console.log('Promise.all reject先执行完：resolve');
     },
     function(){
         console.log('Promise.all reject先执行完：reject');
     }
 )

Promise.race([p1, p2, p3])

以最先执行的promise为准

Promise.resolve()

参数	操作
Promise对象	直接返回该对象（状态一致）
有then函数的对象	先返回pending状态promise，接着立即调用then函数
普通对象或值	以该值为参数调用resolve，返回一个promise

 var promise = Promise.resolve({
     then: function(resolve, reject){
         console.log('Promise.resolve: thenable对象的then函数');
         setTimeout(function(){resolve()}, 3000);
     }
 });
 console.log('promise.resolve刚赋值后的promise: ', promise);
 var interval = setInterval(function(){console.log(promise)}, 1000);
 setTimeout(function(){clearInterval(interval)}, 4000);
 //结果：
 //promise.resolve刚赋值后的promise:  Promise {<pending>}
 //Promise.resolve: thenable对象的then函数
 //Promise {<pending>}
 //Promise {<pending>}
 //Promise {<pending>}
 //Promise {<resolved>: undefined}

Promise.reject(param)

返回一个Promise，状态为rejected，值为传入的参数param