一、把任何异步操作包装成promise

1、假设需求：

（1）用户点击按钮，弹出确认窗体。

（2）用户确认和取消有不同的处理。

let confirm = popupManager.confirm('您确定么');
confirm.promise
  .then(() => {
    // do confirm staff
  })
  .catch(() => {
    // do cancel staff
  })

// 窗体的构造函数
class Confirm{
  constructor() {
    this.promise = new Promise((resolve, reject) => {
      this.confirmButton.onClick = resolve;
      this.cancelButton.onclick = reject;
    })
  }
}

一、promise.race()

1、类似promise.all(),区别在于它有任意一个完成就算完成。

2、常见用法

（1）把异步操作和定时器放在一起

（2）如果定时器先触发，就认为超时，告知用户。

一、promise.resolve()

1、返回一个fulfilled的promise实例，或原始promise实例。

（1）参数为空，返回一个状态为fulfilled的promise实例

（2）参数是一个跟promise无关的值，同上，不过fulfilled响应函数会得到这个参数。

（3）参数为promise实例，则返回该实例，不做任何修改。

（4）参数为thenable，立刻执行它的.then()函数

一、实现队列

1、forEach()

（1）

function queue(things) {
  let promise = Promise.resolve();
  things.forEach(thing => {
    promise = promise.then(() => {
      return new Promise(resolve => {
        doThing(thing, () => {
          resolve();
        });
      });
    });
  });
  return promise;
}
queue(['lots', 'of', 'things', ....]);

（2）常见错误：没有把.then()产生的新的promise实例赋给then,没有生成队列。

2、reduce()，数组的一端遍历到另一端。

（1）

function queue(things) {
  return things.reduce((promise, things) => {
    return promise.then(() => {
      return new Promise(resolve => {
        doThing(thing, () => {
          resolve();
        });
      });
    });
  }), Promise.resolve();
}
queue(['lots', 'of', 'things', ....]);

（2）常见错误：Promise实例创建之后，会立刻执行执行器代码，所以这个也无法达成队列的效果。

一、promise.all()：批量执行

1、Promise.all([p1, p2, p3,  …])用于将多个promise实例，包装成一个新的promise实例。

2、返回的实例就是普通promise

3、它接收一个数组作为参数。

4、数组里可以是promise对象，也可以是别的值，只有promise对象会等待状态改变。

5、当所有子promise都完成，该promise完成，返回值是全部值的数组。

6、有任何一个失败，该promise失败，返回值是第一个失败的子promise的结果

一、.catch()之后.then()

catch也会返回一个promise实例，如果没有抛出错误，也会是fulfilled状态，会执行后面的then()。

二、强烈建议在所有队列最后都加上.catch()，以避免漏掉错误处理造成意想不到的问题。

doSomething()
  .doAnotherThing()
  .doMoreThing()
  .catch(err => {
    console.log(err);
  })

一、错误处理

1、promise会自动捕获内部异常，并交给rejected响应函数处理。

2、promise试图在现有的语言框架中解决异步回调带来的问题。在栈的语言基层运行池相关的问题就无法处理了，我们能捕获到的是异步完成回调之后的这部分栈信息，仍然无法确定是哪里导致的错误。

3、promise执行器如果发生错误，执行器状态就会被置为rejected，fulfilled状态就不会被执行。

二、错误处理的2中做法

1、reject(‘错误信息’).then(null, message => {});

2、throw new Error(‘错误信息’).catch(message => {});

推荐使用第二种，更加清晰好读，并且可以捕获前面的错误。

new Promise(resolve => {
  setTimeout(() => {
    throw new Error('bye');
  }, 1000);
})
  .then(value => {
    console.log(value + 'world');
  })
  .catch(error => { // 整体捕获错误的方法，可以捕获promise的错误，也可以捕获then中的错误
    console.log('Error:', error.message);
  })

四种promise区别

一、.then()里有.then()的情况：一个响应函数中又有链式调用

1、因为.then()返回的还是promise实例。

2、会等里面的.then()执行完，在执行外面的。

3、对于我们来说，此时最好将其展开，会更好读。

.then()

1、.then()接受两个函数作为参数，分别代表fulfilled和rejected。

2、.then()返回一个新的promise实例，所以它可以链式调用。

3、当前面的promise状态改变时，.then()根据其最终状态，选择特定的状态响应函数执行。

4、状态响应函数可以返回新的promise，或其他值，或不返回值。

5、如果返回新的promise，那么下一级.then()会在新promise状态改变之后执行。

new Promise(resolve => { // 执行1
  setTimeout(() => {
    resolve('hello');
  }, 1000);
})
  .then(value => {
    console.log(value);  // 执行2
    console.log('everyone');
    (function() { // 执行5。1、这段代码中没有返回新的值，下面一行返回的promise实际是在这个函数中返回的，不是在then的响应函数中返回的，then返回的promise实例就没有等待里面的这个promise完成。2、一直在等待执行，等最后的then返回之后，再执行这个函数。3、没有进入promise队列中，但是进程仍然是登它执行完成后才算是完成。
      return new Promise(resolve => { // 自己用自己的回调
        setTimeout(() => {
          console.log('mr');
          resolve('marry');
        }, 2000)
      });
    }());
    return false; // 执行3。1、false会直接传递到下一步，成为下一个then的value
  })
  .then(value => { // 执行4
    console.log(value + 'world'); // value = false;
  })

一、

promise队列的重要特性，在任何地方生成了一个promise队列之后，我们可以把它作为一个变量传递到其他地方，如果我们的操作是队列的状态，即先进先出的状态，就可以在后面追加任意多的then，不管之前的队列是完成还是没有完成，队列都会按照顺序完成。

二、

let promise = new Promise(resolve => {
  setTimeout(() => {
    console.log('the promise fulfilled');
    resolve('hello');
  }, 1000);
});
setTimeout(() => {
  promise.then(value => {
    console.log(value);
  })
})

一、promise

1、promise是一个代理对象，它和原先要进行的操作并无关系。

2、它通过引入一个回调，避免更多的回调。

二、promise的3个状态

1、pending(待定)：初始状态

2、fulfilled(实现)：操作成功

3、rejected（被否决）：操作失败

三、promise状态发生改变，就会触发.then()里的响应函数处理后续步骤。

promise状态一经改变，不会再变。

四、

new Promise(
  // 执行器executor
  function(resolve, reject) {
    // 一段耗时很长的异步操作
    resolve(); // 数据处理完成
    reject(); // 数据处理出错
  }
).then(function A() {
  // 成功，下一步
  }, function B() {
  // 失败，做相应处理
})

回调函数四个问题：

1. 嵌套层次很深

2. 无法正常使用return 和throw

3. 无法正常检索堆栈信息

4. 多个回调函数之间难以建立联系

promise