Promise 构造函数
Promise(excutor){}
1）executor 函数：执行器 (resolve,reject)=>{}
2）resolve 函数：内部定义成功时我们调用的函数 value =>{}
3）reject函数：内定定义失败时我们调用的函数 reason =>{}
说明: executor 会在 Promise 内部立即同步调用，异步操作在执行器中执行；
let p = new Promise((fulfill,reject)=>{
// 函数内部的代码是同步调用
console.log(1111);
});
console.log(222);
执行结果还是先“111”后“222”，说明函数体里的代码是立即执行的，同步调用；
Promise.prototype.then 方法
then(onResolved,onRejected)=>{}
1）onResolved 函数：成功的回调函数 (value)=>{}
2）onRejected 函数：失败的回调函数 (reason)=>{}
说明：指定用于得到成功 value 的成功回调和用于得到失败 reason 的失败回调返回一个新的 promise 对象；
Promise.prototype.catch 方法
1） onReject 函数：失败的回调函数 (reason)=>{}
let p = new Promise((fulfill, reject) => {
// 修改下对象状态为失败
reject('error');
});
p.catch(reason=>{
console.log(reason);
});
catch() 只能执行失败状态的函数；
Promise.resolve
方法：(value)=>{}
1）value： 成功的数据或 promise 对象；
返回一个成功或失败的 Promise 对象；
这是一个 Promise 对象本身的方法，并不是实例化对象的方法；
let p = Promise.resolve(521);
console.log(p);
结果是一个 Promise 对象，状态为 fulfilled 成功，值为 521；
注意：调用的时候并没有使用 new ；
说明：
1）如果传入的参数是非 Promise 类型的对象，则返回的结果都为成功的 promise 对象；
上例已经说明；
2）如果传的的参数是 Promise 对象，则参数的结果决定了 resolve 的结果；
let p = Promise.resolve(new Promise((fulfill,reject)=>{
fulfill('Ok');
}));
console.log(p);
受参数 Promise 对象状态的影响，参数对象返回的是 fulfilled 状态，那么 p 对象的状态即为成功；
同理，参数对象返回的是 rejected 状态，那么 p 对象的状态即为失败；
let p = Promise.resolve(new Promise((fulfill,reject)=>{
reject('Error');
}));
console.log(p);
注意：这里有个报错，原因是我们还没有对这个失败的结果做处理；加一个 catch 方法来处理失败；
let p = Promise.resolve(new Promise((fulfill,reject)=>{
reject('Error');
}));
console.log(p);
p.catch(reason=>{
console.log(reason);
});
Promise.reject
方法：(reason)=>{}
1） reason：失败的原因
说明：作用是返回状态为失败的 Promise 对象；
跟 Promise.resolve 一样，是 Promise 函数自身的方法，并不是实例对象的方法，调用的时候不用 new；
let p1 = Promise.reject(521);
let p2 = Promise.reject('nice to meet you');
let p3 = Promise.reject(new Promise((fulfill,reject)=>{
fulfill('OK');
}));
console.log(p1);
console.log(p2);
console.log(p3);
一下建三个 Promise 对象： p1,p2,p3 。而且3个都报了错；
从结果看，使用 Promise.reject 方法，传入的是 数值、字符串还是 Promise 对象，返回结果的状态都是 rejected 失败的；传入Promise对象后，结果的值还是个 Promise 对象，这点跟 Promise.resolve 不一样，那是因为失败的Promise 对象后必须要跟一个处理失败的方法才行。 如 then() 或 catch();
Promise.all
方法： (promises)=>{}
1）promises：包含 n 个 promise 的数组；
说明：返回一个新的 promise ，只有所有的 promise 都成功才成功，只要有一个失败了就直接失败；
成功的结果是每一个 Promise 对象成功结果的数组 ，失败的结果只是 失败的那个 Promise 对象失败的结果；
let p1 = new Promise((resolve,reject)=>{
resolve("Ok");
});
let p2 = Promise.resolve('Success');
let p3 = Promise.resolve('Oh Yeah');
const result = Promise.all([p1,p2,p3]);
console.log(result);
只有当前三个 Promise 对象的状态都是成功，那么返回的才是状态为成功的 Promise 对象(result)，而且成功的结果值，是这 3 个Promise对象的结果组成的数组；
但凡有一个失败的：那返回的状态就是失败，结果值就是状态为失败的值；
let p1 = new Promise((resolve,reject)=>{
resolve("Ok");
});
let p2 = Promise.reject('Error'); // 弄个失败的
let p3 = Promise.resolve('Oh Yeah');
const result = Promise.all([p1,p2,p3]);
console.log(result);
这里，p2 对象是失败的，那么不论 p3 是什么，都会返回失败状态和失败的值；报错是需要在后面接个处理失败的方法；
Promise.race
方法： (promises)=>{}
1） promise: 包含 n 个 promise 的数组；
说明：返回一个新的 Promise 对象，第一个完成的 Promise 的结果状态就是最终的结果状态；
let p1 = new Promise((resolve, reject) => {
resolve("Ok");
});
let p2 = Promise.resolve('Success');
let p3 = Promise.resolve('Oh Yeah');
const result = Promise.race([p1, p2, p3]);
console.log(result);
当前代码中，p1 先改变状态，所以结果由 p1 决定，结果即为成功，返回的值也是 p1 的值；
改一下代码，把 p1 加上异步任务，并把 p2 改为失败的 Promise 对象；
let p1 = new Promise((resolve, reject) => {
setTimeout(()=>{
resolve("Ok");
},1000);
});
let p2 = Promise.reject('Error');
let p3 = Promise.resolve('Oh Yeah');
const result = Promise.race([p1, p2, p3]);
console.log(result);
这样一来，返回的对象状态就变为 p2 的失败状态，返回值也是 p2 的值；
虽然说不上有啥用，感觉挺有用；