在掘金上看到一道面试题，一点思路都没有，请问各路大神这道题该怎么解答

19.现要按照一定顺序发起去进行第三方渠道授权的多个异步网络请求（未知数量，需设置数组），但是每个网络请求，如果报错了或者失败了有多次重新请求本网络请求的机会（次数可设置），直到当前网络请求节点的次数用完了，才算整个授权调用链失败，需要封装成一个函数，返回Promise可知道整体的调用链的完成情况以及每个节点的数据

整体数据，肯定是要搞个闭包嘛。。

发起请求可以当作是 axios，那么其实就是就是搞个 promise，然后模拟递归咯（有重试机会就调用自己并机会减一）

//模拟请求
async function ajax(url) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (Math.floor(Math.random() * 10) % 2) {
        resolve(url);
 } else {
        reject(new Error("test error"));
 }
    }, 1000);
 });
}
//重试
async function retry(request, count) {
  let index = 0;
 let data;
 let lastError = null;
 while (index < count) {
    try {
      data = await request();
 return new Promise(resolve => resolve(data));
 } catch (e) {
      index++;
 if (index < count) {
        console.error(e, `失败获取到数据,准备第${index}次重试`);
 } else {
        console.error(e, `失败获取到数据`);
 }
      lastError = e;
 }
  }
  return new Promise((resolve, reject) => reject(lastError));
}
// 请求方法
async function requests(urls, retryCount) {
  let value = {};
 for (let url of urls) {
    try {
      const data = await retry(() => ajax(url), retryCount);
 console.log(`${url}成功获取到数据:${data}`);
 value[url] = data;
 }catch (e){
      value[url] = e;
 }
  }
  return new Promise(resolve => resolve(value));
}
//test
(async () => console.log(await requests(['b', 'a'], 3)))();

function randomBool() {
                return Math.random() * 2 > 1;
            }

            function delay(sign, timeSec) {
                return new Promise((resolve, reject) => {
                    const result = randomBool();
                    const exec = result ? resolve : reject;
                    setTimeout(exec, timeSec * 1000, sign);
                })
            }

            function fetchs(fetchArr, retryTime) {
                let retriedTime = 0;
                const fetch = (...data) => {
                    return delay(...data)
                        .catch(() => {
                            retriedTime++;
                            if (retriedTime <= retryTime) {
                                console.log(`重试${retriedTime}, ${data[0]}`)
                                return fetch(...data)
                            } else {
                                console.log(`失败在${data[0]}`)
                                return Promise.reject(data[0]);
                            }
                        })
                }
                const arr = fetchArr.map(item => fetch(...item));
                return Promise.all(arr)
            }

            fetchs([
                ['a', 1],
                ['b', 0.5],
                ['c', 0.25],
                ['d', 1]
            ], 3).then(console.log)