基本概念
Promise本质是用于承载异步操作的容器，使得异步操作能够以类似同步的面貌出现，所以then里面内容执行时机不要和其他同步代码做混淆。。
Promise（承诺）类比于将来一定会发生的事情，它本身有三个状态pending,resolved,rejected,当将来它的状态改变后，会调用注册的方法。
// Promise new出来之后就会立即执行，所以一般被包装在函数中，更易于理解调用时机。
const getJSON = function(url) {
const promise = new Promise(function(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 promise;
};
异步函数内部，需要在合适的时机调用resolve或者reject，或者throw err（臣妾办不到异步正常完事儿呀~），以通知Promise改变自身状态。
then & catch
then接收传递resolve或者reject的参数，执行状态变化后的操作。
catch是then的子集，一般来说由then处理resolve，catch处理reject。
catch和then都会返回一个新的Promise对象，then将函数的返回值作为参数，新的promise的resolve会调用，实现链式调用。
post(...).then(res=>res.json()).then(json=>console.log(json))
应该与以下两个函数有关：
Promise.resolve();Promise.reject();
then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
Promise.prototype.finally()
finally本质上是then方法的特例。
执行一个无参参数，不做其他任何修改。
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 })
);
};
finally方法用于指定不管 Promise 对象最后状态如何，都会执行的操作。该方法是 ES2018 引入标准的。
finally方法的回调函数不接受任何参数，这意味着没有办法知道，前面的 Promise 状态到底是fulfilled还是rejected。这表明，finally方法里面的操作，应该是与状态无关的，不依赖于 Promise 的执行结果。
Promise.all(),Promise.race()
异步的容器，自然可以放多个异步操作，从名字可以自解释。
接收一个promise对象的数组，如果不是promise对象，会对参数进行promise化。
Promise.resolve()，Promise.reject()
对于基本类型、函数、Promise的promise化。
resolve<T>(value: T | PromiseLike<T>): Promise<T>;
reject<T = never>(reason?: any): Promise<T>;
js宽泛的、弱类型检查的语言，往往不需要其他语言重载等操作，但是使用起来安全性要尤其注意。
Promise.try()
际开发中，经常遇到一种情况：不知道或者不想区分，函数f是同步函数还是异步操作，但是想用 Promise 来处理它。因为这样就可以不管f是否包含异步操作，都用then方法指定下一步流程，用catch方法处理f抛出的错误。一般就会采用下面的写法。
Promise.resolve().then(f)
上面的写法有一个缺点，就是如果f是同步函数，那么它会在本轮事件循环的末尾执行。
那么有没有一种方法，让同步函数同步执行，异步函数异步执行，并且让它们具有统一的 API 呢？
// 不确定同步还是异步函数f，用async或者Promise包装，以同步调用方式使用
const f = (msg) => {
console.log(msg)
return msg
}
//Promise
(
() => new Promise(
resolve => resolve(f('In function F!'))
)
)().then(msg=>console.log(msg)).catch(err=>console.log(err));
//async
(async () => f('hello in asyn'))()
.then(msg => console.log(msg))
.catch(err => console.log(err))
console.log('In code!')
