是什么
Promise是异步编程的一种解决方案。
深入剖析Promise原理讲解 && 实现一个Promise对象 (遵循Promise/A+规范)
30分钟，让你彻底明白Promise原理
特点
1、对象的状态不受外界影响。
Promise对象代表一个异步操作，有3中状态：Pending(进行中)、Fulfilled(已成功)、Rejected(已失败)。只有异步操作的结果可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。
2、一旦状态改变就不会再变，任何时候都可以得到这个结果。Prmise对象的状态改变只有两种可能：从Pending到Fulfilled，从Pending到Rejected。只要这两种情况发生，状态就凝固了，不会再变，而是一直保持这个结果，此时为Reaolved(已定型）
优缺点
优点：
1、将异步操作以同步操作的流程表达出来，避免层层嵌套回调函数
2、接口统一，控制异步操作更加容易
缺点
1、无法取消Promise，一旦创建就会立即执行。
2、如果不设置回调函数，错误无法反应到外部
3、当处于Pending状态时，无法得知进展到哪一个阶段（刚开始还是即将完成）
基本用法
Promise对象是一个构造函数，用来生成Promise实例。
let promise=new Promise((resolve,reject)=>{
if(/*异步操作成功*/){
resolve(val)
}else{
reject(err)
}
})
promise.then(
val=>console.log(val,'异步操作成功调用该函数'),
err=>console.log(err,'异步操作失败')
)
Promise构造函数的
参数是一个函数，该函数接受两个参数，也均为函数，分别是resolve和reject。resolve的作用是将Promise对象的状态从未完成变为成功，在异步操作成功时调用，并将异步操作的结果作为参数传递出去，而reject则是用于失败的情况。当Promise实例生成后，可以用then方法分别指定Resolve状态和Rejected状态的回调函数。.then对象的第一个函数参数就是处理resolve的情况，第二个函数参数是处理reject的情况
Promise新建后会立即执行
let promise = new Promise(function(resolve, reject) {
console.log('Promise');
resolve();
});
promise.then(function() {
console.log('resolved.');
});
console.log('Hi!');
// Promise
// Hi!
// resolved
同步任务栈为空时，才去异步任务队列中取出回调函数去执行
then方法的作用是为Promise实例添加状态改变时的回调函数。返回的仍然是一个Promise对象，但是它是新的对象，不再是原来的那个实例。因此可以采用链式。非常重要的一点：采用链式的then可以指定一组按次序调用的回调函数，后面的then等前面的then（也就是新的Promise对象状态变化后在执行，如果前面的then状态是resolve那么就执行第一个参数函数，否则就执行第二个参数函数）,promise.then()属于异步任务的微任务，当执行到微任务时，他会全部按顺序执行完**
then链式操作
const timeout = ms => new Promise((resolve, reject) => {
setTimeout(() => {
resolve();
}, ms);
});
const ajax1 = () => timeout(2000).then(() => {
console.log('1');
return 1;
});
const ajax2 = () => timeout(1000).then(() => {
console.log('2');
return 2;
});
const ajax3 = () => timeout(2000).then(() => {
console.log('3');
return 3;
});
var sequence = Promise.resolve();//返回一个状态是resolveed的promise对象
var data=[]
//链式操作，按顺序来
sequence.then(ajax1).then(val=>{//如果ajax1的状态为resolved那么其返回的值就入栈，其他同理
data.push(val)
}).then(ajax2).then(val=>{
data.push(val)
}).then(ajax3).then(val=>{
data.push(val)
console.log(data)
})
//1
//2
//3
//[1,2,3]
注意事项
1、resolve(p)，p还是个promise对象时，那么最终状态有p来决定。
const p1 = new Promise(function (resolve, reject) {
setTimeout(() => reject(new Error('fail')), 3000)
})
const p2 = new Promise(function (resolve, reject) {
setTimeout(() => resolve(p1), 1000)
})
p2 .then(result => console.log(result))
.catch(error => console.log(error))
// Error: fail
上面代码中，
p1是一个Promise，3 秒之后变为rejected。p2的状态在 1 秒之后改变，resolve方法返回的是p1。由于p2返回的是另一个Promise，导致p2自己的状态无效了，由p1的状态决定p2的状态。所以，后面的then语句都变成针对后者（p1）。又过了 2 秒,p1变为rejected，导致触发catch方法指定的回调函数。
2、调用resolve或reject不会终结Promise的参数函数执行
new Promise((resolve, reject) => {
resolve(1);
console.log(2);
}).then(r => {
console.log(r);
});
// 2
// 1
一般来说，调用resolve或reject以后，Promise 的使命就完成了，后继操作应该放到then方法里面，而不应该直接写在resolve或reject的后面。所以，最好在它们前面加上return语句，这样就不会有意外。
new Promise((resolve, reject) => {
return resolve(1);
// 后面的语句不会执行
console.log(2);
})
3、尽量使用catch来捕获错误，而非reject第二个参数函数
Promise 对象的错误具有“冒泡”性质，会一直向后传递，直到被捕获为止。也就是说，错误总是会被下一个catch语句捕获。
getJSON('/post/1.json').then(function(post) {
return getJSON(post.commentURL);
}).then(function(comments) {
// some code
}).catch(function(error) {
// 处理前面三个Promise产生的错误
});
// bad
promise
.then(function(data) {
// success
}, function(err) {
// error
});
// good
promise
.then(function(data) { //cb
// success
})
.catch(function(err) {
// error
});
与传统try/catch的不同：如果没有使用
catch方法指定错误处理的回调函数，Promise对象抛出的错误不会传递到外层代码，即不会有任何反应。
4、如果 Promise 状态已经变成resolved，再抛出错误是无效的。
const promise = new Promise(function(resolve, reject) {
resolve('ok');
throw new Error('test');
});
promise
.then(function(value) { console.log(value) })
.catch(function(error) { console.log(error) });
// ok
Promise.resolve(参数)
（1）参数是一个 Promise 实例
如果参数是 Promise 实例，那么Promise.resolve将不做任何修改、原封不动地返回这个实例。
（2）参数是一个thenable对象
Promise.resolve方法会将这个对象转为 Promise 对象，然后就立即执行thenable对象的then方法。
let thenable = {
then: function(resolve, reject) {
resolve(42);
}
};
let p1 = Promise.resolve(thenable);
p1.then(function(value) {
console.log(value); // 42
});
（3）参数不是具有then方法的对象，或根本就不是对象
如果参数是一个原始值，或者是一个不具有then方法的对象，则Promise.resolve方法返回一个新的 Promise 对象，状态为resolved。
const p = Promise.resolve('Hello');
p.then(function (s){
console.log(s)
});
// Hello
（4）不带有任何参数
Promise.resolve方法允许调用时不带参数，直接返回一个resolved状态的 Promise 对象。
done()和finally()的区别
done()处于回调链的尾端，保证抛出任何肯能的错误，向全局抛出。
finally方法用于指定不管 Promise 对象最后状态如何，都会执行的操作。
promise
.then(result => {···})
.catch(error => {···})
.finally(() => {···});
上面代码中，不管promise最后的状态，在执行完then或catch指定的回调函数以后，都会执行finally方法指定的回调函数。可以使用finally关掉服务器。
Promise.all()
Promise.all()方法，用于将多个Promise实例包装成一个新的Promise实例。
const p = Promise.all([p1, p2, p3]);
上面代码中，Promise.all方法接受一个数组作为参数，p1、p2、p3都是 Promise 实例，如果不是，就会先调用Promise.resolve方法，将参数转为 Promise 实例，再进一步处理。
p的状态由p1、p2、p3决定，分成两种情况。
（1）只有p1、p2、p3的状态都变成fulfilled，p的状态才会变成fulfilled，此时p1、p2、p3的返回值组成一个数组，传递给p的回调函数。
（2）只要p1、p2、p3之中有一个被rejected，p的状态就变成rejected，此时第一个被reject的实例的返回值，会传递给p的回调函数。
var task = []
for (var i = 0; i < 5; i++) {
(function (j) {
task.push(new Promise((resolve) => {
setTimeout(function () {
console.log(new Date, j);
resolve()
}, 1000)
}
)); // 这里修改 0~4 的定时器时间
})(i)
}
Promise.all(task).then(() => {
setTimeout(() => {
console.log(new Date, i)
}, 1000)
})
//输出0,1,2,3,4,->5
var task = []
for (var i = 0; i < 5; i++) {
(function (j) {
task.push(new Promise((resolve) => {
setTimeout(function () {
console.log(new Date, j);
resolve()
}, 1000*j)
}
)); // 这里修改 0~4 的定时器时间
})(i)
}
Promise.all(task).then(() => {
setTimeout(() => {
console.log(new Date, i)
}, 1000)
})
//输出0->1->2->3->4->5
阿里笔试题目 -- 实现mergePromise函数
//实现mergePromise函数，把传进去的数组顺序先后执行，
//并且把返回的数据先后放到数组data中
const timeout = ms => new Promise((resolve, reject) => {
setTimeout(() => {
resolve();
}, ms);
});
const ajax1 = () => timeout(2000).then(() => {
console.log('1');
return 1;
});
const ajax2 = () => timeout(1000).then(() => {
console.log('2');
return 2;
});
const ajax3 = () => timeout(2000).then(() => {
console.log('3');
return 3;
});
const mergePromise = ajaxArray => {
// 在这里实现你的代码
var data = [];
var sequence = Promise.resolve();
ajaxArray.forEach(function(item){//使用链式then，每次的then都赋给sequence，从而达到连接的作用。
sequence = sequence.then(item).then(function(res){
data.push(res);
return data;
});
})
return sequence;
};
mergePromise([ajax1, ajax2, ajax3]).then(data => {
console.log('done');
console.log(data); // data 为 [1, 2, 3]
});
// 分别输出
// 1
// 2
// 3
// done
// [1, 2, 3]
promise.all(promisearr),promisearr按数组中的元素顺序执行
const timeout = ms => new Promise((resolve, reject) => {
setTimeout(() => {
resolve();
}, ms);
});
const ajax1 = () => timeout(1000).then(() => {
console.log('1');
return 1;
});
const ajax2 = () => timeout(1000).then(() => {
console.log('2');
return 2;
});
const ajax3 = () => timeout(1000).then(() => {
console.log('3');
return 3;
});
Promise.all([ajax1(),ajax2(),ajax3()]).then(result=>console.log(result))
1
2
3
[ 1, 2, 3 ]
补充
promise里面的then函数仅仅是注册了后续需要执行的代码，真正的执行是在resolve方法里面执行的。有点类似观察者模式。
下面一段代码，表示了从上到下执行代码，先输出0，resolve和reject有时间延迟是异步，然后执行第一个个p.then及其链式连缀，由于then方法仅注册，也就是把resolve需要执行的代码收集起来（第一个p.then的链式中的第二个then是下一轮的事件循环），由于第一个链中的第3个then接受的参数是直接执行函数（console.log是函数），因此直接执行。
var p=new Promise((resolve,reject)=>{
console.log(0)
resolve(2)
reject(3)
})
p.then(val=>{
console.log(val)
return 1;
}).then(val=>console.log(val)).then(console.log(9))
p.then(val=>{
console.log(val)
return 4
}).then(val=>console.log(val))
p.then(val=>console.log(val)).then(console.log(5))
0
9
5
2
2
2
1
4