JavaScript函数式编程（1）：基本思想

1 函数式编程简介

函数式编程是和传统命令式编程区分的一种编程思想，“在函数式编程语言中，函数是第一类的对象，也就是说，函数 不依赖于任何其他的对象而可以独立存在，而在面向对象的语言中，函数 ( 方法 ) 是依附于对象的，属于对象的一部分。这一点决定了函数在函数式语言中的一些特别的性质，比如作为传出 / 传入参数，作为一个普通的变量等。[1]”

函数式编程思想的源头可以追溯到 20 世纪 30 年代，数学家阿隆左 . 丘奇在进行一项关于问题的可计算性的研究，也就是后来的 lambda 演算。lambda 演算的本质为 一切皆函数，函数可以作为另外一个函数的输出或者 / 和输入，一系列的函数使用最终会形成一个表达式链，这个表达式链可以最终求得一个值，而这个过程，即为计算的本质。

然而，这种思想在当时的硬件基础上很难实现，历史最终选择了同丘奇的 lambda 理论平行的另一种数学理论：图灵机作为计算理论，而采取另一位科学家冯 . 诺依曼的计算机结构，并最终被实现为硬件。由于第一台计算机即为冯 . 诺依曼的程序存储结构，因此运行在此平台的程序也继承了这种基因，程序设计语言如 C/Pascal 等都在一定程度上依赖于此体系。

到了 20 世纪 50 年代，一位 MIT 的教授 John McCarthy 在冯 . 诺依曼体系的机器上成功的实现了 lambda 理论，取名为 LISP(LISt Processor), 至此函数式编程语言便开始活跃于计算机科学领域。

2 JavaScript中的函数式编程思想

2.1）匿名函数

在函数式编程语言中，函数是可以没有名字的，匿名函数通常表示：“可以完成某件事的一块代码”。这种表达在很多场合是有用的，因为我们有时需要用函数完成某件事，但是这个函数可能只是临时性的，那就没有理由专门为其生成一个顶层的函数对象。

    //自定义map()
    function map(array, func){ 
        var res = []; 
        for ( var i = 0, len = array.length; i < len; i++){ 
                res.push(func(array[i])); 
            } 
        return res; 
    } 
    //匿名函数
    var mapped = map([1, 3, 5, 7, 8],  function (n){ 
        return n = n + 1; 
    }); 
    alert(mapped); //2,4,6,8,9// 对数组 [1,3,5,7,8] 中每一个元素加 1

2.2）柯里化

是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，或者说创建一个已经预先包含一个参数的函数，这其中会使用到闭包。
先来一个不是类似克里化的例子：

function add(num1, num2){
        return num1 + num2;
    }
    function curriedAdd(num2){
        return add(5, num2);
    }
    alert(add(2, 3)); //5
    alert(curriedAdd(3)); //8

这里的curriedAdd函数类似克里化，因为它固定了函数的一个参数。
下面看一个真正的函数克里化：

  //传入的参数不止fn一个，但是只有fn显式用到，所以明确给出

    function curry(fn){
            var args = Array.prototype.slice.call(arguments, 1);//得到外部函数参数
            return function(){
            var innerArgs = Array.prototype.slice.call(arguments);//得到内部函数参数
            var finalArgs = args.concat(innerArgs);//参数合并得到整体参数数组
            return fn.apply(null, finalArgs);//对整体参数数组运用函数fn
        };
    }
    function add(num1, num2){
        return num1 + num2;
    }
    var curriedAdd = curry(add, 5);
    alert(curriedAdd(3)); //8

根据上述实例，克里化一般通过curry()函数动态实现，curry()函数的主要工作就是将被返回函数的参数进行排序。 curry()的第一个参数是要进行柯里化的函数，其他参数是要传入的值。为了获取第一个参数之后的所有参数，在 arguments 对象上调用了 slice()方法，并传入参数 1 表示被返回的数组包含从第二个参数开始的所有参数。然后 args 数组包含了来自外部函数的参数。在内部函数中，创建了 innerArgs 数组用来存放所有传入的参数（又一次用到了 slice()）。有了存放来自外部函数和内部函数的参数数组后，就可以使用 concat()方法将它们组合为 finalArgs，然后使用 apply()将结果传递给该函数。注意这个函数并没有考虑到执行环境，所以调用 apply()时第一个参数是 null。

