Promise 构造函数接收一个函数作为参数，该函数有两个参数 resolve和reject ,他们是两个函数 ，js引擎提供。
1）resolve函数的作用是 ，将Promise对象状态从“pending”变为resolved,在异步造作成功后调用 ，并将异步操作结果作为参数传递出去。
2）reject函数的作用是 ,将Promise对象状态从“未完成”变为“失败”（即从pendding 变为 rejectd）,在异步操作失败时调用 ，并将异步操作报出的错误，作为参数传递出去。
3）promise实例生成以后，可以用then方法分别指定resolved和rejected状态回调函数

浅析Promise用法

关键词：Promise，resolve，reject，Prepending，Resolve，Reject，then，catch，all，race

所谓Promise，简单说就是一个容器，里面保存着某个未来才会结束的事件（通常是一个异步操作）的结果。从语法上说，Promise 是一个对象，从它可以获取异步操作的消息。Promise 提供统一的 API，各种异步操作都可以用同样的方法进行处理。

Promise对象有以下两个特点。
（1）对象的状态不受外界影响。Promise对象代表一个异步操作，有三种状态：Pending（进行中）、Resolved（已完成，又称 Fulfilled）和Rejected（已失败）。只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。这也是Promise这个名字的由来，它的英语意思就是“承诺”，表示其他手段无法改变。
（2）一旦状态改变，就不会再变，任何时候都可以得到这个结果。Promise对象的状态改变，只有两种可能：从Pending变为Resolved和从Pending变为Rejected。只要这两种情况发生，状态就凝固了，不会再变了，会一直保持这个结果。就算改变已经发生了，你再对Promise对象添加回调函数，也会立即得到这个结果。这与事件（Event）完全不同，事件的特点是，如果你错过了它，再去监听，是得不到结果的。
有了Promise对象，就可以将异步操作以同步操作的流程表达出来，避免了层层嵌套的回调函数。此外，Promise对象提供统一的接口，使得控制异步操作更加容易。

要理解Promise要知道没有Promise的回调地狱：

一般我们要在一个函数执行完之后执行另一个函数我们称之为callback‘回调’，简单的写一下：

setTimeout(function(){
  left(function(){
    setTimeout(function(){
       left(function(){
         setTimeout(function(){
           left();
         },2000);
       });
    }, 2000);
  });
}, 2000);

以上代码就是传说中的回调地狱，如果有多层业务逻辑嵌套的话，不仅会使代码阅读困难，而且后面维护起来也是难点。
之后在ES6，Promise就应运而生。

Promise语法与then的用法：

var promise = new Promise(function(resolve, reject) {
  // ... some code
  if (/* 异步操作成功 */){
    resolve(value);
  } else {
    reject(error);
  }
});

resolve(value)是在Promise在已经异步完成成功(Resolved)之后执行的
reject(value)是在Promise在异步失败之后(Rejected)执行。
当然，也可以用then来指定：then(resolve,reject)
或者：then(resolve),catch(reject)

promise.then(function(value) {
  // success
}, function(error) {
  // failure
});
//等价于：
promise.then(function(){
  //success
}).catch(function(){
  //failure
})

范例展示：写一个img图片加载示例点击

Tips

1. 连续调用回调：
   以刚开始的回调地狱为例子:

setTimeout(function(){
  left(function(){
    setTimeout(function(){
       left(function(){
         setTimeout(function(){
           left();
         },2000);
       });
    }, 2000);
  });
}, 2000);
//我们给left函数内容换成console.log(11);

 var p = new Promise((resolve,reject)=>{
    setTimeout( resolve , 2000 )
  })
  .then( ()=>setTimeout( null, 2000 ) )
  .then( ()=>setTimeout(function(){
    console.log(11)
  },2000) )
//这样在6秒钟之后会打出11

范例点击
总结：

• 可以采用连续的then链式操作来写回调（这是因为返回值一直是新的Promise实例）。
• 以上例子可以看出来只要在第一个promise回调中添加resolve，之后的连续then就会默认执行。

2. 可以在then中return出数据，并且这个数据会以参数的形式传入下一个then。

var p = new Promise(function(resolve,reject){
      var a=1
      resolve(a);  

  }).then(function(data){
      console.log(data)
      return ++data;
  }).then( function(data){
      console.log(data)
  } )
//打印出来的结果依次是： 1  2 。

接下来介绍一下catch()

• catch是用于指定发生错误时的回调函数。（建议不要在then的第二个参数写rejected状态，总是使用catch）
• catch()使回调报错时不会卡死js而是会继续往下执行。点击范例
• Promise 对象的错误具有“冒泡”性质，会一直向后传递，直到被捕获为止。也就是说，错误总是会被下一个catch语句捕获。
  如：

getJSON('/post/1.json').then(function(post) {
  return getJSON(post.commentURL);
}).then(function(comments) {
  // some code
}).catch(function(error) {
  // 处理前面三个Promise产生的错误
});

用一段小代码来理解catch()

var p = new Promise((resolve,reject)=> {
    n
  } ).then(()=>console.log('运行成功'))
  .catch( ()=>{a;console.log('报错');} )//这里我们没有定义a的值会报错
  .catch( ()=> console.log('报错2') )
  .then( ()=>console.log('报错后的回调') )
//运行结果是：'报错2'  '报错后的回调'

首先n没有定义，所以第一层出错。下一个then的‘运行成功’不会被打出来。而是会被下一个catch捕获，第一个catch没有定义a，所以报错，console.log('报错')没办法打出来，又被下一个catch捕获： 第二个catch没有问题：打出‘报错2’。运行成功传给下一个then，打出'报错后的回调'。

这里要注意，不管是then或者catch返回的都是一个新的Promise实例！而每个Primise实例都有最原始的Pending（进行中）到Resolve（已完成），或者Pending（进行中）到Reject（已失败）的过程。

Promise.all()

Promise.all方法用于将多个Promise实例，包装成一个新的Promise实例。

如：

var p = Promise.all([p1, p2, p3]);

all()接受数组作为参数。p1,p2,p3都是Promise的实例对象，p要变成Resolved状态需要p1，p2，p3状态都是Resolved，如果p1,p2,p3至少有一个状态是Rejected，p的状态就变成Rejected（个人感觉很想&&符号链接）

Promise.race();

var p = new Promise( [p1,p2,p3] )

上面代码中，只要p1、p2、p3之中有一个实例率先改变状态，p的状态就跟着改变。那个率先改变的 Promise 实例的返回值，就传递给p的回调函数。（感觉就是||符号操作~~~）

Promise resolve():

有时需要将现有对象转为Promise对象，Promise.resolve方法就起到这个作用。
Promise.resolve等价于下面的写法。

Promise.resolve('foo')
// 等价于
new Promise(resolve => resolve('foo'))

Promise reject()

Promise.reject(reason)方法也会返回一个新的 Promise 实例，该实例的状态为rejected。

Promise.reject('foo')
// 等价于
new Promise(reject => reject('foo'))

注意，Promise.reject()方法的参数，会原封不动地作为reject的理由，变成后续方法的参数。这一点与Promise.resolve方法不一致。