Scala的闭包和柯里化

1、scala中的闭包：

闭包是指有权访问另外一个函数作用域中的变量的函数。可以理解为能够读取另一个函数作用域的变量的函数。

一个函数的函数体是一个新的函数，这个函数体函数是闭包（有权访问另外一个函数作用域中的变量）

闭包可以作为函数参数传递

val filterAllLogClasRdd = caseClassAllLogRdd.filter(filterCondition(_, validProjectsSetBroad.value))

变量不在函数作用域中时，还可以访问。闭包可以作为变量或者返回值

def mulBy(factor:Double) = (x:Double) => factor * x

　　　　　　//开始调用

　　　　　　val tripe = mulBy(3)

　　　　　　val half = mulBy(0.5)

　　　　　　println(tripe(14) + " " + half(14))

　　　　这就是一个闭包

2、scala中的柯里化

//柯里化的前提是scala支持闭包，才会有柯里化

def add(x:Int)(y:Int) = x + y实际演化成了def add(x:Int)=(y:Int)=>x+y（后者用到了闭包）

柯里化(Currying)指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数。

实例

首先我们定义一个函数:

def add(x:Int,y:Int)=x+y

那么我们应用的时候，应该是这样用：add(1,2)

现在我们把这个函数变一下形：

def add(x:Int)(y:Int) = x + y

 

那么我们应用的时候，应该是这样用：add(1)(2),最后结果都一样是3，这种方式（过程）就叫柯里化。

实现过程

add(1)(2) 实际上是依次调用两个普通函数（非柯里化函数），第一次调用使用一个参数 x，返回一个函数类型的值，第二次使用参数y调用这个函数类型的值。

实质上最先演变成这样一个方法：

def add(x:Int)=(y:Int)=>x+y

那么这个函数是什么意思呢？ 接收一个x为参数，返回一个匿名函数，该匿名函数的定义是：接收一个Int型参数y，函数体为x+y。现在我们来对这个方法进行调用。

 

val result = add(1) 

返回一个result，那result的值应该是一个匿名函数：(y:Int)=>1+y

所以为了得到结果，我们继续调用result。

val sum = result(2)

最后打印出来的结果就是3。

完整实例

下面是一个完整实例：

object Test {
   def main(args: Array[String]) {
      val str1:String = "Hello, "
      val str2:String = "Scala!"
      println( "str1 + str2 = " +  strcat(str1)(str2) )
   }

   def strcat(s1: String)(s2: String) = {
      s1 + s2
   }
}
执行以上代码，输出结果为：

$ scalac Test.scala
$ scala Test
str1 + str2 = Hello, Scala!

案例二

def aggregate[U](zeroValue: U)(seqOp: (U, T) ⇒ U, combOp: (U, U) ⇒ U)(implicit arg0: ClassTag[U]): U

##第一个分区中包含5,4,3,2,1

##第二个分区中包含10,9,8,7,6

scala> rdd1.aggregate(1)(
     |           {(x : Int,y : Int) => x + y}, 
     |           {(a : Int,b : Int) => a + b}
     |     )
res17: Int = 58