TypeScript 实现并发请求控制和科里化函数

function concurRequest(urls: string[], maxNum: number) {
  return new Promise((resolve) => {
    if (urls.length === 0) resolve([])

    let index = 0 // 下一次请求对应的 urls 的下标
    let count = 0 // 请求完成的数量
    const result = [] // 请求结果

    async function request() {
      const i = index // 保存当前请求对应的 urls 的下标
      const url = urls[index] // 获取当前请求的 url
      index++ // 下一次请求对应的 urls 的下标 +1

      try {
        const res = await fetch(url) // 请求
        result[i] = res // 保存请求结果
      } catch (error) {
        result[i] = error // 保存请求结果
      } finally {
        if (count === urls.length) {
          // 请求完成
          resolve(result)
        }

        if (index < urls.length) {
          // 还有请求未发出，继续请求
          await request()
        }
      }
    }

    // 发起并发请求
    for (let i = 0; i < Math.min(maxNum, urls.length); i++) {
      request()
    }
  })
}

const curry = (fn: Function, len = fn.length, ...args: any[]) =>
  len <= args.length ? fn(...args) : curry.bind(null, fn, len, ...args)

const sum = (a: number, b: number, c: number) => a + b + c

const curriedSum = curry(sum)

curriedSum(1, 2, 3) // 6
curriedSum(1)(2, 3) // 6
curriedSum(1, 2)(3) // 6
curriedSum(1)(2)(3) // 6

// 定义一个通用的 compose 函数，接受任意数量的函数作为参数
function compose<T>(...functions: ((x: T) => T)[]): (x: T) => T {
  // 返回一个新的函数，将输入依次传递给所有函数并返回结果
  return (input: T): T => functions.reduce((result, fn) => fn(result), input) as T
}

// 示例函数
function addOne(x: number): number {
  return x + 1
}

function double(x: number): number {
  return x * 2
}

// 将 addOne 和 double 函数组合起来
const composedFunction = compose(addOne, double)

// 测试组合函数
console.log(composedFunction(3)) // 输出 8，先加一再乘二