ES6新特性之Promise

基本概念

从字面意思上来看，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));
  

转载于:https://my.oschina.net/u/4144971/blog/3096601