ES6-Promise 对象
1.Promise 的含义
Promise是异步编程的一种解决方案，比传统的解决方案- -回调函数和事件- - 更合理和更强大。它由社区最早提出和实现，ES6将其写进入了语言标准，统一了用法，原生提供了Promise对象。
所谓Promise，简单说就是一个容器，里面保存着某个未来才会结束的时间（通常是一个异步操作）的结果。从语法上说，Promise是一个对象，从它可以获取异步操作的消息。Promise提共统一的API，各种异步操作都可以用同样的方法进行处理。
Promise对象有以下各个特点。
（1） 对象的状态不受外界的影响。Promise对象代表一个异步操作，有三种状态：pending（进行中）、fulfilled（已成功）和rejected（已失败）。只有异步操作的结果，可以决定当前是哪一种状态，热和其他操作都无法改变这个状态。这也是Promise这个名字的由来，它的英语意思是“承诺”，表示其他手段无法改变。
（2）一旦状态改变，就不会在改变，任何时候都可以得到这个结果。Promise对象的状态改变，只有两种可能：从pending变为fulfilled和从pending变为rejected.只要这两种情况发生，状态就凝固了，不会再变了，会一直保持这个结果，这时候称为resolved(已定型)。如果改变已经发生了，你再对Promise对象添加回调函数，也会立即得到这个结果。这与事件（Event）完全不同，事件的特点是，乳沟你错过了它，再去监听，是得不到结果的。
Promise也有一些缺点。首先，无法取消Promise，一旦新建它就会立即执行，无法中途取消。其次，如果不设置回调函数，Promise内部抛出的错误，不会反应发哦外部。第三，当初与pending状态时，无法得到目前进展到哪一个阶段。
如果某些事件不断地地反复发生，一般来说，使用Stream模式是比部署Promise更好的选择
2.基本用法
ES6规定，Promise对象是一个构造函数，用来生成Promise实例。
下面diamante创造了一个Promise实例
const promise = new Promise(function(resolve,reject){
if(/*异步操作成功*/){
resolve(value);
} else {
reject(error);
}
});
Promise构造函数接受一个函数作为参数，该函数的两个参数分别是resolve和reject。它们是两个函数，有javascript引擎提供，不用自己部署。
resolve函数的作用是，将Promise对象的状态从“未完成”变为“成功”（即从 pending 变为 resolved），在异步操作成功时调用，并将异步操作的结果，作为参数传递出去；reject函数的作用是，将Promise对象的状态从“未完成”变为“失败”（即从 pending 变为 rejected），在异步操作失败时调用，并将异步操作报出的错误，作为参数传递出去。
Promise实例生成以后，可以用then方法分别指定resolved状态和rejected状态的回调函数。
promise.then(function(value) {
// success
}, function(error) {
// failure
});
then方法可以接受两个回调函数作为参数。第一个回调函数是Promise对象的状态变为resolved时调用，第二个回调函数是Promise对象的状态变为rejected时调用。其中，第二个函数是可选的，不一定要提供。这两个函数都接受Promise对象传出的值作为参数。
function timeout(ms) {
return new Promise((resolve,reject) => {
setTimeout(resolve,ms,'done');
});
}
timeout(100).then((value) =>{
console.log(value);
});
上面代码中，timeout方法返回一个Promise实例，表示一段时间以后才会发生的结果。过了指定的时间以后，Promise实例的状态变为resolved，就会触发then方法绑定的回调函数。
Promise新建后就会立即执行。
let promise = new Promise(function(resolve, reject) {
console.log('Promise');
resolve();
});
promise.then(function() {
console.log('resolved.');
});
console.log('Hi!');
// Promise
// Hi!
// resolved
上面代码中，Promise 新建后立即执行，所以首先输出的是Promise。然后，then方法指定的回调函数，将在当前脚本所有同步任务执行完才会执行，所以resolved最后输出。
下面是异步加载图片的例子。
function loadImageAsync(url) {
return new Promise(function(resolve,reject){
const image = new Image();
image.onload = function() {
resolve(image);
};
image.onerror = function() {
reject(new Error('Could not load image at' + url));
};
image.src = url;
})；
}
上面代码中，使用Promise包装了一个图片加载的异步操作。如果加载成功，就调用resolve方法，否则就调用reject方法。
下面是一个用Promise对象实现的Ajax操作的例子。
const getJSON = function(url) {
const promise = new Promise(funciton(resolve,reject){
const handler = function() {
if (this.readyState !== 4) {
return;
}
if (this.status === 200) {
resolve(this.response);
} else {
reject(new Error(this.statusText));
}
};
const client = new XMLHttpRequest();
client.open("GET", url);
client.onreadystatechange = handler;
client.responseType = "json";
client.setRequestHeader("Accept", "application/json");
client.send();
});
return promis;
};
getJSON("/posts.json").then(function(json) {
console.log('Contents:' + json);
},function(error){
console.log('出错了',error)
})
3. Promise.prototype.then()
Promise实例具有then方法，也就是说，then方法是定义在原型对象Promise.prototype上的。它的作用是为Promise实例添加状态改变时的回调函数。
前面说过，then方法的第一个参数是resolved状态的回调函数，第二个参数（可选）是rejected状态的回调函数。
then方法返回的是一个新的Promise实例（注意，不是原来那个Promise实例）。因此可以采用链式写法，即then方法后面再调用另一个then方法。
getJSON("/post.json").then(function(json){
return json.post;
}).then(function(post){
//...
})
上面代码使员工then方法，以此指定了两个回调函数。第一个回调函数完成以后，会将返回结果作为参数，传入第二个回调函数。
采用链式的then,可以指定一组按照次序调用函数。这时，前一个回调函数，有可能返回的还是一个Promise对象（即有异步操作），这时后一个回调函数，就会等待该Promise对象的状态反生变化，才会被调用。
getJSON("/post/1.json").then(function(post) {
return getJSON(post.commentURL);
}).then(function funcA(comments) {
console.log("resolved: ", comments);
}, function funcB(err){
console.log("rejected: ", err);
});
上面代码中，第一个then方法指定的回调函数，返回的是另一个Promise对象。这时，第二个then方法指定的回调函数，就会等待这个新的Promise对象状态发生变化。如果变为resolved，就调用funcA，如果状态变为rejected，就调用funcB。
如果采用箭头函数，上面的代码可以简写的更加简洁
getJSON("/post/1.json").then(
post => getJSON(post.commentURL);
).then(
comments => console.log("resolved: ", comments),
err => console.log("rejected: ", err)
);
4.自我理解关于ES6
Promise——承诺
异步：操作之间没有关系，各自完成各自的，可以同时进行多个操作；
同步：操作之间是相关的，同时只能完成一个操作，必须等前一步完成，才能进行下一步
异步：代码复杂，操作困难,提高性能
同步：代码简单
Promise——消除异步操作
*用同步一样的方式，来消除异步操作
Promise.all
Promise.race 竞速
Promise.race([
$.ajax({url:"http:www.baidu.com"}),
$.ajax({url:"http:www.baidu.com"}),
$.ajax({url:"http:www.baidu.com"}),
$.ajax({url:"http:www.baidu.com"})
]);
eg:
let p = new Promise(function(resolve,reject){
//异步执行
//resolve——成功了
//reject——失败了
});
Promise.all([
p1,p2
]).then(function(arr){
alert("全部都成功了");
let [res1,res2] = arr;
console.log(res1);
console.log(res2);
},function(){
alert("至少有一个成功了");
})
注意：ajax不能再file文件路径下支持
jquery自己的Promise
有了Promise之后的异步：
Promise.all([$.ajax(),$.ajax()]).then(results=>{
//对了
},err=>{
//错了
})；
eg:
Promise.all([
$.ajax({url:"../js/testJson.json",dataType:"json"}),
$.ajax({url:"../js/testJson2.json",dataType:"json"}),
]).then(function(results){
let [res1,res2] = results;
console.log(res1);
console.log(res2);
},function(err){
console.log(err)
});
自己封装Promise自己调用
Promise.all([
createPromise("../js/testJson2.json"),
createPromise("../js/testJson.json")
]).then(function(arr){
alert("全部都成功了");
let [res1,res2] = arr;
console.log(res1);
console.log(res2);
},function(){
alert("至少有一个成功了");
})
function createPromise(url){
return new Promise(function(resolve,reject){
$.ajax({
url:url,
dataType:'json',
success(arr){
resolve(arr);
},
err(err){
reject(err);
}
})
});
}
原文：阮一峰 ES6
