Promise源码解密-catch/resolve/reject/race

系列文章

1. Promise源码解密-PromisesA+标准
2. Promise源码解密-同步版
3. Promise源码解密-异步版
4. Promise源码解密-then的链式调用
5. Promise源码解密-catch/resolve/reject/race

创作不易 拒绝白嫖 点个赞呗
关注专栏 Promise源码解密,带你走进Promise的深处！！！

---

catch - 特殊的then方法,只有onRejectd

使用

let t = new MyPromise(function (resolve, reject) {
    console.log(somedata); //此处的somedata未定义
});
t.catch(function (reason) {
    console.log('rejected');
    console.log(reason);
});


let t = new MyPromise(function (resolve, reject) {
    //做一些异步操作
    reject("2"); //此处的somedata未定义
})
t.catch(function (reason) {
    console.log('rejected');
    console.log(reason);
});

实现

catch(fn){
    return this.then(null,fn)
}

resolve -返回一个成功的promise

挂载在类本身，静态方法，由类直接调用

MyPromise.resolve = (param) => {
    // 如果是promise的话直接返回
    if (param instanceof MyPromise) {
        return param;
    }
    // 否则
    return new MyPromise((resolve, reject) => {
        // 如果是一个then函数的话直接
        if (param && typeof param === 'object' && typeof param.then === 'function') {
            setTimeout(() => {
                param.then(resolve, reject);
            });
        } else {
            // 普通值直接resolve
            resolve(param);
        }
    });
}

reject 返回一个失败的promise

挂载在类本身，静态方法，由类直接调用

MyPromise.reject = reason => new Promise((resolve,reject)=> reject(reason))

race 执行多个操作

Promise.race([p1, p2, p3])里面哪个结果获得的快，就返回那个结果，不管结果本身是成功状态还是失败状态 。

MyPromise.race = promises =>
  new Promise((resolve, reject) =>
    promises.forEach(pro => pro.then(resolve, reject))
  )

all 执行所有，最终返回一个promise，全部成功返回成功的数组，一个失败就返回失败的结果，

MyPromise.all = (promises) => {
    return new MyPromise((resolve, reject) => {
        let result = []
        // 用来计数，确定执行了几个
        let index = 0
        // 如果没有，直接返回空数据
        if (promises.length === 0) {
            resolve(result);
            return ;
        } 

        for (let i = 0; i < promises.length; i++) {
            MyPromise.resolve(promises[i]).then(res=>{
                result[i] = res
                index++
                // 全部执行返回结果
                if (index === promises.length) {
                    resolve(result)
                }
            },error=>{
                reject(error)
            })
            
        }

    })

}

race 执行全部，和all不同的是，返回第一个成功的结果，否则返回第一个失败的结果

MyPromise.race = function (promises) {
    return new Promise((resolve, reject) => {
        if (promises.length === 0) {
            return;
        } else {
            for (let i = 0; i < promises.length; i++) {
                Promise.resolve(promises[i]).then((data) => {
                    resolve(data);
                    return;
                }, (err) => {
                    reject(err);
                    return;
                });
            }
        }
    });
}