2.3）高阶函数

即为对函数的进一步抽象，map(array, func) 的表达式已经表明，将 func 函数作用于 array 中的每一个元素，最终返回一个新的 array，应该注意的是，map 对 array 和 func 的实现是没有任何预先的假设的（抽象），因此称之为“高阶”函数。

    function map(array, func){ 
      var res = []; 
      for ( var i = 0, len = array.length; i < len; i++){ 
             res.push(func(array[i])); 
         } 
          return res; 
     } 
     var mapped = map([1, 3, 5, 7, 8],  function (n){ 
          return n = n + 1; 
     }); 
    alert(mapped); 
    
    var mapped2 = map(["one", "two" , "three", "four"], 
      function (item){ 
          return "("+item+")"; 
     }); 
    alert(mapped2);

mapped 和 mapped2 均调用了 map，但是得到了截然不同的结果，因为 map 的参数本身已经进行了一次抽象，map 函数做的是第二次抽象，高阶的“阶”可以理解为抽象的层次。

2.4）闭包

闭包已经在另一篇文章《闭包：私有化变量》中介绍过，与闭包有关的垃圾回收机制在《垃圾回收机制——总结自《JavaScript高级程序设计》也有详细介绍，因此这里仅仅简要说明闭包。
当在一个函数 outter 内部定义另一个函数 inner，而 inner 又引用了 outter 作用域内的变量，在 outter 之外使用 inner 函数，则形成了闭包。

<script type="text/javascript">
function outter(){ 
    var n = 0; 
    return function (){ 
        return n++; 
    } 
 } 

 var o1 = outter(); 
 o1();//n == 0 
 o1();//n == 1 
 alert(o1());//n == 2 
  var o2 = outter(); 
 o2();//n == 0 
 alert(o2());//n == 1
</script>   

匿名函数 function(){return n++;} 中包含对 outter 的局部变量 n 的引用，因此当 outter 返回时，n 的值被保留 ( 不会被垃圾回收机制回收 )，持续调用 o1()，将会改变 n 的值。而 o2 的值并不会随着 o1() 被调用而改变，第一次调用 o2 会得到 n==0 的结果，用面向对象的术语来说，就是 o1 和 o2 为不同的 实例，互不干涉。
闭包实例2：

//创建一个对象并压入数组
var outter = [];
function clouseTest () {
var array = ["one", "two", "three", "four"];
for ( var i = 0; i < array.length;i++){

var x = {}; 
x.no = i; 
x.text = array[i]; 
 x.invoke =  function (){ 
     alert(i); 
    } 
outter.push(x); 
} 

}
//执行函数并调用每个数组元素对应的对象的方法
clouseTest();// 调用这个函数，向 outter 数组中添加对象
for ( var i = 0, len = outter.length; i < len; i++){

outter[i].invoke(); //4,4,4,4

}

由于 i 是闭包中的局部变量，for 循环最后退出时的值为 4，因此调用 outter 中的每个元素都会得到 4。
修正过后的闭包：

    <script type="text/javascript">
    //创建一个对象并压入数组
    var outter = []; 
    function clouseTest () { 
    var array = ["one", "two", "three", "four"]; 
    for ( var i = 0; i < array.length;i++){ 
        var x = {}; 
        x.no = i; 
        x.text = array[i]; 
        //返回匿名函数，匿名函数中包含一个闭包，后续的括号表示立即执行
         x.invoke =  function (no){ 
              return function (){ 
                     alert(no); 
                 } 
             }(i); //这个i是匿名函数的参数，会赋值给匿名函数的参数no，这个i导致了不同的no副本
         outter.push(x); 
     }     
    }
     //执行函数并调用每个数组元素对应的对象的方法
    clouseTest();// 调用这个函数，向 outter 数组中添加对象
    for ( var i = 0, len = outter.length; i < len; i++){ 
        outter[i].invoke(); //1,2,3,4
    }
</script>   

[1] http://www.ibm.com/developerw...