JavaScript柯里化原理与通用实现详解

函数式编程与柯里化概述

函数式编程是当前主流的编程范式之一，其核心主张是将函数作为参数传递，并返回一个无副作用的函数。简而言之，这种范式追求让每个函数仅负责单一职责。

包括JavaScript、Haskell和Clojure在内的多种编程语言均支持函数式编程特性。

该编程思想主要包含三个关键概念：

• 纯函数
• 柯里化
• 高阶函数

本文旨在详细阐述柯里化这一核心概念。

柯里化的基本概念与示例

什么是柯里化

首先通过一个具体示例进行说明：

function sum(a, b, c) { return a + b + c; } // 调用 sum(1, 2, 3); // 6

上述代码实现了a、b、c三个参数的相加功能。若将其改写为柯里化形式，代码如下：

function sum(a) { return function (b) { return function(c) { return a + b + c; } } } // 调用 let sum1 = sum(1); let sum2 = sum1(2); sum2(3); // 6

柯里化的本质是将拥有多个参数的函数转化为一系列只接收较少参数（通常是一个参数）的函数的过程。

让我们逐步分析上述柯里化函数的执行逻辑。首先调用sum(1)，此时变量sum1等价于：

sum1 = function(b) { return function(c) { // 注意此时变量a存在于闭包中，可以调用，a = 1 return a + b + c; } }

接着调用sum1(2)，此时赋值给变量sum2等价于：

sum2 = function(c) { // 变量a,b皆在闭包中, a = 1, b = 2 return a + b + c; }

最后调用sum2(3)，返回1 + 2 + 3的计算结果6；

这就是一个最基础的柯里化函数示例，逻辑相对简单。

柯里化的实际应用价值

柯里化函数的作用

那么问题来了，与原始函数相比，改写后的柯里化函数代码量显著增加，且可读性降低。柯里化究竟有何实际用途？

诚然，在此例中柯里化显得冗长且不够直观，但在许多实际场景中，它发挥着巨大作用，甚至许多开发者在不知不觉中已在使用。举一个简单例子：

假设我们需要计算一批长方体的体积，实现如下函数：

function volume(length, width, height) {
  return length * width * height;
}
volume(200, 100, 200);
volume(200, 150, 100);
volume(200, 50, 80);
volume(100, 50, 60);

如上计算长方体的体积函数会发现存在很多相同长度的长方体，我们再用柯里化函数实现一下：

function volume(length, width, height) {
  return function(width) {
    return function(height) {
     return length * width * height;
      }
  }
}
let len200 = volume(200);
len200(100)(200);
len200(150)(100);
len200(50)(80);
volume(100)(50)(60);

如上，通过实现一个len200函数我们统一处理长度为200的长方体的体积，这就实现了参数复用。

再举一个只执行一次函数的例子：

function execOnce(fun) {
   let flag = true;
 return function() {
  if (flag) {
   fun && fun();
   flag = false;
  }
 }
}
let onceConsole = execOnce(function() {
  console.log('只打印一次');
});
onceConsole();
onceConsole();

如上，我们实现了一个execOnce函数，该函数接受一个函数参数，然后返回一个函数，变量flag存在闭包中，用来判断返回的函数是否执行过，onceConsole相当于：

let onceConsole = function() {
 if (flag) {
     (function() {
    console.log('只打印一次');
   })()
   flag = false;
  }
}

这也是柯里化函数的一个简单应用。

通用柯里化函数的实现方案

通用柯里化函数的实现

既然柯里化如此实用，我们能否实现一个通用的柯里化工具函数？所谓通用，即该函数能将任意函数的参数转换为柯里化形式。首先看第一版实现代码：

 // 第一版
var curry = function (fn) {
 var args = [].slice.call(arguments, 1);
 return function() {
  var newArgs = args.concat([].slice.call(arguments));
  return fn.apply(null, newArgs);
 };
};
 function add(a, b) {
  return a + b;
 }

var addFun = curry(add, 1, 2);
addFun() // 3
//或者
var addOne = curry(add, 1);

如上代码，我们接受一个函数作为参数，然后收集其它的参数，将这些参数传给这个函数参数去执行。但上面的代码有个问题，参数不够自由，比如我们想这么调用就会报错：

var addFun = curry(function(a, b,c) { return a + b + c; }, 1); addFun(2)(3); // 报错 addFun(...) is not a function

这似乎违背了参数复用的初衷，改进方案如下：

function curry(fn, args) {
 var length = fn.length;
 args = args || [];
 return function(...rest) {
  var _args = [...args, ...rest];
  return _args.length < length
   ? curry.call(this, fn, _args)
  : fn.apply(this, _args);
 }
}
var fn = curry(function(a, b, c) {
 console.log(a + b + c);
});
fn('a', 'b', 'c'); // abc
fn('a', 'b')('c'); // abc
fn('a')('b')('c'); // abc

如上实现就很完善，该工具函数的实现总结起来就一句话：

利用闭包将函数的参数储存起来，等参数达到一定数量时执行函数。

总结与展望

后记

柯里化基于闭包机制，若不理解闭包可能会阻碍对柯里化的理解。希望本文能帮助读者充分了解和掌握JavaScript中的柯里化技术。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持本站。