Promise

Promise

用于异步编程，存着某个异步操作的结果。

一个对象，从Promise可以获取异步操作的消息，Promise提供统一的api

特点

1. 对象的状态不受外界影响。Promise对象代表一个异步操作，三种状态

   • pending(进行中)、fulfilled、rejected，只有异步操作结果可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。
   • 一旦状态改变，就不会再变。两种变化pending->rejected、pending->fulfilled,称为已定型，resolved（仅指代fulfilled）。此时对Promise对象添加回调函数就会立即得到结果
   • 缺点：无法取消Promise,一旦建立立即执行，无法中途取消。
     • 若不设置回调函数，Promise内部报错不会反映到外部，当处于pending状态时，无法得知最终状态

2. 基本用法

   //创造一个Promise实例
   const promise  = new Promise(function(resolve,reject){
       if(/*异步成功 */){
           resolve(value);
       }else{
           reject(error);
       }
   })
   
   //Promise实例生成后用then方法指定resolved和rejected状态返回回调函数
   promise.then(function(value){
       //success
   },function(error){
       //failure
   })
   

   function timeout(ms){
       return new Promise((resolve,reject)=>{
           setTimeout(resolve,ms,'donesss');
       })
   }
   
   timeout(1000).then((value)=>{
       console.log(value);     //donesss
   })
   
   console.log(111)
   
   // 111
   // donesss
   

   let promise = new Promise(function(resolve,reject){
       console.log('Promise');
       resolve();
   });
   
   promise.then(function(){
       console.log('resolved');
   })
   
   console.log('Hi!');
   
   // Promise Promise立即执行
   // Hi!
   // resolved
   

   //p1的状态决定了p2
   const p1 = new Promise(function(resolve,reject){
       setTimeout(()=>reject(new Error('fail')),3000);
   })
   
   const p2 = new Promise(function(resolve,reject){
       setTimeout(()=>resolve(p1),1000);
   })
   
   p2.then(result=>console.log(result))
       .catch(error=>console.log('rejected',error));//p1 rejected导致p2状态无效，then针对p1变为rejected出发catch
   //rejected Error: fail
   
   

3. Promise.prototype.then()

   then方法返回一个新的Promise实例，作用是为Promise实例添加状态改变时的回调函数

4. Promise.prototype.catch()

   .then(null,rejection)或.then(undefined,rejection)的别名，用于指定发生错误时的回调

5. Promise.prototype.finally()

   finally()不论Promise对象最后状态如何都会执行的操作

   不接受任何参数，意味着不知道前面Promise的状态，则finally()的操作不应与状态无关，也不依赖与Promise的执行结果

   本质时then的特例

6. Promise.all()

   用于返回多个Promise实例，包装成一个新的Promise实例

   const p = Promise.all([p1,p2,p3]);
   //仅当p1,p2,p3的状态都为fulfilled,p的状态才变为fulfilled
   //只要有一个变为rejected，p就会变为rejected,
   //p1,p2,p3都是Promise实例不是则调用Promise.resolve()转为Promise实例再进行处理
   

   Promise.all()的参数可以不是数组，但必须具有Iterator,且返回的每个成员都是Promise实例

   const promise = [2,3,4,5,6].map(function(id){
       return getJSON('/post/'+id+'.json');
   })
   
   Promise.all(promise).then(function(posts){
       //...
   }).catch(function(){
       //...
   })
   

7. Promise.race()

   将多个Promise实例包装成一个新的Pormise实例，率先返回的实例状态作为p的状态，

   const p = Promise.race([p1,p2,p3]);
   //p1,p2,p3中状态率先改变的实例的返回值传递给p的回调函数
   

8. Promise.allSettled()

   确定所有Promise对象都发生状态变更后，返回的Promise对象才会发生状态变更

   状态发生变更后，状态总是fulfilled，回调函数接收一个数组作为参数，数组元素为前面的每一个Promise对象

   const resolved = Promise.resolve(42)
   const rejected = Promise.reject(-1)
   
   const allSettledPromise = Promise.allSettled([resolved,rejected]);
   
   allSettledPromise.then(function(results){
       console.log(results[0]);
       console.log(results[1]);
   })
   //{status: 'fulfilled', value: 42}
   //{status: 'rejected', reason: -1}
   

9. Promise.any()

   只要有一个实例fulfilled，实例就变成fullfilled状态，

   当所有rejected,实例才变成rejected

10. Promise.resolve()

    将现有对象转为Promise对象，

    Promise.resolve('foo')
    //等价于
    new Promise(resolve=>resolve('foo'))
    
    const p = Promise.resolve()//得到一个Promise对象
    

11. Promise.reject()

    返回新的Promise实例，其状态为rejected

12. Promise.try()

    模拟try代码块