偏函数, 柯里化, Compose 和 Pipe

2023-10-29

5分钟阅读时长

偏函数（Partial Function）

在 JavaScript 中，偏函数（Partial Function）是指通过固定部分参数来创建一个新的函数。这个新函数会接收剩余的参数，并将其与固定的参数一起传递给原始函数执行。偏函数的作用是减少重复的代码，提高代码的可重用性。

下面是一个简单的例子来说明偏函数的概念：

// 原始函数
function multiply(x, y) {
  return x * y;
}

// 偏函数
function createMultiplier(multiplier) {
  return function (x) {
    return multiply(x, multiplier);
  };
}

// 使用偏函数
const double = createMultiplier(2); // 创建一个乘以2的偏函数
console.log(double(5)); // 输出：10

const triple = createMultiplier(3); // 创建一个乘以3的偏函数
console.log(triple(5)); // 输出：15

在上面的例子中，我们定义了一个原始函数 multiply，它接收两个参数并返回它们的乘积。然后，我们使用 createMultiplier 函数创建了两个偏函数 double 和 triple，分别乘以 2 和乘以 3。这些偏函数只需要传入一个参数，它们会将这个参数与固定的乘数进行相乘并返回结果。

通过偏函数，我们可以预先设置一些参数，得到一个新的函数，然后在后续的调用中，只需传入剩余的参数即可。这样可以避免在多次调用中重复设置相同的参数，提高了代码的可读性和重用性。

需要注意的是，JavaScript 原生并没有内置的偏函数方法。上面的例子是通过创建一个闭包函数来实现的。但是在 ECMAScript 6（ES6）之后，我们可以使用 bind 方法来创建偏函数，如下所示：

// 使用bind方法创建偏函数
const triple = multiply.bind(null, 3);

console.log(triple(5)); // 输出：15

在这个例子中，我们使用 bind 方法将 multiply 函数绑定到固定的第一个参数 3 上，返回一个新的偏函数 triple。然后，我们可以像正常调用函数一样使用偏函数 triple。

柯里化（Currying）

柯里化（Currying）是一种函数转换技术，它将接受多个参数的函数转化为一系列接收一个参数的函数。这种转换使得函数更加灵活和可复用。在 JavaScript 中，柯里化是一种常见的编程技巧，可以通过不断返回新的函数来实现。

下面是一个简单的例子来说明柯里化：

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

// 将接受三个参数的函数转化为一系列接受一个参数的函数
function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn.apply(null, args);
    } else {
      return function (...moreArgs) {
        return curried.apply(null, args.concat(moreArgs));
      };
    }
  };
}

// 使用柯里化函数
const curriedAdd = curry(add);
console.log(curriedAdd(1)(2)(3)); // 输出：6
console.log(curriedAdd(1, 2)(3)); // 输出：6
console.log(curriedAdd(1)(2, 3)); // 输出：6
console.log(curriedAdd(1, 2, 3)); // 输出：6

在上面的例子中，curry 函数接受一个函数作为参数，然后返回一个新的函数 curried。当调用 curried 函数时，如果传入的参数数量达到了原始函数 fn 的参数数量，就直接调用原始函数并返回结果；否则，返回一个新的函数，该新函数将当前传入的参数与之前的参数合并，并递归调用 curried 函数。

柯里化在实际编程中有很多应用。它可以帮助我们提供更多的灵活性，例如部分应用函数、延迟执行、参数复用等。通过柯里化，我们可以将一个接受多个参数的函数转化为接受一个参数的函数序列，从而更方便地进行函数组合和复用。

Compose

在 JavaScript 中，Compose 是一个函数组合的概念，它用于将多个函数按照一定的顺序组合起来形成一个新的函数。这种函数组合的方式可以帮助我们以一种更加简洁和可读的方式处理函数的复杂组合操作。

Compose 函数接受一个或多个函数作为参数，并返回一个新的函数。这个新函数将按照从右到左的顺序依次调用传入的函数。每个函数的输出都会作为下一个函数的输入，最后返回最终的结果。

下面是一个简单的示例来演示如何使用 Compose 函数：

const compose =
  (...funcs) =>
  (arg) => {
    return funcs.reduceRight((result, fn) => {
      return fn(result);
    }, arg);
  };

// 示例函数
const addOne = (x) => x + 1;
const multiplyByTwo = (x) => x * 2;
const square = (x) => x * x;

// 组合函数
const composedFunction = compose(addOne, multiplyByTwo, square);

// 使用组合函数
const result = composedFunction(3); // 结果为 19
console.log(result);

在上面的示例中，我们定义了三个简单的函数：addOne、multiplyByTwo 和 square。然后，我们使用 Compose 函数将它们按照顺序组合在一起，创建了一个新的函数 composedFunction。

当我们调用 composedFunction 时，它会按照从右到左的顺序依次调用 addOne、multiplyByTwo 和 square 函数，并返回最终的结果。

在这个示例中，我们传入的参数是 3。首先，3 经过 square 函数处理后变为 9，然后经过 multiplyByTwo 函数处理变为 18，最后经过 addOne 函数处理变为 19，最终的结果就是 19。

使用 Compose 函数可以帮助我们更好地组织和重用函数，使代码更加模块化和可组合。它在函数式编程中被广泛使用，可以大大简化复杂的函数操作。

Pipe

在 JavaScript 编程中，“pipe"是一种常见的函数式编程概念和技术，用于将多个函数以一种顺序连接起来，形成一个函数管道或函数链。每个函数接收前一个函数的输出作为输入，并将自己的输出传递给下一个函数，以便按照特定的顺序依次进行处理。

实际上，“pipe"的概念源于 UNIX 操作系统中的管道（pipe）概念，类比于将多个命令通过管道连接在一起依次执行。在 JavaScript 中，借鉴了这个概念，使用"pipe"可以将多个函数链接在一起，使代码更加模块化、可读性更高。

通常，“pipe"可以通过自定义函数实现，也可以使用第三方库（如 Lodash、Ramda 等）提供的函数来实现。下面是一个示例，展示了如何使用原生 JavaScript 实现一个简单的"pipe"函数：

function pipe(...fns) {
  return function (x) {
    return fns.reduce((v, f) => f(v), x);
  };
}

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

function double(x) {
  return x * 2;
}

function square(x) {
  return x * x;
}

// 创建管道函数
const pipeline = pipe(addOne, double, square);

// 使用管道函数
const result = pipeline(3); // 64

console.log(result); // 输出 64

在上面的示例中，我们定义了三个简单的函数：addOne、double 和 square。然后使用 pipe 函数将它们连接在一起，形成一个管道函数 pipeline。通过调用 pipeline(3)，可以将输入的值依次经过 addOne、double 和 square 三个函数进行处理，最终输出结果 64。

这种函数管道的方式可以帮助我们在编程中更好地组合和复用函数，使代码更加清晰、简洁和可维护。

偏函数, 柯里化, Compose 和 Pipe

偏函数（Partial Function）

柯里化（Currying）

Compose

Pipe

本页内容