Promise

promise介绍

Promise是异步编程的一种解决方案，比传统的解决方案（回调函数和事件）更合理更强大。它由社区最早提出和实现，ES6将其写进了语言标准，统一了用法，原生提供了Promise对象。

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

有了Promise对象，就可以将异步操作以同步操作的流程表达出来，避免了层层嵌套的回调函数。此外，Promise对象提供统一的接口，使得控制异步操作更加容易。

基本用法

Promise构造函数接收一个函数作为参数，该函数的两个参数分别是reolve和reject。它们是两个函数，有JavaScript引擎提供，不用自己部署。

resolve函数的作用是，将Promise对象的状态从“未完成”变为“成功”（即从Pending变为Resolved），在异步操作成功时调用，并将异步操作的结果作为参数传递出去。

reject函数的作用是，将Promise对象的状态从“未完成”变为“失败”（即从Pending变为Rejected），在异步操作失败时调用，并将异步操作的结果作为参数传递出去。

如果调用resolve和reject函数时带有参数，那么它们的参数会被传递给回调函数。

const pro = new Promise((resolve,reject) =>{
             //传递参数只能有一个，表示推向状态的数据
            resolve("123")
            // reject("false")
        })
        pro.then(data=>{
            // thenable函数 ，此时promise已经到达已决阶段，resolved状态
            console.log(data)
        },err=>{
            // cathable函数 ，此时promise已经到达已决阶段，rejected状态
            console.log(err)
        })

Promise实例生成以后，可以调用then方法分别指定Resolved状态和Rejected状态的回调函数。

.then(function(){
        //success
     },
     function(){
        //error
     });

promise.prototype.then()

then方法的第一个参数是Resolved状态的回调函数，第二个参数（可选）是Rejected状态的回调函数。then方法返回的是一个新的Promise实例（注意：不是原来的Promise实例）。
因此可以采用链式写法，即then方法后面再调用另一个then方法。如果使用两个then方法，第一个回调函数完成以后，会将返回结果作为参数，传入第二个回调函数。

getJSON("/posts.json").then(function(json) {
return json.post;
}).then(function(post) {
// ...
});

getJSON("/post/1.json").then(
post => getJSON(post.commentURL)
).then(
comments => console.log("resolved: ", comments),
err => console.log("rejected: ", err)
);

promise.prototype.catch()

Promise.prototype.catch方法是.then(null,rejection)的别名，用于指定发生错误时的回调函数。
一般来说，不要在then方法里面定义Reject状态的回调函数（即then的第二个参数），总是使用catch方法。

Promise对象的错误具有“冒泡”性质，会一直向后传递，直到被捕获为止。也就是说，错误总是会被下一个catch语句捕获。

在resolve的回调中，我们console.log(somedata);而somedata这个变量是没有被定义的。
如果我们不用Promise，代码运行到这里就直接在控制台报错了，不往下运行了，但是在Promise 里是传入带catch里去了，
也就是说进到catch方法里面去了，而且把错误原因传到了reason参数中。
即便是有错误的代码也不会报错了，这与我们的try/catch语句有相同的功能。
 

//throw catch
const promise = new Promise(function(resolve, reject) {
    throw new Error('test');
});
promise.catch(function(error) {
    console.log(error);
});


//reject 
const promise = new Promise(function(resolve, reject) {
    reject(new Error('test'));
});
promise.catch(function(error) {
    console.log(error);
});

promise.all()

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

Promise.all()接收一个数组为参数，当数组的所有Promise都为resolve的状态时，Promise.all()才会成功；若有一个失败，都会被认为是失败的。举个小例子：

var p1 = Promise.resolve('a');
 var p2 = Promise.resolve('b');
 var p3 = Promise.resolve('c');
Promise.all([p1,p2,p3]).then(function(value) {
    console.log(value);//[a,b,c]
})

var p1 = Promise.resolve('a');
 var p2 = Promise.reject('b');
 var p3 = Promise.resolve('c');
Promise.all([p1,p2,p3]).then(function(value) {
    //then方法不会执行
    console.log(value);
}).catch(function*(e){
    //catch方法会执行,输出结果为2
    console.log(2);
})

promise.race()

promise.race方法同样是将多个Promise实例包装成一个新的Promise。下面代码中，只要p1,p2,p3之中有一个实例率先改变状态，p的状态就跟着改变。那个率先改变的Promise实例的返回值，就传递给p的回调函数。

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

下面是一个例子，如果指定时间内没有获得结果，就将 Promise 的状态变为reject，否则变为resolve。

const p = Promise.race([
fetch('/resource-that-may-take-a-while'),
new Promise(function (resolve, reject) {
setTimeout(() => reject(new Error('request timeout')), 5000)
})
]);
p.then(response => console.log(response));
p.catch(error => console.log(error));

上面代码中，如果 5 秒之内fetch方法无法返回结果，变量p的状态就会变为rejected，从而触发catch方法指定的回调函数。

promise.resolve()

promise.resolve方法将现有对象转为Promise对象，例如：

var jsPromise = promise.resolve($.ajax('/whatever.json'));

1. 参数是一个Promise实例
   promise.resolve将不做任何修改、原封不动地返回这个实例。
2. 参数是一个thenable对象
   thenable对象指的是具有then方法的对象，promise.resolve方法会将这个对象转为Promise对象，然后立即执行thenable对象的then方法。
3. 参数不是具有then方法的对象，或根本就不是对象
   如果参数是一个原始值，或者是一个不具有then方法的对象，则promise.resolve方法返回一个新的Promise对象，状态为resolved。
4. 不带有任何参数
   直接返回一个resolve状态的Promise对象。需要注意的是，立即resolve的Promise对象，是在本轮“事件循环”(event loop)的结束时，而不是在下一轮的“事件循环”的开始时。

promise.reject()

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

var p = promise.reject("出错了");
 =>
 var p = new Promise((resolve,reject)=>reject('出错了'));

finally()

finally方法用于指定不管Promise对象最后状态如何都会执行的操作。它接收一个普通的回调函数作为参数，该函数不管怎样都必须执行。
下面是一个例子，服务器使用Promise处理请求，然后使用finally方法关掉服务器。

server.listen(0).then(function(){
     // run test
 }).finallly(server.stop);