Promise对象着重解决JS编程中异步回调问题，例如ajax请求所产生的一系列回调操作

  1. ajaxSend(function() {
  2.     ajaxSend(function() {
  3.       ajaxSend({
  4.         ....
  5.     });
  6.   })
  7. });

语法

  1. new Promise(resolve , reject) {
  2.   //resolve , 成功的时候调用
  3.   //reject，失败的时候调用
  4. }

简单的实例

  1. let a = 10;
  2. let p = new Promise(resolve , reject) {
  3.   if(a>=10) {
  4.       resolve('成功');
  5.   } else {
  6.       reject('失败');
  7.   }
  8. }
  9. //调用1
  10. p.then(res=>{
  11.     console.log(res');
  12. } , err=>{
  13.     console.log(err);
  14. });
  15. //调用2
  16. p.then(function(res) {
  17.     console.log(res);
  18. }).catch(function(err) {
  19.     console.log(err);
  20. });

方法

Promise.resolve()

返回一个成功状态的Promise对象

  1. //resolve: 返回一个成功状态的Promise对象
  2. Promise.resolve('成功');
  4. //等价于
  5. new Promise(resolve , reject) {
  6.     resolve('成功');
  7. }

Promise.reject()

返回一个失败状态的Promise对象

  1. //resolve: 返回一个成功状态的Promise对象
  2. Promise.reject('失败');
  4. //等价于
  5. new Promise(resolve , reject) {
  6.     reject('失败');
  7. }

Promise.all()

批量执行Promise任务，然后在结果组成一个数组返回，而且必须所有的Promise都是成功状态

  1. let p1 = Promise.resolve('成功1');
  2. let p2 = Promise.resolve('成功2');
  3. let p3 = Promise.resolve('成功3');
  5. Promise.all([p1,p2,p3]).then(function(res) {
  6.     console.log(res); //["成功1" , "成功2" , "成功3"]
  7.   let [res1 , res2 , res3 ] = res; //解构获取
  8. }).catch(function(err) {
  9.     console.log(err); //['失败1']
  10. });

Promise.race()

批量执行Promise任务，然后在结果组成一个数组返回，只要遇到一个resolve状态就返回

  1. let p1 = Promise.resolve('成功1');
  2. let p2 = Promise.reject('失败1');
  4. Promise.race([p1,p2]).then(function(res) {
  5.     console.log(res); //["成功1"]
  6. }).catch(function(err) {
  7.     console.log(err); //['失败1']
  8. });
  10. //最终输出结果: 成功1