Scala 闭包 与 柯力化

Scala 闭包：

闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。

闭包通常来讲可以简单的认为是可以访问一个函数里面局部变量的另外一个函数。

如下面这段匿名的函数：

val multiplier = (i:Int) => i * 10  

函数体内有一个变量 i，它作为函数的一个参数。如下面的另一段代码：

val multiplier = (i:Int) => i * factor

在 multiplier 中有两个变量：i 和 factor。其中的一个 i 是函数的形式参数，在 multiplier 函数被调用时，i 被赋予一个新的值。然而，factor不是形式参数，而是自由变量，考虑下面代码：

var factor = 3  
val multiplier = (i:Int) => i * factor  

这里我们引入一个自由变量 factor，这个变量定义在函数外面。

这样定义的函数变量 multiplier 成为一个"闭包"，因为它引用到函数外面定义的变量，定义这个函数的过程是将这个自由变量捕获而构成一个封闭的函数。

完整实例：

object Test {  
   def main(args: Array[String]) {  
      println( "muliplier(1) value = " +  multiplier(1) )  
      println( "muliplier(2) value = " +  multiplier(2) )  
   }  
   var factor = 3  
   val multiplier = (i:Int) => i * factor  
}

执行以上代码，输出结果为：

muliplier(1) value = 3  
muliplier(2) value = 6  

下面我们来变换一下形式:

      把这匿名函数，赋值给有参函数.

  def mulBy(factor:Int) = (i:Int) => i * factor
 var mulBy3 = mulBy(3) //函数闭包
  var mulBy5 = mulBy(5) //函数闭包

完整代码:

object FunctionCloseOps {
  def main(args: Array[String]): Unit = {
    println(mulBy3(10))
    println(mulBy5(10))
    //再次进行简化
    println(mulBy(3)(10))  //函数柯里化 参数降维
    println(mulBy(5)(10))  //函数柯里化 参数降维

  }

  /**
   *  mulB 的函数体是通过一个匿名函数来实现的
   *  而该匿名函数(i:Int) => i * factor 需要一个参数 factor 并没有赋值，而factor来自于前面的函数
   *  程序执行过程:
   *    首先，在代码中定义了两个函数
   *       第一个是: mulBy
   *       第二个是匿名函数
   *   其次， 执行函数mulBy，并赋值给mulBy3，这样就把factor的值赋值成了 3 ，
   *   函数执行完毕后，就进行了弹栈  mulBy3 就实现了匿名函数
   *   然后 匿名函数 (i:Int) => i * factor 压栈，
   *   最后调用 mulBy3(10) 把 10 赋值给 i， 完成最终计算
   *
   *   在这过程中 匿名函数(i:Int) => i * factor  调用了一个不在其作用域范围的变量 factor,先弹栈，然后将factor保存到匿名函数
   *   最后匿名函数中调用了factor.
   *   我们把这种结构调用了闭包
   */
  def mulBy(factor:Int) = (i:Int) => i * factor
  var mulBy3 = mulBy(3) //函数闭包
  var mulBy5 = mulBy(5) //函数闭包
}