请求合并（后端服务可能扛不住频繁的请求时，将多个重复请求（参数不一样），合并成一个，也就是将参数合并）

const fetchUserInfoBatched = createBatchedRequest<string, UserBaseInfo>(
  async (userIds) => {
    const { data } = await request.post('/api/user/list', {
      userIds,
    });
    return data;
  },
  500 // 设置延迟时间为500毫秒
);

// 使用示例
async function getUserInfo() {
  const user1 = await fetchUserInfoBatched(1);
  const user2 = await fetchUserInfoBatched(2);
  const user3 = await fetchUserInfoBatched(3);

  console.log(user1, user2, user3);
}

getUserInfo();

interface BatchRequestItem<T, R> {
  params: T;
  resolve: (r: R) => void;
  reject: (reason: unknown) => void;
}

/**
 * 创建批量请求的函数
 * 在一定延迟时间内的所有请求都会被合并提交并批量发送
 * @param batchFunction 合并后的请求函数
 * @param delay 延迟时间，以毫秒为单位
 */
export function createBatchedRequest<T, R>(
  batchFunction: (batchParams: T[]) => Promise<R[]>,
  delay = 200
): (params: T) => Promise<R> {
  const batchQueue: BatchRequestItem<T, R>[] = [];
  let isBatching = false;
  let timer: NodeJS.Timeout | null = null;

  async function executeBatchedRequest() {
    if (isBatching) return;
    isBatching = true;

    const itemsToBatch = [...batchQueue];
    batchQueue.length = 0;

    try {
      const batchedResult = await batchFunction(itemsToBatch.map((item) => item.params));
      itemsToBatch.forEach((item, index) => {
        item.resolve(batchedResult[index]);
      });
    } catch (error) {
      itemsToBatch.forEach((item) => {
        item.reject(error);
      });
    } finally {
      isBatching = false;
    }
  }

  return (params: T): Promise<R> => {
    return new Promise<R>((resolve, reject) => {
      batchQueue.push({
        params,
        resolve,
        reject,
      });

      // Execute the batched request after the specified delay
      if (!timer) {
        timer = setTimeout(() => {
          executeBatchedRequest();
          timer = null;
        }, delay);
      }
    });
  };
}