// 請(qǐng)求列表
const requestList = [];

// 為了方便查看，i從1開(kāi)始計(jì)數(shù)
for (let i = 1; i <= 100; i++) {
  requestList.push(
    () =>
      new Promise(resolve => {
        setTimeout(() => {
          console.log('done', i);
          resolve(i);
        }, Math.random() * 1000);
      }),
  );
}

const parallelRun = async max => {
  const requestSliceList = [];
  for (let i = 0; i < requestList.length; i += max) {
    requestSliceList.push(requestList.slice(i, i + max));
  }

  for (let i = 0; i < requestSliceList.length; i++) {
    const group = requestSliceList[i];
    try {
      const res = await Promise.all(group.map(fn => fn()));
      console.log('接口返回值為：', res);
    } catch (error) {
      console.error(error);
    }
  }
};

// 請(qǐng)求列表
const requestList = [];

for (let i = 1; i <= 100; i++) {
  requestList.push(
    () =>
      new Promise((resolve, reject) => {
        setTimeout(() => {
          if (i === 92) {
            reject(new Error('出錯(cuò)了，出錯(cuò)請(qǐng)求：' + i));
          } else {
            console.log('done', i);
            resolve(i);
          }
        }, Math.random() * 1000);
      }),
  );
}

const parallelRun = async max => {
  const requestSliceList = [];
  for (let i = 0; i < requestList.length; i += max) {
    requestSliceList.push(requestList.slice(i, i + max));
  }

  for (let i = 0; i < requestSliceList.length; i++) {
    const group = requestSliceList[i];
    try {
      // 使用 allSettled 替換 all
      const res = await Promise.allSettled(group.map(fn => fn()));
      console.log('接口返回值為：', res);
    } catch (error) {
      console.error(error);
    }
  }
};

// 運(yùn)行池
const pool = new Set();

// 等待隊(duì)列
const waitQueue = [];

/**
 * @description: 限制并發(fā)數(shù)量的請(qǐng)求
 * @param {*} reqFn：請(qǐng)求方法
 * @param {*} max：最大并發(fā)數(shù)
 */
const request = (reqFn, max) => {
  return new Promise((resolve, reject) => {
    // 判斷運(yùn)行吃是否已滿
    const isFull = pool.size >= max;

    // 包裝的新請(qǐng)求
    const newReqFn = () => {
      reqFn()
        .then(res => {
          resolve(res);
        })
        .catch(err => {
          reject(err);
        })
        .finally(() => {
          // 請(qǐng)求完成后，將該請(qǐng)求從運(yùn)行池中刪除
          pool.delete(newReqFn);
          // 從等待隊(duì)列中取出一個(gè)新請(qǐng)求放入等待運(yùn)行池執(zhí)行
          const next = waitQueue.shift();
          if (next) {
            pool.add(next);
            next();
          }
        });
    };

    if (isFull) {
      // 如果運(yùn)行池已滿，則將新的請(qǐng)求放到等待隊(duì)列中
      waitQueue.push(newReqFn);
    } else {
      // 如果運(yùn)行池未滿，則向運(yùn)行池中添加一個(gè)新請(qǐng)求并執(zhí)行該請(qǐng)求
      pool.add(newReqFn);
      newReqFn();
    }
  });
};

requestList.forEach(async item => {
  const res = await request(item, 10);
  console.log(res);
});

npm install p-limit -S

import plimit from 'p-limit';


const limit = plimit(10);

requestList.forEach(async item => {
  const res = await limit(item);
  console.log(res);
});

import Queue from 'yocto-queue';

export default function pLimit(concurrency) {
  const queue = new Queue();
  let activeCount = 0;

  const next = () => {
    activeCount--;

    if (queue.size > 0) {
      queue.dequeue()();
    }
  };

  const run = async (function_, resolve, arguments_) => {
    activeCount++;

    const result = (async () => function_(...arguments_))();

    resolve(result);

    try {
      await result;
    } catch {}

    next();
  };

  const enqueue = (function_, resolve, arguments_) => {
    queue.enqueue(run.bind(undefined, function_, resolve, arguments_));

    (async () => {
      // This function needs to wait until the next microtask before comparing
      // `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
      // when the run function is dequeued and called. The comparison in the if-statement
      // needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
      await Promise.resolve();

      if (activeCount < concurrency && queue.size > 0) {
        queue.dequeue()();
      }
    })();
  };

  const generator = (function_, ...arguments_) =>
    new Promise(resolve => {
      enqueue(function_, resolve, arguments_);
    });

  return generator;
}