Javascript(笔记52) - promise - 2 API和方法

本套笔记，是基于尚硅谷的课程整理；

​​Javascript(笔记51) - promise - 1 介绍与基本使用 ​​

​​Javascript(笔记52) - promise - 2 API和方法​​

​​Javascript(笔记53) - promise - 3 几个关键问题​​

​​Javascript(笔记54) - promise - 4 async函数、await表达式、结合示例​​

补充：

​​Javascript(笔记38) - ES6特性 - Promise​​

​​Javascript(笔记45) - ES8特性 - async 和 await​​

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 的值；

虽然说不上有啥用，感觉挺有用；