Promise

三种状态

  1. pending 初始状态
  2. fulfilled 胜利状态
  3. rejected 回绝状态

初始状态

let p = new Promise(() => {})console.log(p);

胜利状态

let p = new Promise((resolve) => {    resolve()})console.log(p);

回绝状态

let p = new Promise((resolve, reject) => {    reject()})console.log(p);

繁多状态与状态直达

繁多状态：Promise的状态变为fulfilled或resolved不会再扭转

let p = new Promise((resolve, reject) => {    resolve()    reject()})console.log(p);

状态直达：resolve()接管一个Promise时会依照接管的状态传递

let rej = new Promise((resolve, reject) => {    reject()})let p = new Promise((resolve, reject) => {    resolve(rej)})console.log(rej);console.log(p);

办法

  1. then
  2. catch
  3. finally
  4. done
  5. resolve
  6. reject
  7. all
  8. allSettled
  9. race
  10. any
  11. try

1.then(callback1,callback2)

接管resolve或reject的返回值，依据不同状态调用回调函数
then返回的也是Promise，解决后fulfilled，报错为rejected

let p = new Promise((resolve, reject) => {    reject("回绝")})let p1 = p.then(null, res => {    console.log(res);})console.log(p1);

  • then返回一个Promise能够持续解决
new Promise((resolve, reject) => {    reject("回绝")}).then(null, err => {    console.log(err);    return err}).then(err => {    console.log(err);})//回绝//回绝

2.catch

等价于 .then(null,rejection) 用于指定产生谬误时的回调函数

new Promise((resolve, reject) => {    try {        throw new Error('谬误');    }    catch (e) {        reject(e)    }//等价于 reject(new Error("谬误"))}).then(val => {    console.log(val);}).catch(res => {    console.log(res);})

  • catch捕捉try中抛出的谬误，而后由reject扭转状态并传递
  • 谬误具备"冒泡性质"，会向下传递，直到被catch捕捉
  • 反对then解决resolve,catch解决reject，catch能够去捕捉then中的谬误，相似于try/catch的写法
  • resolve后再抛出谬误不会被捕捉，也不会传递到外层代码
new Promise((resolve, reject) => {    resolve("承受")    throw new Error('谬误');}).then(val => {    console.log(val); //承受}).catch(res => {    console.log(res);})

3.finally

无论Promise对象最初状态是fulfilled还是rejected，都会执行其中的回调函数
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})    )}
new Promise((resolve, reject) => {    reject("谬误")}).finally(() => {    console.log(1); //1}).catch(res => {    console.log(res);//谬误})
  • 能够看出finally执行一个一般的回调函数，状态会向下传递

4.done

最初的谬误无奈捕捉，能够用done抛出一个全局谬误
done的实现

Promise.prototype.done = function (onFulfilled,onRejected) {    this.then(onFulfilled,onRejected)    .catch(function(reason){        setTimeout(()=>{throw reason},0)    })}
new Promise((resolve, reject) => {    reject(0)}).done(val => {    console.log(val);}, res => {    console.log(res);})
  • done也能够像then一样应用

5.Promise.resolve() 与 Promise.reject()

将一个对象转为Promise对象
以Promise.resolve(参数)为例

Promise.resolve("foo")//等价于new Promise(resolve => resolve("foo"))
  • 参数为Promise的实例

  • Promise.resolve将不做任何批改

    let p = new Promise((resolve, reject) => {  reject("谬误")})let p1 = Promise.resolve(p)console.log(p1);

  • 参数是一个thenable对象，有then办法的对象
  • Promise.resolve()会将这个对象转成Promise对象

  • 而后立刻执行thenable中的then办法

    let thenable = {  then: function (resolve, reject) {      resolve("承受")  }}Promise.resolve(thenable)  .then(val => {      console.log(val);//承受  })
  • 参数没有then办法或不是对象

  • Promise.resolve()返回一个新的Promise对象，状态为fulfilled

    let obj = {  a: 0}Promise.resolve(obj)  .then(val => {      console.log(val.a);//a  })
  • 不带任何参数

  • 间接返回一个fulfilled状态的Promise对象

    Promise.resolve()  .then(() => {      console.log("承受状态");//承受转态  })
    Promise.reject()也会返回一个新的Promise实例，状态为rejected
    与Promise.resolve()不同的是，Promise.reject()的参数会一成不变的传递

6.Promise.all()与Promise.allSettled()

  • Promise.all能够将多个Promise实例包装成一个新的Promise实例
  • 如果不是则会调用Promise.resolve办法，转为Promise实例
  • 参数为iterable类型

  • Promise.all返回的Promise的状态取决于参数的状态，全副fulfilled为fulfilled，有一个rejected返回第一个rejected

    let p1 = Promise.resolve("胜利")let p2 = "foo"let p3 = Promise.reject("失败1")let p4 = Promise.reject("失败2")  .catch(res => {      console.log("本人的" + res);//本人的失败2      return res  })Promise.all([p1, p2, p4])  .then(val => {      console.log(val);//["胜利","foo","失败2"]  })Promise.all([p2, p4, p3])  .then(val => {      console.log(val);  })  .catch(res => {      console.log("all的" + res);//all的失败1  })
  • 参数有本人的catch时，状态为fulfilled
  • 参数中有一个rejected则会调用all上的catch
  • Promise.allSettled会返回所有参数的状态与返回值
let p1 = Promise.resolve("胜利")let p2 = "foo"let p3 = Promise.reject("失败1")let p4 = Promise.reject("失败2")    .catch(res => {        console.log("本人的" + res);        return res    })Promise.allSettled([p1, p2, p4])    .then(val => {        console.log(val);    })Promise.allSettled([p2, p4, p3])    .then(val => {        console.log(val);    })

7.Promise.race()

  • 相较于Promise.all Promise.race会返回一个fulfilled或rejected的参数
  • Promise.race返回的Promise的状态由跑的最快的Promise决定的
let p1 = new Promise((resolve, reject) => {    setTimeout(resolve, 1000, "p1承受")})let p2 = new Promise((resolve, reject) => {    setTimeout(reject, 1500, "p2回绝")})Promise.race([p1, p2])    .then(val => {        console.log(val);//p1承受    })    .catch(res => {        console.log(res);    })

8.Promise.any()

  • Promise.any正好与Promise.all相同，有一个fulfilled状态就为fulfilled

    let p1 = new Promise((resolve, reject) => {  setTimeout(resolve, 2000, "p1承受")})let p2 = new Promise((resolve, reject) => {  setTimeout(reject, 1500, "p2回绝")})let p3 = new Promise((resolve, reject) => {  setTimeout(resolve, 1000, "p3承受")})Promise.any([p1, p2, p3])  .then(val => {      console.log(val);//p3承受  })  .catch(res => {      console.log(res);  })
  • 如果全副为rejected则会抛出一个全副回绝的谬误
Promise.any([p2])    .then(val => {        console.log(val);    })    .catch(res => {        console.log(res);//AggregateError: All promises were rejected    })

9.Promise.try()

让同步函数同步执行
两种实现形式

//形式一Promise.try = function (func) {    return (async () => func())()}//形式二Promise.try = function (func) {    return new Promise((resolve, reject) => {        resolve(func())    })}
  • func()如果是同步函数会立刻执行，如果是异步函数会将返回值或谬误交给then解决
let f = () => console.log("now");Promise.try(f)console.log("next");//now//next