常用的高阶函数

• 常用的高阶函数
  • 数组
  • 函数处理
  • 控制函数执行

数组

1. forEach 遍历数组，无返回值
2. map 对数组每个元素做映射，返回新数组
3. filter 过滤数组中满足条件的项
4. reduce 聚合计算，如累加、合并等
5. some / every 判断数组中是否有 / 所有元素满足条件
6. find / findIndex 找到第一个满足条件的元素 / 索引

函数处理

• curry 柯里化函数，将多参数转为单参数链调用

function curry(fn: Function, args: any[] = []) {
  return (...nextArgs: any[]) => {
    const all = [...args, ...nextArgs]
    return all.length >= fn.length ? fn(...all) : curry(fn, all)
  }
}

const add = (a: number, b: number, c: number) => a + b + c
const curriedAdd = curry(add)
curriedAdd(1)(2)(3) // 6

• compose / pipe 函数组合，从右到左 / 从左到右组合函数

const compose =
  (...fns: Function[]) =>
  (x: any) =>
    fns.reduceRight((res, fn) => fn(res), x)

const pipe =
  (...fns: Function[]) =>
  (x: any) =>
    fns.reduce((res, fn) => fn(res), x)

const double = (x: number) => x * 2
const square = (x: number) => x ** 2

const composed = compose(square, double) // square(double(x))
composed(3) // (3 * 2)^2 = 36

• once 返回只执行一次的函数

function once(fn: Function) {
  let called = false,
    result: any
  return (...args: any[]) => {
    if (!called) {
      called = true
      result = fn(...args)
    }
    return result
  }
}

const init = once(() => console.log('Only once'))
init()
init() // 不再执行```

• debounce / throttle（用于防抖节流）

// 防抖
function debounce(fn: Function, delay: number) {
  let timer: any = null
  return (...args: any[]) => {
    clearTimeout(timer)
    timer = setTimeout(() => fn(...args), delay)
  }
}
// 节流

function throttle(fn, delay) {
  let last = 0
  return function (...args) {
    const now = Date.now()
    if (now - last >= delay) {
      last = now
      fn.apply(this, args)
    }
  }
}

控制函数执行

// 记忆化，提高纯函数的计算性能

function memoize(fn: Fn): Fn {
  const cache = new Map()
  return function (...args) {
    const key = JSON.stringify(args)
    if (cache.has(key)) {
      return cache.get(key)
    }
    const result = fn(...args)
    cache.set(key, result)
    return result
  }
}

//偏函数，预设部分参数
function partial(fn: Function, ...presetArgs: any[]) {
  return function (...laterArgs: any[]) {
    return fn(...presetArgs, ...laterArgs)
  }
}

function add(a: number, b: number, c: number) {
  return a + b + c
}

const add5 = partial(add, 2, 3)
console.log(add5(4)) // 输出 9，相当于 add(2, 3, 4)