ES6新特性之Promise

1：基本概念

从字面意思上来看，Promise 是承诺。它表示一个异步操作的最终状态（完成或失败），以及该异步操作的结果值。根据 Pormise 的执行结果可以拿到一个最终状态。

new Promise（{function(resolve,reject){/* executor */}
}）;

一般来讲，有三种状态：

• pending，进行中
• fulfilled，已成功
• rejected，已失败

关于三种状态，实际上分为两种情况：一种是从 pending 到 fulfilled，也就是执行然后成功；另一种 pending 到 rejected 是执行，然后失败。Promise 的状态一旦确定就不再改变。只能够从 pending 到 fulfill 或者是从 pending 到 rejected，确定之后的状态称之为 resolved。resolved 之后添加回调会立即执行得到结果，resolved 一般指的是 fulfilled 状态。

一旦新建会立即执行，无法中途取消。Promise 构造函数执行时立即调用 executor 函数。

基本用法

• Promise 接收一个函数作为参数，该函数的参数分别是 resolved 和 reject

    let promise = new Promise(function(resolve,reject){console.log('new promise');
        setTimeout(function(){console.log('promise resolved');
            return resolved('success');
        },1000);
    });

• Promise 实例生成后在 then 方法中指定 resolved 状态和 rejected（可选）状态的回调函数
  promise.then(function(value){

  console.log('resolved callback',value);

  });

• Promise 传递
  const promise1 = new Promise(function (resolve,reject)){

  /* .... */

  }

属性和方法

• Promise.prototype.then，是 Promise 状态改变时的回调函数，也就是定义了一个承诺，那么得到的结果是什么。它返回一个新的 Promise，新的 Promise 意味着可以链式调用，也就是.then 之后还可以.then。

    // 顺次调用
    let promise1 = new Promise(function(resolve, reject) {console.log('new promise1');
    
        setTimeout(function() {console.log('promise1 resolved');
            return resolve("promise1 success");
        }, 2000);
    });
    
    let promise2 = new Promise(function(resolve, reject) {console.log('new promise2');
    
        setTimeout(function() {console.log('promise2 resolved');
            return resolve("promise2 success");
        }, 4000);
    });
    
    promise1
      .then(function(value) {console.log('then1 callback', value);
        return value;
      })
      .then(function(value) {console.log('then2 callback', value);
        return promise2;
      })
      .then(function(value) {console.log('then3 callback', value);
        return '';
      })

• Promise.prototype.catch(错误捕获)

错误发生时的回调函数，相当于.then（null/undefined，reject）的一个别名，它捕获 reject 以及 then 回调运行时的错误。

    // 顺次调用
    let promise = new Promise(function(resolve, reject) {throw new Error('Error');
    });
    promise.catch(function(error) {console.log(error);
    });
    
    // Error: Error 

• Promise.prototype.finally（最后）

不管成功或失败，这个方法无论状态如何都会执行。它不接受任何参数，与状态无关，不依赖 Promise 执行结果。

• Promise.all（所有）

把所有的 Promise 放在一起，然后当所有的 Promise 全部 resolved，这个 Promise.all 才会真正的 resolved。也就是所有的成功了它才成功，可以理解成一个包装器，它包装多个 Promise 为一个新的 Promise，那么 Promise.all 实际上接收的是一个数组，fulfilled 条件是所有包装的 Promise 全部 fulfilled。

    const promise1 = new Promise((resolve, reject) => {
      resolve({
        code: 200,
        data: [],});
    })
      .then(result => result)
      .catch(err => ({
        code: 200,
        data: [],}));
      
       const promise2 = new Promise((resolve, reject) => {throw new Error('Error');
      })
        .then(result => result)
        .catch(err => ({
          code: 200,
          data: [],}));
    
      Promise.all([promise1, promise2])
        .then(result => console.log(result))
        .catch(e => console.log(e));

使用 Promise.all，我们需要给每一个 Promise 都加一个 catch，返回一个备用的结果，这个月整个的 Promise.all 才会得到一个 resolved 结果。
Promise.race（谁先返回就先执行谁）
包含多个 Promise 为一个新的 Promise，返回第一个 fulfilled。

    const promise = Promise.race([fetch('/url'),
        new Promise(function (resolve, reject) {setTimeout(() => {return reject(new Error('request timeout'));
          }, 5000);
        })
      ]);
    
      p
        .then(console.log)
        .catch(console.error);

• Promise.resolve（状态）

将现有对象转为 Promise 对象，状态为 fulfilled。

    const promise = Promise.resolve('hello');
    promise.then(res => alert(res));

• Promise.reject

将现有对象转为 Promise 对象，状态为 rejected。

    const promise = Promise.reject('word');
    promise.then(res => alert(res)).catch(err => alert(err));