函数和闭包

一、函数

1.1 函数与方法

Scala 中函数与方法的区别非常小，如果函数作为某个对象的成员，这样的函数被称为方法，否则就是一个正常的函数。

  1. // 定义方法
  2. def multi1(x:Int) = {x * x}
  3. // 定义函数
  4. val multi2 = (x: Int) => {x * x}
  6. println(multi1(3)) //输出 9
  7. println(multi2(3)) //输出 9

也可以使用 def 定义函数：

  1. def multi3 = (x: Int) => {x * x}
  2. println(multi3(3))  //输出 9

multi2 和 multi3 本质上没有区别，这是因为函数是一等公民，val multi2 = (x: Int) => {x * x} 这个语句相当于是使用 def 预先定义了函数，之后赋值给变量 multi2。

1.2 函数类型

上面我们说过 multi2 和 multi3 本质上是一样的，那么作为函数它们是什么类型的？两者的类型实际上都是 Int => Int，前面一个 Int 代表输入参数类型，后面一个 Int 代表返回值类型。

  1. scala> val multi2 = (x: Int) => {x * x}
  2. multi2: Int => Int = $$Lambda$1092/594363215@1dd1a777
  4. scala> def multi3 = (x: Int) => {x * x}
  5. multi3: Int => Int
  7. // 如果有多个参数，则类型为：（参数类型，参数类型 ...）=>返回值类型
  8. scala> val multi4 = (x: Int,name: String) => {name + x * x }
  9. multi4: (Int, String) => String = $$Lambda$1093/1039732747@2eb4fe7

1.3 一等公民&匿名函数

在 Scala 中函数是一等公民，这意味着不仅可以定义函数并调用它们，还可以将它们作为值进行传递：

  1. import scala.math.ceil
  2. object ScalaApp extends App {
  3.   // 将函数 ceil 赋值给变量 fun,使用下划线 (_) 指明是 ceil 函数但不传递参数
  4.   val fun = ceil _
  5.   println(fun(2.3456))  //输出 3.0
  7. }

在 Scala 中你不必给每一个函数都命名，如 (x: Int) => 3 * x 就是一个匿名函数：

  1. object ScalaApp extends App {
  2.   // 1.匿名函数
  3.   (x: Int) => 3 * x
  4.   // 2.具名函数
  5.   val fun = (x: Int) => 3 * x
  6.   // 3.直接使用匿名函数
  7.   val array01 = Array(1, 2, 3).map((x: Int) => 3 * x)  
  8.   // 4.使用占位符简写匿名函数
  9.   val array02 = Array(1, 2, 3).map(_ * 3)
  10.   // 5.使用具名函数
  11.   val array03 = Array(1, 2, 3).map(fun)
  13. }

1.4 特殊的函数表达式

1. 可变长度参数列表

在 Java 中如果你想要传递可变长度的参数，需要使用 String ...args 这种形式，Scala 中等效的表达为 args: String*。

  1. object ScalaApp extends App {
  2.   def echo(args: String*): Unit = {
  3.     for (arg <- args) println(arg)
  4.   }
  5.   echo("spark","hadoop","flink")
  6. }
  7. // 输出
  8. spark
  9. hadoop
  10. flink

2. 传递具名参数

向函数传递参数时候可以指定具体的参数名。

  1. object ScalaApp extends App {
  3.   def detail(name: String, age: Int): Unit = println(name + ":" + age)
  5.   // 1.按照参数定义的顺序传入
  6.   detail("heibaiying", 12)
  7.   // 2.传递参数的时候指定具体的名称,则不必遵循定义的顺序
  8.   detail(age = 12, name = "heibaiying")
  10. }

3. 默认值参数

在定义函数时，可以为参数指定默认值。

  1. object ScalaApp extends App {
  3.   def detail(name: String, age: Int = 88): Unit = println(name + ":" + age)
  5.   // 如果没有传递 age 值,则使用默认值
  6.   detail("heibaiying")
  7.   detail("heibaiying", 12)
  9. }

二、闭包

2.1 闭包的定义

  1. var more = 10
  2. // addMore 一个闭包函数:因为其捕获了自由变量 more 从而闭合了该函数字面量
  3. val addMore = (x: Int) => x + more

如上函数 addMore 中有两个变量 x 和 more:

  • x : 是一个绑定变量 (bound variable)，因为其是该函数的入参，在函数的上下文中有明确的定义；
  • more : 是一个自由变量 (free variable)，因为函数字面量本生并没有给 more 赋予任何含义。

按照定义：在创建函数时，如果需要捕获自由变量，那么包含指向被捕获变量的引用的函数就被称为闭包函数。

2.2 修改自由变量

