javascript闭包和柯里化的深度解释


javascript拥有简洁的表达,使你可以专心于算法攻略。就好像黑白机上的闯关游戏,你拾取了宝剑,只需要不停地点A就可以了。你唯一要思考的就是如何不停地跳躲Boss的大招。

javascript成为浏览器的唯一语言,并且成为世界标准许多年,是有非常重要的理由的。《JavaScript: The Good Parts》做出了非常清晰地解释。

JavaScript:The World's Most Misunderstood Programming Language

然而,想要掌握javascript的正确编写方式并不容易。尤其是当你从教科书开始的时候,大部分给你的信息都是面向对象的东西:newprototypeclassextend,...

这些都不是正确编写javascript的方式,当然你可以这么做,但是你会恨上javascript,这样编写的感觉会让你觉得你在写java却不能拥有java一样的计算速度。

想要喜欢上javascript并且享受programming的快感,你需要放下一切对面向对象的理解,走进函数和求值的世界。你的所有代码只有function,这是简单的并且灵活的。


什么是函数?


如同数学界,函数function即代表了求值。然而,从另一个角度来讲,函数function也是值:

g = f(x)

我们认为g是一个值,来自f函数的计算,输入是x。然而,我们可以把值g作为一个函数,输入y,再次进行求值:

v = g(y)

把函数function赋予值的定位,可以使计算充满了灵活:

v = f(x)(y) = k(f, x, y)



什么是柯里化Currying?


f(x)(y)就是柯里化:使用函数f,输入x,计算,获得一个新的函数,再次输入y,计算,获取结果。f(x)(y)(z)(a)(b)(c),你完全可以写这样的函数。每次进行一次计算时,都返回一个新的函数。当然,你也可以写成这样的方式g(x, y, z, a, b, c)

function f (x) {
  return function (y) {
    return function (z) {
      return function (a) {
        return function (b) {
          return function (c) {
              console.log(x  + y + z + a + b + c);
          };
        };
      };
    };
  };
}

计算6个数字相加为什么要费这么大的周折?原因在于可以获得拥有内部记忆的函数: g = f(1)可以获得一个新的函数g。可以使用g编写多种不同的求值组合,而使第一个输入始终是1:

g(2)(3)(4)(5)(6);
g(3)(3)(4)(5)(6);
g(9)(9)(1)(2)(3);



什么是闭包Closure?


上边的函数就是闭包,确切的说,利用柯里化机制的函数function就是闭包函数。通过柯里化,获取一个拥有记忆功能的函数,简化后续的多种计算操作,这就是闭包。

function move(start) {
  var pos = start;
  return function () {
    console.log('Move to ' + (pos += 2) + '.');
  }
}

var move_next = move(6); 
move_next();  // Move to 8. 
move_next();  // Move to 10.



进阶:记忆


下面我们来看一下经典的缓存函数。开始有两个输入参数,一个是数组sets,一个是求值函数f

function memorize(sets, f) {
    var cache = {}; 
    return function (x) { 
        console.log('cache: %j', cache);
        return x in cache
               ? cache[x]
               : cache[x] = f(sets[x]);
    }
}

首先,我们在memorize的内部空间放置了一个记忆单元:cache,是一个Object类型,这样我们就可以用来存储任何我们想要的数据。Object类型可以看做是简化并且统一版的C语言中的struct:不需要考虑链接,不需要考虑类型,解释器会为你完成。

接下来,我们运用柯里化返回一个函数。这个函数有一个输入参数,指定了sets数组中的第几项进行计算。我们首先使用console.log打印当时内部空间的记忆单元cache的值,然后判断输入参数是不是在cache的键中。如果已经存在,直接返回记忆的内容,如果没有存在,使用函数f对输入参数sets[x]求值,然后把结果记忆到内部空间的记忆单元:cache中。

通过记忆,每次使用求值函数f计算后,都将结果保存在cache中,这样可以极大的降低重复计算:

var g = memorize([1000, 2000, 3000], function (x) { return x * x; });
g(0);  // cache: {},计算1000*1000
g(0);  // cache: {"0":1000000},来自记忆
g(0);  // cache: {"0":1000000},来自记忆
g(0);  // cache: {"0":1000000},来自记忆
g(1);  // cache: {"0":1000000},计算2000*2000
g(1);  // cache: {"0":1000000, "1":4000000},来自记忆
g(1);  // cache: {"0":1000000, "1":4000000},来自记忆



进阶:让函数循环起来


我们已经看到了柯里化(闭包)的好处和妙处,同时这些也都是函数function概念帮助我们完成了一系列繁琐的工作。下面我们将把函数function运用到循环中,进一步了解函数的好处和妙处。

function map(sets, f) {
  var i = 0, len = sets.length, result = [], val;  
  while (i < len) {
    val = f(sets[i]);
    result.push(val);
    ++i;
  }
  return result;
}

函数map使用两个输入参数:一个数组sets,一个求值函数f

首先,我们计算数组sets的长度,设定一个位置符i。然后对sets进行循环的操作,把其中的sets[i]进行求值,然后压入result中,最后将result返回。

通过这样的设定,我们使函数f在循环中运转。我们还可以进一步,再放入一个条件函数,只有条件成功的时候才进行求值:

function map(sets, condf, f) {
  var i = 0, len = sets.length, result = [], val, set;  
  while (i < len) {
    set = sets[i];
    if (condf(set)) {
      val = f(set);
      result.push(val);
    }
    ++i;
  }
  return result;
}

上边我们刚刚讨论了柯里化,所以把这个函数改一改,变成柯里化:

function map(sets, f) {
  return function (condf) {
    var i = 0, len = sets.length, result = [], val, set;  
    while (i < len) {
      set = sets[i];
      if (condf(set)) {
        val = f(set);
        result.push(val);
      }
      ++i;
    }
    return result;
  }
}

现在,函数map在循环中进一步增加了灵活性,我们可以这样方便的使用:

var mymap = map([1,2,3,4,5,6], function (set) { return set + 1; });
mymap(function (set) { return set % 2 === 0 });  // 偶数
mymap(function (set) { return set > 9 });  // 大于9

// 如果你熟悉Ecmascript 6,那么代码会非常有趣
var mymap = map([1,2,3,4,5,6], set => set + 1);
mymap(set => set % 2 === 0);  // 偶数
mymap(set => set > 9 );  // 大于9

→ 如何玩转闭包和柯里化

你可能感兴趣的:(javascript闭包和柯里化的深度解释)