第 159 题：实现 Promise.retry，成功后 resolve 结果，失败后重试，尝试超过一定次数才真正的 reject

[yygmind]

[bighamD]

Promise.retry = function (promiseFn, times = 3) {
  return new Promise(async (resolve, reject) => {
    while (times--) {
      try {
        var ret = await promiseFn();
        resolve(ret);
        break;
      } catch (error) {
        if (!times) reject(error);
      }
    }
  });
};
function getProm() {
    const n = Math.random();
    return new Promise((resolve, reject) => {
        setTimeout(() =>  n > 0.9 ? resolve(n) : reject(n), 1000);
    });
}
Promise.retry(getProm);

[liujiekun]

[FunnyBoyCN]

[ShinningFire]

[weiweixuan]

写的不好，有好的写法大家可以指点一下，感谢

/*
          实现 Promise.retry，成功后 resolve 结果，失败后重试，尝试超过一定次数才真正的 reject
        */

      // 同步获得Promise状态和值，这样写很low，要是更好的写法大家call我一下
      async function checkPromise(getFlag) {
        try {
          let res = await getFlag();
          return { flag: true, value: res };
        } catch (e) {
          return { flag: false, value: e };
        }
      }

      async function retry(pro, count = 10) {
        let result = {
            flag: false,
            value: null,
          },
          length = count;
        while (count && !result.flag) {
          console.log(`调用了${length - count + 1}次`);
          result = await checkPromise(pro);
          const { flag, value } = result;
          if (!flag) {
            count--;
          }
        }
        return result.value;
      }
      Promise.retry = retry;

      getFlag = function () {
        return Math.random() > 0.5 ? Promise.resolve(1) : Promise.reject(-1);
      };

      Promise.retry(getFlag, 10)
        .then((res) => {
          console.log("成功结果", res);
        })
        .catch((e) => {
          console.log("失败结果", e);
        });

[fanefanes]

 Promise.retry = function(fn, num){
    return new Promise(function(resolve, reject){
       while(num>0){
           try{
                  const res = await fn
                  resolve(res)
                  num = 0
            } catch(e){
                  if(!num) reject(e)
            }
            num --
        }
    })
}

[listentolife]

function retry (fn, count = 10) {
  return new Promise(async (resolve, reject) => {
    while (count) {
      try {
        let res = await fn()
        resolve(res)
        return
      } catch (e) {
        if (!count) reject(e)
        count--
      }
    }
  })
}

[rottenpen]

/** 
 * 实现 Promise.retry，成功后 resolve 结果，失败后重试，尝试超过一定次数才真正的 reject 
*/
Promise.retry = function(fn, limit) {
  let i = 0
  return new Promise((resolve, reject) => {
    function retry() {
      console.log('try!', i)
      fn().then(res => {
        resolve()
      }).catch(err => {
        i++
        if(i > limit - 1) {
          reject(err)
        } else {
          retry()
        }
      })
    }
    retry()
  })
  
}
Promise.retry(() => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      Math.random() > .5 ? resolve() : reject()
    }, 300);
  })
}, 5).then(res => {
  console.log('resolve')
}).catch(err => {
  console.log('reject')
})

[huangzhiyang166]

方法一：在 catch() 中再次执行函数

Promise.retry = function (fn, times) {
  fn().then(console.log)
    .catch(e => {
      if (times > 0) {
        console.log('try again...')
        Promise.retry(fn, times - 1)
      } else {
        console.log('Error: No more times, now rejected.')
      }
    })
}

方法二：async 函数，结合 while 循环和 try...catch

Promise.retry = async function (fn, times) {
  while (times > 0) {
    try {
      const res = await fn()
      console.log(res)
      return
    } catch(e) {
      console.log('try again...')
      times--
    }
  }
  console.log('Error: No more times, now rejected.')
}

测试：

const test = function () {
  return new Promise((resolve, reject) => {
    const num = Math.floor(Math.random() * 10)
    if (num > 7) {
      resolve(num)
    } else {
      reject(new Error(num))
    }
  })
}

Promise.retry(test, 5)

[hugeorange]

记得几年前面试一次面试时问过类似的问题，当时绞尽脑汁也没想出解决办法

/**
 * promiseFn 返回promise 对象的函数
 * max       最大重试次数
 * interval  重试间隔时间
*/
Promise.retry = function (promiseFn, max=1, interval = 1000) {
    function excuteFn(max) {
        return promiseFn().then(res => {
            return Promise.resolve(res);
        }, err => {
            if (max <= 1) {
                return Promise.reject(err);
            } else {
                return new Promise((resolve, reject) => {
                    setTimeout(() => {
                        resolve(excuteFn(--max));
                    }, interval);
                })
            }
        })
    }
    return excuteFn(max)
}


// 测试用例
Promise.retry(ajax, 5, 1000)
    .then(res => console.log('retry-res->', res))
    .catch(err => console.log('retry-err->', err))



function ajax() {
    const n = Math.random();
    console.log('--->', n)
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (n > 0.9) {
                resolve(`成功返回值--->${n}`)
            } else {
                reject(`失败返回值--->${n}`)
            }
        }, 3000);
    })
}

[dice246]

// 实现 Promise.retry，成功后 resolve 结果，失败后重试，尝试超过一定次数才真正的 reject 
Promise.retry = function(fn, num){
  return new Promise(async function(resolve, reject){
     while(num>0){
         try{
            const res = await fn();
            console.log('res: ', res);
            resolve(res)
            num = 0
          } catch(e){
            console.log('reject....');
            if(num === 1) reject(e);
            num--
          }
      }
  })
}

const test = () => {
  return new Promise((resolve, reject) => {
    const num = Math.floor(Math.random() * 10);
    if (num > 5) {
      resolve(num);
    } else {
      reject(`num 小于等于8`);
    }
  
  })
}

Promise
.retry(test, 5)
.then(res => {
  console.log('result: ', res);
})
.catch(err => {
  console.log('err: ', err);
})