这里需要注意的是，闭包捕获的是变量本身，即是对变量本身的引用，这意味着：

  • 闭包外部对自由变量的修改，在闭包内部是可见的；
  • 闭包内部对自由变量的修改，在闭包外部也是可见的。
  1. // 声明 more 变量
  2. scala> var more = 10
  3. more: Int = 10
  5. // more 变量必须已经被声明，否则下面的语句会报错
  6. scala> val addMore = (x: Int) => {x + more}
  7. addMore: Int => Int = $$Lambda$1076/1844473121@876c4f0
  9. scala> addMore(10)
  10. res7: Int = 20
  12. // 注意这里是给 more 变量赋值，而不是重新声明 more 变量
  13. scala> more=1000
  14. more: Int = 1000
  16. scala> addMore(10)
  17. res8: Int = 1010

2.3 自由变量多副本

自由变量可能随着程序的改变而改变，从而产生多个副本，但是闭包永远指向创建时候有效的那个变量副本。

  1. // 第一次声明 more 变量
  2. scala> var more = 10
  3. more: Int = 10
  5. // 创建闭包函数
  6. scala> val addMore10 = (x: Int) => {x + more}
  7. addMore10: Int => Int = $$Lambda$1077/1144251618@1bdaa13c
  9. // 调用闭包函数
  10. scala> addMore10(9)
  11. res9: Int = 19
  13. // 重新声明 more 变量
  14. scala> var more = 100
  15. more: Int = 100
  17. // 创建新的闭包函数
  18. scala> val addMore100 = (x: Int) => {x + more}
  19. addMore100: Int => Int = $$Lambda$1078/626955849@4d0be2ac
  21. // 引用的是重新声明 more 变量
  22. scala> addMore100(9)
  23. res10: Int = 109
  25. // 引用的还是第一次声明的 more 变量
  26. scala> addMore10(9)
  27. res11: Int = 19
  29. // 对于全局而言 more 还是 100
  30. scala> more
  31. res12: Int = 100

从上面的示例可以看出重新声明 more 后，全局的 more 的值是 100，但是对于闭包函数 addMore10 还是引用的是值为 10 的 more，这是由虚拟机来实现的，虚拟机会保证 more 变量在重新声明后，原来的被捕获的变量副本继续在堆上保持存活。

三、高阶函数

3.1 使用函数作为参数

定义函数时候支持传入函数作为参数，此时新定义的函数被称为高阶函数。

  1. object ScalaApp extends App {
  3.   // 1.定义函数
  4.   def square = (x: Int) => {
  5.     x * x
  6.   }
  8.   // 2.定义高阶函数: 第一个参数是类型为 Int => Int 的函数
  9.   def multi(fun: Int => Int, x: Int) = {
  10.     fun(x) * 100
  11.   }
  13.   // 3.传入具名函数
  14.   println(multi(square, 5)) // 输出 2500
  16.   // 4.传入匿名函数
  17.   println(multi(_ * 100, 5)) // 输出 50000
  19. }

3.2 函数柯里化

我们上面定义的函数都只支持一个参数列表，而柯里化函数则支持多个参数列表。柯里化指的是将原来接受两个参数的函数变成接受一个参数的函数的过程。新的函数以原有第二个参数作为参数。

  1. object ScalaApp extends App {
  2.   // 定义柯里化函数
  3.   def curriedSum(x: Int)(y: Int) = x + y
  4.   println(curriedSum(2)(3)) //输出 5
  5. }

这里当你调用 curriedSum 时候，实际上是连着做了两次传统的函数调用，实际执行的柯里化过程如下：

  • 第一次调用接收一个名为 x 的 Int 型参数，返回一个用于第二次调用的函数，假设 x 为 2，则返回函数 2+y；
  • 返回的函数接收参数 y，并计算并返回值 2+3 的值。

想要获得柯里化的中间返回的函数其实也比较简单：

  1. object ScalaApp extends App {
  2.   // 定义柯里化函数
  3.   def curriedSum(x: Int)(y: Int) = x + y
  4.   println(curriedSum(2)(3)) //输出 5
  6.   // 获取传入值为 10 返回的中间函数 10 + y
  7.   val plus: Int => Int = curriedSum(10)_
  8.   println(plus(3)) //输出值 13
  9. }

柯里化支持多个参数列表，多个参数按照从左到右的顺序依次执行柯里化操作：

  1. object ScalaApp extends App {
  2.   // 定义柯里化函数
  3.   def curriedSum(x: Int)(y: Int)(z: String) = x + y + z
  4.   println(curriedSum(2)(3)("name")) // 输出 5name
  6. }

参考资料

  1. Martin Odersky . Scala 编程 (第 3 版)[M] . 电子工业出版社 . 2018-1-1
  2. 凯.S.霍斯特曼 . 快学 Scala(第 2 版)[M] . 电子工业出版社 . 2017-7