一、概念
Promise是异步编程的一种解决方案（解决回调地狱的问题），是一个能够获取异步操作信息的对象。Promise的内部保存着某个未来才会结束的事件（通常是一个异步操作）
二、特点
1.Promise对象的状态不受外界影响
Promise对象的状态由异步操作的结果决定当前处于pending（进行中）、fulfilled（已成功）还是rejected（已失败），任何其他操作都无法改变这个状态。
2.状态改变不可逆
一旦状态改变，就不会再变，任何时候都可以得到这个结果。promise对象的状态改变，只有两种可能：从pending变为fulfilled和从pending变为rejected。只要这两种情况发生，状态就凝固了，不会再变了，会一直保持这个结果，这时就称为 resolved（已定型）。如果改变已经发生了，你再对promise对象添加回调函数，也会立即得到这个结果。
3.缺点
（1）无法取消promise，一旦新建它就会立即执行，无法中途取消
（2）如果不设置回调函数，promise内部抛出的错误，不会反应到外部
（3）当处于pending状态时，无法得知目前进展到哪一个阶段（刚刚开始还是即将完成）
4.优点
promise对象可以将异步操作以同步操作的流程表达出来，避免了层层嵌套的回调函数。此外，promise对象提供统一的接口，使得控制异步操作更加容易。
三、基本用法
Promise对象是一个构造函数，接受一个函数为参数，这个函数的参数是resolve和reject，它们两个也是函数。
resolve函数的作用是，将promise对象的状态从“未完成”变为“成功”（即从 pending 变为 resolved），在异步操作成功时调用，并将异步操作的结果，作为参数传递出去，外部用then方法接收
reject函数的作用是，将promise对象的状态从“未完成”变为“失败”（即从 pending 变为 rejected），在异步操作失败时调用，并将异步操作报出的错误，作为参数传递出去，外部用catch方法接收
const promise = new Promise(function(resolve, reject) {
// ... some code
if (/* 异步操作成功 */){
resolve(value);
} else {
reject(error);
}
});
四、API详解
1.promise.prototype.then()
then方法是定义在原型对象promise.prototype上的，它是异步操作成功的回调函数，是resolve函数的外部接收器。参数是一个函数。
工作原理：当promise对象执行异步操作成功时，会通过resolve函数向外传递操作结果，由then方法接收后，对该结果继续执行传入then方法内部的函数。
then方法返回的是一个新的promise实例（注意，不是原来那个promise实例）。因此可以采用链式写法，即then方法后面再调用另一个then方法。
function async(a,b) {
return new Promise(function (resolve,reject) {
//异步代码
setTimeout(function () {
//加入数据格式的判断
if(a!=undefined && (typeof a) =="number"){
//如果数据格式正确 则调用resolve匹配外部的then
resolve(a+b);
}else{
//数据格式错误 调用reject 匹配外部的catch
reject(new Error("a is not a number,你瞎啊!!!"));
}
},200)
});
}
var promise=async(1,2);
promise.then(function (res) {
if(res>2){
console.log("我是3分支");
return async(res,3)
}
//如果上一个then返回了一个promise 那么可以后面继续跟着then
}).then(function (res) {
if(res>4){
console.log("我是4分支");
return async(res,4);
}
})
2.promise.prototype.catch()
catch方法的使用、原理同then方法，只是catch方法是失败的回调函数。
注意：
（1）如果没有使用catch()方法指定错误处理的回调函数，promise 对象抛出的错误不会传递到外层代码，即不会有任何反应。
（2）catch方法只能有一个，有多个无意义，后面的catch并不会执行，catch方法通常写在最后
var user=new User("niujinghui","123456");
user.checkUsername()
.then(function (res) {
return user.checkUserpwd();
})
.then(function (res) {
console.log("用户名密码都正确");
})
.catch(function (err) {
if(err) throw err;
});
3.promise.prototype.finally()
finally()方法用于指定不管 promise 对象最后状态如何，都会执行的操作。该方法是 es2018 引入标准的。
promise
.then(result => {···})
.catch(error => {···})
.finally(() => {···});
上面代码中，不管promise最后的状态，在执行完then或catch指定的回调函数以后，都会执行finally方法指定的回调函数。
finally方法源码
Promise.prototype.finally = function (callback) {
let P = this.constructor;
return this.then(
value => P.resolve(callback()).then(() => value),
reason => P.resolve(callback()).then(() => { throw reason })
);
};
4.promise.all()
promise.all()用于将多个Promise实例包装成一个新的Promise实例。接受一个数组作为参数，如果该数组的元素不是promise对象实例，则使用Promise.resolve()方法将参数转为Promise实例再处理。另外，promise.all()方法的参数可以不是数组，但必须具有 iterator 接口，且返回的每个成员都是 promise 实例。
const p = Promise.all([p1, p2, p3]);
上面代码中p的状态由p1、p2、p3决定，有以下两种情况：
（1）只有p1、p2、p3的状态都变成fulfilled，p的状态才会变成fulfilled，此时p1、p2、p3的返回值组成一个数组，传递给p的回调函数。（都成功，传返回值数组，如果没有返回值，会组成元素为undefined的数组）
（2）只要p1、p2、p3之中有一个被rejected，p的状态就变成rejected，此时第一个被reject的实例的返回值，会传递给p的回调函数。（一失败，传reject的返回值）
注意！！坑点来袭
1、如果作为参数的 promise 实例，自己定义了catch方法，那么它一旦被rejected，并不会触发promise.all()的catch方法。如果没有自己的catch方法，就会调用promise.all()的catch方法。
2、使用all()方法时，传入的promise对象如果本身定义了then和catch方法，因为这两个方法都会返回一个新的promise实例，所以调用all方法得到的新promise状态一直都是成功。解释起来有点绕，结合下面的代码看就知道了。
const p1 = new Promise((resolve,reject)=>{
let abc = 10
let a = 10;
let b = 20
if(abc > 30){
resolve(a+b)
}else{
reject(b-a)
}
}).then(function(res){
return res
}).catch(function(err){
console.log(err)
})
const p2 = new Promise((resolve,reject)=>{
let abc = 10
let a = 10;
let b = 20
if(abc > 30){
resolve(a+b+b)
}else{
reject(b-a-a)
}
}).then(function(res){
return res
}).catch(function(err){
console.log(err)
})
const p3 = new Promise((resolve,reject)=>{
let abc = 10
let a = 10;
let b = 20
if(abc > 30){
resolve(a*b)
}else{
reject(b/a)
}
}).then(function(res){
return res
}).catch(function(err){
console.log(err)
})
const p=Promise.all([p1,p2,p3])
p.then(function(){
console.log("正确")
}).catch(function(){
console.log("错误")
})
上面的代码在abc的值小于30时，就会执行reject方法，当调用promise.all()时，应该会输出错误。但是因为p1、p2、p3都有各自的then和catch方法，返回了新的promise实例，又因为这个新实例已经处于完成状态，所以变量p才会一直处于成功状态。（小炉写代码的时候还思考了好久，大坑！！！）
5.promise.race()
const p = Promise.race([p1, p2, p3]);
race方法的参数以及对参数中非promise对象的处理都和all方法一致，但是race方法返回的状态只和数组中最先改变状态的实例相同，那个最先改变的 promise 实例的返回值，就传递给p的回调函数。
注意：
（1）如果数组里面promise实例执行的速度一样，返回数组第一个promise执行的结果
（2）如果数组里面promise实例执行的速度不一样，返回最快的promise执行的结果，结果是失败就会直接匹配race的catch方法
（3）如果数组里面promise实例有成功、有失败的只要不是返回的结果，失败的就不影响
6.promise.allsettled()
promise.allsettled()方法接受一组 promise 实例作为参数，包装成一个新的 promise 实例。只有等到所有这些参数实例都返回结果，不管是fulfilled还是rejected，包装实例才会结束。该方法由 es2020 引入。
该方法返回的新的 promise 实例，一旦结束，状态总是fulfilled，不会变成rejected
const promises = [ fetch('index.html'), fetch('https://does-not-exist/') ];
const results = await Promise.allSettled(promises);
// 过滤出成功的请求
const successfulPromises = results.filter(p => p.status === 'fulfilled');
// 过滤出失败的请求，并输出原因
const errors = results
.filter(p => p.status === 'rejected')
.map(p => p.reason);
7.promise.any()
promise.any()跟promise.race()方法很像，只有一点不同，就是不会因为某个 promise 变成rejected状态而结束。如果所有的promise实例都是rejected，则返回AggregateError: All promises were rejected
经过小炉自己试验，总结规则如下：
（1）如果数组里面promise实例执行的速度不一样，执行最快的promise结果为成功则返回，为失败则按照这个规则找第二快的，依次类推。
（2）如果数组里面promise实例执行的速度一样，则返回第一个成功的promise的返回值
8.promise.resolve()
作用：将现有对象转为 Promise 对象
参数情况：
（1）参数是一个 Promise 实例
如果参数是 promise 实例，那么promise.resolve将不做任何修改、原封不动地返回这个实例。
（2）参数是一个thenable对象
thenable对象指的是具有then方法的对象，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
});
上面代码中，thenable对象的then方法执行后，对象p1的状态就变为resolved，从而立即执行最后那个then方法指定的回调函数，输出 42。
（3）参数不是具有then方法的对象，或根本就不是对象
如果参数是一个原始值，或者是一个不具有then方法的对象，则promise.resolve方法返回一个新的 promise 对象，状态为resolved。
（4）不带有任何参数
promise.resolve()方法允许调用时不带参数，直接返回一个resolved状态的 promise 对象。
9.promise.reject()
promise.reject(reason)方法也会返回一个新的 promise 实例，该实例的状态为rejected。
const p = Promise.reject('出错了');
// 等同于
const p = new Promise((resolve, reject) => reject('出错了'))
p.then(null, function (s) {
console.log(s)
});
注意：promise.reject()方法的参数，会原封不动地作为reject的理由，变成后续方法的参数。这一点与promise.resolve方法不一致。
五、总结
1.promise的作用：Promise是异步编程的一种解决方案（解决回调地狱的问题）
2.无法取消promise，一旦新建它就会立即执行，无法中途取消
3.如果不设置回调函数，promise内部抛出的错误，不会反应到外部
4.当处于pending状态时，无法得知目前进展到哪一个阶段（刚刚开始还是即将完成）
5.promise.then()成功的回调函数，返回的是一个新的promise实例，可以使用链式编程，参数来自resolve函数
6.promise。catch()失败的回调函数，只写一个，多写无意义，通常写在最后，参数来自reject函数
7.promise.all()监听所有的promise实例状态，全成功则成功，一失败则失败
8.promise.allsettled()监听所有的promise实例状态,等到所有这些参数实例都返回结果才结束，结束时状态总是fulfilled，不会变成rejected
9.promise.any()不会因为某个 promise 变成rejected状态而结束。如果所有的promise实例都是rejected，则返回AggregateError: All promises were rejected
10.promise.race()返回的状态只和数组中最先改变状态的实例相同，那个最先改变的 promise 实例的返回值，就传递给p的回调函数。
11.promise.finally()不管 promise 对象最后状态如何，都会执行的操作
12.promise.resolve()和promise.reject()都返回一个promise实例，但是promise.reject()方法的参数，会原封不动地作为reject的理由，变成后续方法的参数