Scala入门第九篇--高阶函数

这次我们介绍Scala的高阶函数

---

高阶函数的概念

Scala混合了面向对象和函数式的特性，我们通常将可以作为参数传递到方法中的表达式叫做函数。在函数式编程语言中，函数是“头等公民”，高阶函数我们主要介绍：

• 作为值的函数
• 匿名函数
• 柯里化
• 闭包

作为值的函数

可以像任何其他数据类型一样被传递和操作的函数，每当你想要给算法传入具体动作时这个特性就会变得非常有用。

//给一个数组
scala> val arr1 = Array(1,2,3,4,5)
arr1: Array[Int] = Array(1, 2, 3, 4, 5)

//作为值得函数
scala> val fun1 = (x:Int)=>x*2
fun1: Int => Int = <function1>

//将函数作为值传递
scala> arr1.map(fun1)
res0: Array[Int] = Array(2, 4, 6, 8, 10)

定义函数时格式：val 变量名 = (输入参数类型和个数) => 函数实现和返回值类型

• “=”表示将函数赋给一个变量
• “=>”左面表示输入参数名称、类型和个数，右边表示函数的实现和返回值类型

匿名函数

在Scala中，你不需要给每一个函数命名，没有将函数赋给变量的函数叫做匿名函数。

//给一个数组
scala> val arr1 = Array(1,2,3,4,5)
arr1: Array[Int] = Array(1, 2, 3, 4, 5)

//匿名函数直接传入
scala> arr1.map(x =>x*10)
res1: Array[Int] = Array(10, 20, 30, 40, 50)

//更简洁的写法
scala> arr1.map(_*10)
res3: Array[Int] = Array(10, 20, 30, 40, 50)

柯里化

什么是柯里化？

柯里化(Currying)指的是把原来接受多个参数的函数变换成接受一个参数的函数过程，并且返回接受余下的参数且返回结果为一个新函数的技术。

//一个奇怪的方法，看起来像函数又像方法
scala> def m3 (x:Int)=(y:Int)=>x+y
m3: (x: Int)Int => Int

//传入参数1，彻底编程一个函数 val fun2 =(y :Int) =>1 +y
scala> val fun2=m3(1)
fun2: Int => Int = <function1>

//然后调用这个函数，并传递参数，得到结果
scala> fun2(2)
res7: Int = 3

• 一个普通的非柯里化的函数定义，实现一个加法函数：

//多参数函数
scala> def plainOldSum(x:Int,y:Int)=x+y
plainOldSum: (x: Int, y: Int)Int

scala> plainOldSum(1,2)
res0: Int = 3

• 使用“柯里化”技术来定义这个加法函数，原来函数使用一个参数列表，“柯里化”，把函数定义为多个参数列表：

scala> def curriedSum(x:Int)(y:Int)=x+y
curriedSum: (x: Int)(y: Int)Int

scala> curriedSum(1)(2)
res1: Int = 3

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

• 使用下面两个分开的定义在模拟curriedSum柯里化函数：

首先定义第一个函数：
scala> def first(x:Int)=(y:Int)=>x+y
first: (x: Int)Int => Int

然后我们使用参数1调用这个函数来生成第二个函数：
scala> val second =first(1)
second: Int => Int = <function1>
scala> second(2)
res2: Int = 3

总结 ：scala柯里化风格的使用可以简化主函数的复杂度，提高主函数的自闭性，提高功能上的可扩张性、灵活性。可以编写出更加抽象,功能化和高效的函数式代码。

闭包

什么是闭包

闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。
闭包通常来讲可以简单的认为是可以访问不在当前作用域范围内的一个函数。

例子

**
  * scala中的闭包
  * 闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。
  */
object ClosureDemo {
  def main(args: Array[String]): Unit = {
       val y=10
      //变量y不处于其有效作用域时,函数还能够对变量进行访问

        val add=(x:Int)=>{
          x+y
        }
    //在add中有两个变量：x和y。其中的一个x是函数的形式参数，
    //在add方法被调用时，x被赋予一个新的值。
    // 然而，y不是形式参数，而是自由变量
    println(add(5)) // 结果15
  }
}