函数式编程-柯里化(currying)和偏应用(partail application 偏函数)

函数式编程
5.1k words

核心概念

柯里化 (Currying)

柯里化是将一个接受多个参数的函数转换成一系列接受单一参数的函数的过程。这种技术让我们能够逐步传入参数，并返回新的函数等待接收剩余参数。
关键特点：

  • 参数是从左到右依次固定的
  • 每次调用返回一个新函数，直到收集齐所有参数
  • 最终在收集完所有参数后执行原函数

偏应用 (Partial Application)

偏应用则是预先固定函数的一个或多个参数，并返回一个接受剩余参数的新函数。与柯里化不同，偏应用允许任意位置的参数被预设。
关键特点：

  • 可以固定任意位置的参数
  • 使用占位符（如undefined）来标记待填充的参数位置
  • 一次性可以固定多个参数

💡 多元函数

仅接受一个参数的被称作一元函数， 二个参数称作二元函数，以此类推…

1
2
3
4
5
// 一元函数
const double = (n) => n * 2

// 二元函数
const add = (x, y) => x + y

了解完 多元函数 后再来实现 柯里化

🔩 柯里化实现

在js中fn.bind() 方法就可以当做一个柯里化方法来使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
const curry = (bindFn, ...firstArg) => {
  return (...curArg) => {
    // 合并参数
    const args = [...firstArg, ...curArg]

    // 判断当前的参数个数是否少于函数调用的参数个数
    if (args.length < bindFn.length) {
      // 记录以传入的参数并返回一个新的函数
      return curry(bindFn, ...args)
    }

    // 执行
    return bindFn(...args)
  }
}

🌰 使用示例

1
2
3
4
5
6
7
8
9
const add = (x, y) => x + y
/** 对add进行柯里化处理 */
const curryAdd = curry(add)

//  参数个数少于add函数预期，返回一个新的函数
console.log(curryAdd(1)) // [Function (anonymous)]

// 参数个数达到预期，返回结果
console.log(curryAdd(1)(2)) // 3

🍐 柯里化的高级用法

  1. 函数组合优化：柯里化使函数组合更加优雅
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 组合函数
const compose = (...fns) =>
  fns.reduce(
    (f, g) =>
      (...args) =>
        f(g(...args))
  )

const addOne = (x) => x + 1
const double = (x) => x * 2
const square = (x) => x * x

// 使用组合函数创建新函数
const compute = compose(square, double, addOne)
console.log(compute(3)) // ((3 + 1) * 2)² = 64
  1. 参数复用：在函数式编程中创建特定功能的函数族
1
2
3
4
5
6
7
8
9
// 通用的过滤器构造函数
const filter = curry((predicate, array) => array.filter(predicate))

// 创建特定过滤器
const filterPositive = filter((x) => x > 0)
const filterEven = filter((x) => x % 2 === 0)

console.log(filterPositive([-3, -2, -1, 0, 1, 2, 3])) // [1, 2, 3]
console.log(filterEven([1, 2, 3, 4, 5, 6])) // [2, 4, 6]

🍐 其他使用场景

实现一个针对不同情况的系统日志打印。可以这么实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 基础的 logHelper 方法
const logHelper = (type, message) => {
  if (type === 'DEBUG') {
    console.debug(message)
  } else if (type === 'ERROR') {
    console.error(message)
  } else {
    console.log(type, message)
  }
}

// 使用柯里化延伸出其他方法
const logDebug = curry(logHelper)('DEBUG')
const logError = curry(logHelper)('ERROR')
const logInfo = curry(logHelper)('INFO')

以上可知 柯里化 所预处理的参数都是，从左至右处理。 如果遇到像 setTimeout 这种，柯里化就无法很好的完成工作。这时候就需要另一个 偏函数

偏函数 partail application

假如要实现一个每隔16ms执行一次的操作，使用 setTimeout(fn, 16)。 这时候柯里化固定的就是第一个参数fn，解决这种情况使用的是偏函数

🌰 使用示例

1
2
3
4
5
6
7
8
// 使用 undefined 充当占位符
const nextAnimeFrame = partial(setTimeout, undefined, 16)

