函数与闭包

Posted 2020-08-18

scala中函数4种的表现形式{

　　对象中的函数，

　　内嵌在函数的函数，

　　函数字面量，

　　函数值

｝

1）对象中的函数

　　不解释。

2）内嵌在函数中函数

　　控制helper函数的方式 一般限制访问级别private。scala可以通过内嵌方式控制（前者同样生效），类似方法中的变量（本地变量）。

　　本地函数可以访问外层的函数参数等。scala的嵌套和作用域思想是什么？？？为何嵌套和作用域的思想对于函数是一等公民的语言中及其重要？？？

3）一等函数：函数字面量与函数值

　　什么是函数字面量？基本类型绝大部分都可以通过字面量来表示，比如 4，12 表示一个int值 2.3 表示double值等，函数也可以通过这种字面量来表示一个值（函数值）。而def形式是在定义一个函数，并不是一个值。再例如 val a:Int = 3定义Int类型的a，5是Int类型的值。

　　一等函数，不仅可以通过定义和调用使用它们，还可以写成函数字面量，当作值来传递。

　　函数字面量被编译进类，并在运行时形成对象（及函数值）。

　　函数字面量和函数值的区别：源码与运行时。如同蓝图与建筑，类与对象。（这里函数字面量就是类，函数值就是对象）

　　函数值既是对象又是函数

val increase = (x: Int) => x + 1  //像对象一样传值给变量
increase(10)    //像函数一样调用参数

 　　函数字面量中的方法部分可以用{}

val increase = (x: Int) => {
    val y = x + 1
    y +1
}

 　　既然函数作为值，就可以传递给函数，形成高阶函数。

　　栗子：集合类中的两个方法foreach与filter同是以函数作为参数的函数。

 

 

目标类型化 缩减函数字面量的无用字符？？

占位符 _ 一个占位符只能表示一个函数参数，且这个函数参数在函数体中只能被用到一次。

　　栗子：(x:Int) => x+1    写成  _ + 1 

　　　　　(x:Int,y:Int) => x+y   写成  (_:Int) + (_:Int) 不简洁，但是如果是某一函数调用两个参数的函数时，可以通过类型推断（？）直接写成xx.yy(_ + _) 

 

部分应用函数

1.通过部分应用函数将def转换为函数值

def sum(a:Int,b:Int,c:Int) = a+b+c
val temp_sum = sum _

2.当指定了一些函数参数时候 部分应用函数的占位符还需要添加类型

scala> val mysum = sum(1,_,_)
<console>:11: error: missing parameter type for expanded function ((x$1, x$2) => sum(1, x$1, x$2))
       val mysum = sum(1,_,_)
                         ^
<console>:11: error: missing parameter type for expanded function ((x$1: <error>, x$2) => sum(1, x$1, x$2))
       val mysum = sum(1,_,_)
                           ^

scala> val mysum = sum(1,_:Int,_:Int)
mysum: (Int, Int) => Int = <function2>

 3. 1和2的原理是编译器将函数编译成类，mysum(2,3)其实在调用mysum.apply(2,3)。 apply方法？

 

闭包

自由变量与绑定变量 

闭包是函数值。通过自由变量创建的函数值称为闭包。

闭包捕获自由变量而不是变量所指向的值。所以变量的改变会影响闭包，同样闭包的也能改变自由变量。

scala> var s = 10
s: Int = 10

scala> val mydef = (a:Int) => a + s
mydef: Int => Int = <function1>

scala> mydef(1)
res0: Int = 11

scala> s = 12
s: Int = 12

scala> mydef(1)
res1: Int = 13

 

scala> val sumList = List(1,2,-1,-2,4)
sumList: List[Int] = List(1, 2, -1, -2, 4)

scala> var sum  = 0
sum: Int = 0

scala> sumList.foreach(sum += _)

scala> sum
res3: Int = 4

 

个人理解 当闭包的自由变量是函数参数时。每一次函数传参都会形成新的闭包。由于函数参数是val 所以函数体内形成的闭包的自由变量恒定。

 

重复参数

定义重复参数只要在类型后面加*

scala> def sum(a:Int*) = a.sum
sum: (a: Int*)Int

scala> sum(1)
res4: Int = 1

scala> sum(1,3,4)
res5: Int = 8

形成的类型其实是数组。所以可以调用数组sum方法。

然而不能传数组给sum函数，需要将数组转为arr: _*形式（这种形式是告诉编译器把数组中的每一个参数传给函数）

scala> val arr = Array(1,2,3,4,5,6,7,8,9)
arr: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> sum(arr)
<console>:13: error: type mismatch;
 found   : Array[Int]
 required: Int
       sum(arr)
           ^

scala> sum(arr: _*)
res7: Int = 45

 

指定名字的调用参数

scala> def speed(distance: Float, time: Float): Float = distance / time
speed: (distance: Float, time: Float)Float

scala> speed(100, 10)
res9: Float = 10.0

scala> speed(distance=100,time=10)
res10: Float = 10.0

scala> speed(time=10,distance=100)
res11: Float = 10.0

 一般常用方式是默认顺序＋指定参数 配合使用 （没记错的话，Spark中比较常见）

 

默认的参数值

scala> def printTime(out:java.io.PrintStream = Console.out) = out.println("time = " + System.currentTimeMillis())
printTime: (out: java.io.PrintStream)Unit

scala> printTime()
time = 1478591319201

scala> printTime(Console.err)
time = 1478591327893

 然而默认的参数值常常与指定参数配合使用 

scala> def printTime2(out: java.io.PrintStream = Console.out, divisor: Int = 1) = out.println("time = " + System.currentTimeMillis()/divisor)
printTime2: (out: java.io.PrintStream, divisor: Int)Unit

scala> printTime2(out = Console.err)
time = 1478591428641

scala> printTime2(divisor = 1000)
time = 1478591435

 

 

 

 

 

尾递归：scala编译器对尾递归进行了特殊处理，使得与指令形式的while效率相当。但由于JVM的限制使得尾递归并不能完全支持（间接尾递归，函数值的尾递归），支持直接尾递归。