作为参数的函数 匿名函数 高阶函数

作为参数的函数

函数作为一个变量传入到了另一个函数中，那么该作为参数的函数的类型是:function1，即:(参数类型) => 返回类型

object FunParameter {
def main(args: Array[String]): Unit = {
def plus(x: Int) = 3 + x
//说明
val result1 = Array(1, 2, 3, 4).map(plus(_)) println(result1.mkString(",")) //(4,5,6,7)
//说明
//1. 在 scala 中，函数也是有类型，比如 plus 就是 <function1> println("puls 的函数类型 function1" + (plus _))
} }

1) map(plus(_)) 中的 plus(_) 就是将 plus 这个函数当做一个参数传给了 map，_这里代表从集合中 遍历出来的一个元素。

plus _ 则代表的是将函数的引用传入，跟plus(_) 含义不一样。
2) plus(_) 这里也可以写成 plus 表示对 Array(1,2,3,4) 遍历，将每次遍历的元素传给 plus 的 x 3) 进行 3 + x 运算后，返回新的 Int ，并加入到新的集合 result1 中
4) def map[B, That](f: A => B) 的声明中的 f: A => B 一个函数

匿名函数

没有名字的函数就是匿名函数，可以通过函数表达式来设置匿名函数

object AnonymouseFunction {
def main(args: Array[String]): Unit = {
//对匿名函数的说明
//1. 不需要写 def 函数名
//2. 不需要写返回类型，使用类型推导 //3. = 变成 =>
//4. 如果有多行，则使用{} 包括
val triple = (x: Double) => {
println("x=" + x)
3*x }
println("triple" + triple(3)) // 9.0
} }


val f1 = (n1: Int, n2: Int ) => { println("匿名函数被调用");1 + n2}
println("f1 类型=" + f1) println(f1(10, 30))

高阶函数

能够接受函数作为参数的函数，叫做高阶函数 (higher-order function)。可使应用程序更加健壮

object HigherOrderFunction {
  def main(args: Array[String]): Unit = {
    def test(f: Double => Double, f2: Double => Int, n1: Double) {
      f(f2(n1)) // f(0)
    }

    //sum 是接收一个 Double,返回一个 Double
    def sum(d: Double): Double = {
      d + d
    }

    def mod(d: Double): Int = {
      d.toInt % 2
    }

    val res = test(sum, mod, 5.0) // println("res=" + res) // 2.0
    println(res)
  }
}

匿名函数当函数当返回参数，函数当柯里化

object HigherOrderFunction2 {
  def main(args: Array[String]): Unit = {
    //说明
    //1. minusxy 是高阶函数,因为它返回匿名函数 //2. 返回的匿名函数 (y: Int) => x - y
    //3. 返回的匿名函数可以使用变量接收
    def minusxy(x: Int) = { (y: Int) => x - y //匿名函数 
    }

    //分步执行
    //f1 就是 (y:Int)=>3-y
    val f1 = minusxy(3)
    println("f1 的类型=" + f1)
    println(f1(1)) // 2 println(f1(9)) // -6
    //也可以一步到位的调用 
    println(minusxy(4)(9)) // -5
  }
}