javascript中有趣的反柯里化深入分析

反柯里化（uncurrying）是一种将柯里化函数转换为普通函数的过程。JavaScript中的对象方法都是柯里化函数，即将this绑定在对象上来返回一个新函数。

反柯里化的主要目的是为了复用函数，在对象层级比较深的地方使用更为方便。

以下是javascript中有趣的反柯理化深入分析的完整攻略：

什么是反柯里化

1.1 柯里化

在JavaScript中，函数可以使用闭包创建柯里化函数。例如，我们创建一个简单的加法柯里化函数：

function add(x) {
  return function(y) {
    return x + y;
  }
}

const add5 = add(5);
console.log(add5(3)); // 输出 8

在上面的例子中，add函数返回一个没有输入参数，但是返回一个接受一个参数的函数的函数。这是一种柯里化的方法。

1.2 反柯里化

反柯里化是把柯里化函数转换成普通函数。反柯里化可以让我们更加方便的使用对象的方法。

如何进行反柯里化

2.1 方法1

反柯里化的一种方式是，把对象的方法复制到Function.prototype中并执行。

Function.prototype.uncurrying = function() {
  const self = this;
  return function() {
    return Function.prototype.call.apply(self, arguments);
  }
}

const push = Array.prototype.push.uncurrying();

let a = {};
push(a, 1, 2, 3);
console.log(a); // 输出 [1, 2, 3]

上面的示例代码中，我们在Function.prototype中新建了一个uncurrying方法，该方法返回一个接受无参的函数。并且在函数内部，使用原型方法call将this绑定到self上并调用。

2.2 方法2

另一种反柯里化的方式是使用闭包创建一个返回函数的函数。在这个返回函数中，我们将对象方法作为this绑定的函数并执行它。

function uncurrying(fn) {
  return function() {
    return fn.apply(arguments[0], [].slice.call(arguments, 1));
  }
}

const push = uncurrying(Array.prototype.push);

let a = {};
push(a, 1, 2, 3);
console.log(a); // 输出 [1, 2, 3]

上面的示例代码中，我们创建了一个uncurrying函数，该函数返回一个接受一个函数参数的闭包函数。在返回函数中，我们将调用函数apply方法将arguments的第一个参数this绑定并解析剩余的参数，最后再返回结果。

示例

示例1

为了更好地理解反柯里化的概念，我们可以使用一个具体的例子。

function a() {
  console.log(this.name);
}

const obj = { name: 'object' };
const objA = obj.a = a;

objA(); // 输出 'object'

在上述代码中，我们定义一个函数a并将它复制到对象obj的a属性中。当我们调用objA()方法时，a函数内部的this指向了obj对象，最终输出 "object"。

但是，在某些情况下，我们需要以更通用的方式使用函数。这时，我们可以使用反柯里化对函数进行转换。

Function.prototype.uncurrying = function() {
  const self = this;
  return function() {
    return Function.prototype.call.apply(self, arguments);
  }
}

const obj = { name: 'object' };
const objA = obj.a = a.uncurrying();

objA(); // 输出 'object'

在上述代码中，我们同时使用了反柯里化和方法1。a函数经过反柯里化后，成为了一个普通的函数，不再需要被绑定在obj对象的a属性中。

示例2

另外一个例子是在延迟执行中使用反柯里化。

const _ = {};

_.delay = function(func, wait) {
  const args = [].slice.call(arguments, 2);
  setTimeout(function() {
    func.apply(null, args);
  }, wait);
};

const f = function() {
  console.log(this.name);
}.uncurrying();

const obj = {
  name: 'object',
  f: f
};

_.delay(obj.f, 3000); // 输出 'object'

在上述代码中，我们使用了反柯里化对函数f进行转换。最终我们将函数传递给delay方法，并将this绑定到obj对象上。在3秒之后，输出 "object"。