/** 执行 */
console.log('第一次', Date.now())
nextAnimeFrame(() => {
  console.log('第二次', Date.now())
})

🔩 偏函数实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
const partial = (fn, ...partialArg) => {
  return (...fullArg) => {
    // 复制一份预存的参数
    const args = [...partialArg]
    // 当前填充fullArg的下标位置
    let arg = 0

    for (let i = 0; i < fn.length && arg < fullArg.length; i++) {
      // 使用 undefined 充当占位符
      if (args[i] === undefined) {
        // 填充新传入的参数
        args[i] = fullArg[arg++]
      }
    }

    // 执行
    return fn(...args)
  }
}

偏应用的扩展思路

  1. 函数适配器模式：利用偏应用转换已有API以适应新的上下文
1
2
3
4
5
6
7
// DOM操作适配
const addEvent = partial(Element.prototype.addEventListener, undefined, 'click')
const removeEvent = partial(Element.prototype.removeEventListener, undefined, 'click')

// 使用
const button = document.querySelector('button')
addEvent.call(button, () => console.log('Clicked!'))
  1. 配置化函数：创建预配置的函数版本
1
2
3
4
5
6
7
8
9
10
11
12
// 通用Ajax请求函数
const ajaxRequest = (url, method, headers, body) => {
  // 实现省略...
}

// 创建特定类型的请求函数
const getJSON = partial(ajaxRequest, undefined, 'GET', { 'Content-Type': 'application/json' })
const postJSON = partial(ajaxRequest, undefined, 'POST', { 'Content-Type': 'application/json' })

// 使用
getJSON('/api/users')
postJSON('/api/users', { name: 'John', age: 30 })

🚗 柯里化和偏应用的结合使用

可以创建一个更灵活的通用工具函数，同时支持柯里化和偏应用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
const adaptable = (fn) => {
  const arity = fn.length

  function curried(...args) {
    if (args.length >= arity) return fn(...args)
    return (...more) => curried(...args, ...more)
  }

  curried.partial = (...partialArgs) => {
    return (...restArgs) => {
      const args = [...partialArgs]
      let restIndex = 0

      for (let i = 0; i < args.length && restIndex < restArgs.length; i++) {
        if (args[i] === undefined) {
          args[i] = restArgs[restIndex++]
        }
      }

      return fn(...args)
    }
  }

  return curried
}

// 使用示例
const sum = adaptable((a, b, c) => a + b + c)

// 柯里化使用
console.log(sum(1)(2)(3)) // 6
console.log(sum(1, 2)(3)) // 6

// 偏应用使用
const sumWithA5 = sum.partial(5, undefined, undefined)
console.log(sumWithA5(10, 15)) // 30

性能考量与应用场景

  • 性能权衡：柯里化和偏应用会创建额外的闭包，在性能敏感的场景应注意评估

  • 最佳应用场景：

    1. API适配层
    2. 配置化系统
    3. 函数式编程范式
    4. 事件处理系统
    5. 中间件构建

  • 与其他函数式编程技术结合：

    1. 函数组合(compose)
    2. 管道操作(pipe)
    3. 函子(functor)
    4. 单子(monad)

建议

  1. 为重复使用的函数模式创建通用柯里化/偏应用工具
  2. 实现自动柯里化的装饰器，简化代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// TypeScript装饰器示例
function Curry(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value
  descriptor.value = function (...args) {
    if (args.length >= originalMethod.length) {
      return originalMethod.apply(this, args)
    }
    return (...moreArgs) => descriptor.value.apply(this, [...args, ...moreArgs])
  }
  return descriptor
}

class Calculator {
  @Curry
  add(a: number, b: number, c: number) {
    return a + b + c
  }
}
  1. 结合TypeScript的类型系统增强类型安全：
1
2
3
4
5
6
// 通用柯里化类型定义
type Curry<F> = F extends (...args: infer A) => infer R
  ? A extends [infer First, ...infer Rest]
    ? (arg: First) => Curry<(...args: Rest) => R>
    : R
  : never
Comments