1. promise超时，返回error

传入一个promise和超时的时间，如果在time的时间内promise没有返回就抛出错误

/**
 *  传入一个promise和超时的时间，如果在time的时间内promise没有返回就抛出错误
 * @param {Promise} promise
 * @param {Number} time
 * @returns
 */
function promiseTimeout(promise, time) {
  const timePro = new Promise((resolve, reject) => {
    setTimeout(function () {
      reject('超时');
    }, time);
  });

  return Promise.race([promise, timePro]);
}
 

2. 实现reTry函数

/**
 * 实现一个函数：function retry（fn, interval, times）
 * fn是一个promise，
 * 重试上限为times次，
 * 重试间隔为interval，
 * 重试成功返回成功的结果，失败返回失败的结果
 * @param {Promise} fn
 * @param {number} interval
 * @param {number} times
 */

async function reTry(fn, interval, times) {
  let allTimes = 0;
  while (allTimes < times) {
    try {
      const res = await fn();
      return res;
    } catch (error) {
      allTimes++;
      if (allTimes === times) {
        throw error;
      } else {
        await new Promise((res, rej) => setTimeout(res, interval));
      }
    }
  }
}

3. 并发请求

/**
 *  并发请求
 * @param {[]} promiseArr    Promise 数组
 * @param {number} maxNum    最大并发数
 * @returns
 */
async function conCurrentRequest(promiseArr, maxNum) {
  return new Promise((resolve, reject) => {
    const allNum = promiseArr.length;
    let curIndex = 0;
    let successCount = 0;
    let allData = [];
    async function run() {
      let i = curIndex;
      try {
        let res = await promiseArr[curIndex++]();
        allData[i] = res;
      } catch (error) {
        allData[i] = error;
      } finally {
        successCount++;
        if (successCount === allNum) {
          resolve(allData);
        }
        if (curIndex < allNum) {
          run();
        }
      }
    }
    for (let j = 0; j < maxNum; j++) {
      run();
    }
  });
}