ECMAscript 6 原生提供了 Promise 对象。
Promise 对象用来传递异步操作的消息，代表一个异步操作的最终完成或者失败。
特点
1、对象的状态不受外界影响。Promise 对象代表一个异步操作，有三种状态：
pending: 初始状态，不是成功或失败状态。
fulfilled: 意味着操作成功完成。
rejected: 意味着操作失败。
只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。这也是 Promise 这个名字的由来，它的英语意思就是「承诺」，表示其他手段无法改变。
2、一旦状态改变，就不会再变，任何时候都可以得到这个结果。Promise 对象的状态改变，只有两种可能：从 Pending 变为 Resolved 和从 Pending 变为 Rejected。只要这两种情况发生，状态就凝固了，不会再变了，会一直保持这个结果。就算改变已经发生了，你再对 Promise 对象添加回调函数，也会立即得到这个结果。这与事件（Event）完全不同，事件的特点是，如果你错过了它，再去监听，是得不到结果的。
优点:
有了 Promise 对象，就可以将异步操作以同步操作的流程表达出来，避免了层层嵌套的回调函数。此外，Promise 对象提供统一的接口，使得控制异步操作更加容易。
缺点:
1.无法取消 Promise，一旦新建它就会立即执行，无法中途取消。2.如果不设置回调函数，Promise 内部抛出的错误，不会反应到外部。3.当处于 Pending 状态时，无法得知目前进展到哪一个阶段（刚刚开始还是即将完成）。
在过去，要想做多重的异步操作，会导致经典的回调地狱。现在，我们可以把回调绑定到返回的 Promise 上，形成一个 Promise 链：
var promise = new Promise(function(resolve, reject) {
// 异步处理
// 处理结束后、调用resolve 或 reject
});
//对于已经实例化过的 promise 对象可以调用 promise.then() 方法
promise().then(function(result){
return doSomethingElse(result);
}).then(function(newResult){
return doThirdThing(newResult);
}).then(function(finalResult) {
console.log('Got the final result: ' + finalResult);
})
.catch(failureCallback);
//也可以用[箭头函数表示
promise().then(result => doSomethingElse(result))
.then(newResult => doThirdThing(newResult))
.then(finalResult => {
console.log('Got the final result: ' + finalResult);
})
.catch(failureCallback);
下面是用 Promise 对象实现的 Ajax 操作的例子
var ajax = function (token) {
return new Promise(function(resolve,reject){
var xhr = window.XMLHttpRequest ? new XMLHttpRequest : new ActiveXObject('Microsoft.XMLHTTP');
var url = '';
var obj = {'accessToken':token}
var params = "request="+JSON.stringify(obj);
xhr.onreadystatechange = function() {
if (xhr.readyState == 4) {
if (xhr.status >= 200 && xhr.status < 300) {
var res = JSON.parse(xhr.responseText);
if (res.code == 0) {
resolve(res.response.userId)
}else {
reject(res.msg)
}
} else {
alert('error')
}
}
}
xhr.open('POST', url, true);
xhr.setRequestHeader('Content-type', "application/x-www-form-urlencoded");
xhr.send(params);
})
},
ajax(token).then(function(res){
sessionStorage.setItem('userid',res);
}).catch(function(res){
console.log(res)
})
Promise.all方法，Promise.race方法，Promise.any方法
Promise.all和Promise.race是并行运行异步操作的两个组合式工具。
Promise.all()
Promise.all 方法接收一个promise的iterable类型（注：Array，Map，Set都属于ES6的iterable类型）的输入，且返回的每个成员都是 Promise 实例，那个输入的所有promise的resolve回调的结果是一个数组。
Promise 的状态由promise1、promise2、promise3 决定，分成两种情况。
（1）只有promise1、promise2、promise3的状态都变成fulfilled，Promise 的状态才会变成fulfilled，此时promise1、promise2、promise3的返回值组成一个数组，传递给p的回调函数。
（2）只要promise1、promise2、promise3之中有一个被rejected，Promise 的状态就变成rejected，Promise.all 异步地将失败的那个结果给失败状态的回调函数，而不管其它 promise 是否完成
const promise1 = Promise.resolve(3);
const promise2 = 42;
const promise3 = new Promise((resolve, reject) => {
setTimeout(resolve, 100, 'foo');
});
Promise.all([promise1, promise2, promise3]).then((values) => {
console.log(values);
});
var p3 = Promise.all([1,2,3, Promise.reject(555)]);
//log
// Promise { <state>: "rejected", <reason>: 555 }
Promise.all 当且仅当传入的可迭代对象为空时为同步：
var p = Promise.all([]); // will be immediately resolved
var p2 = Promise.all([1337, "hi"]); // non-promise values will be ignored, but the evaluation will be done asynchronously
console.log(p);
console.log(p2)
setTimeout(function(){
console.log('the stack is now empty');
console.log(p2);
});
// logs
// Promise { <state>: "fulfilled", <value>: Array[0] }
// Promise { <state>: "pending" }
// the stack is now empty
// Promise { <state>: "fulfilled", <value>: Array[2] }
Promise.race()
Promise.race(iterable) 方法返回一个 promise，一旦迭代器中的某个promise解决或拒绝，返回的 promise就会解决或拒绝。
race 函数返回一个 Promise，它将与第一个传递的 promise 相同的完成方式被完成。它可以是完成（ resolves），也可以是失败（rejects），这要取决于第一个完成的方式是两个中的哪个。
如果传的迭代是空的，则返回的 promise 将永远等待。
如果迭代包含一个或多个非承诺值和/或已解决/拒绝的承诺，则 Promise.race 将解析为迭代中找到的第一个值。
const promise1 = new Promise((resolve, reject) => {
setTimeout(resolve, 500, 'one');
});
const promise2 = new Promise((resolve, reject) => {
setTimeout(resolve, 100, 'two');
});
Promise.race([promise1, promise2]).then((value) => {
console.log(value);
// Both resolve, but promise2 is faster
});
// expected output: "two"
Promise.any()
E12新增的Promise的方法
接收一个Promise数组，数组中如有非Promise项，则此项当做成功
如果有一个Promise成功，则返回这个成功结果
如果所有Promise都失败，则报错
var promise1 = new Promise((resolve, reject) => {
setTimeout(resolve, 100, 'one');
});
var promise2 = new Promise((resolve, reject) => {
setTimeout(reject, 100, 'two');
});
var promise3 = new Promise((resolve, reject) => {
setTimeout(resolve, 50, 'three');
});
var promise4 = new Promise((resolve, reject) => {
setTimeout(reject, 50, 'four');
});
// 当有成功的时候，返回最快那个成功
Promise.any([promise1,promise2,promise3]).then((value) => {
console.log(value)//three
})
//当全都失败时
Promise.any([promise2,promise4]).then((value) => {
console.log(value)
},err =>{
console.log(err)//AggregateError: All promises were rejected
})
