常用的高阶函数

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

数组

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)

背景

「常用的高阶函数」属于语言语义边界主题。该类问题在重构阶段最容易引发“代码没报错但行为变了”的隐性风险。

核心原理

需要同时理解语法定义与运行时行为：作用域、提升规则、this 绑定、短路语义、类型判定边界。

实现方式 / 示例

建议每个结论都配“正例 + 反例 + 适用边界”，并明确推荐写法与禁用写法。

常见问题

1. 只背结论，不验证边界。
2. 在不同场景复用同一写法，忽略语义差异。
3. 缺少函数式约束与副作用边界时，问题会在链式调用中被持续放大。

最佳实践

将知识点同步到 ESLint 规则、代码评审清单与模板代码，形成自动化约束。

总结

围绕「常用的高阶函数」的关键不是记忆语法，而是把语义边界沉淀为可执行规范。