Scala 函数\匿名函数 至简原则详解

Scala函数具有至简原则，遵循能省就省的风格，这也让我们这些初次接触到Scala编程的程序员在阅读程序是感到非常困惑，导出都是_，也不知道这些杠代表什么意思。因此将这些函数的简化原则记录了下来，供自己更好的记忆。

函数的简化原则包含普通函数的简化原则 和 匿名函数的简化原则，我将先介绍普通函数的简化原则，然后再介绍匿名函数的简化原则

　　普通函数至简原则：

标准函数的写法如下所示

（1）return 可以省略，Scala 会使用函数体的最后一行代码作为返回值

（2）如果函数体只有一行代码，可以省略花括号

（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）

（4）如果有 return，则不能省略返回值类型，必须指定

（5）如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用

（6）Scala 如果期望是无返回值类型，可以省略等号

（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加

（8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略

（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略

 //至简原则，能省则省
    //(1)return可以省略，scala会使用函数体的最后一行代码作为返回值
    def f1(s:String):String = {
      s+" cls"
    }

    //(2)如果函数体只有一行代码，可以省略花括号
    def f2(s:String):String = s+" cls"

    //(3)返回值类型如果能够推断出来，那么可以省略(:一起省略)
    def f3(s:String) = s+"cls"

    var s = f3("dh ai ")
    println(s)

    //(4)如果有return，那么不能省略返回值类型，必须指定
    def f4(s:String) :String = {
      return s+"cls"
    }

    //(5)如果有函数声明unit,那么及时函数体中使用return关键字也不起作用
    def f5(s:String):Unit = {
      return s+" cls"
    }
    val as = f5("dh ")
    println(as)

    //(6)如果妻王氏无返回值类型，则可省略=
    def f6(s:String):String={
        return s+" cls"
    }

    //(7)如果函数无参，但是声明了参数列表，那么调用时小括号可加可不加
    def f7():String={
      "cls"
    }
    val as1 = f7()
    val as2 = f7
    println(as1 +" "+ as2)

    //(8)如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
    def f8 = "cls"
    println(f8)

    //(9)如果不关心名称，只关心函数名(def)可以省略
    def f9 = (x:String)=>{println("wusong")}
    def f10(f:String=>Unit) = {
      f("")
    }
    f10(f9)
    println(f10((x:String)=>{println("wusong")}))

匿名函数之间原则：

首先先看一下匿名函数的写法，如下所示，

　　　　　　(x:Int)=>{函数体}

（1）参数的类型可以省略，会根据形参进行自动的推导

（2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参 数超过 1 的永远不能省略圆括号。

（3）匿名函数如果只有一行，则大括号也可以省略

（4）如果参数只出现一次，则参数省略且后面参数可以用_代替

 //定义一个函数:参数包含数据和逻辑函数
    def operation(arr:Array[Int],op:Int=>Int)={
      for (elem <- arr) yield op(elem)
    }

    //定义逻辑函数
    def op(ele:Int):Int = {
      ele+1
    }

    //（3）标准函数调用
    val arr = operation(Array(1,2,3,4),op)
    println(arr.mkString(","))

    //(4)采用匿名函数
    val arr1 = operation(Array(1,2,3,4),(ele:Int)=>{
      ele+1
    })
    println(arr1.mkString(","))

    //(4.1)参数类型可以省略，会根据形参进行自动推导
    var arr2 = operation(Array(1,2,3,4),(ele)=>{
      ele+1
    })
    println(arr2.mkString(","))

    //(4.2)类型省略之后，发现只有一个参数，则圆括号可以省略；
    //其他情况:没有参数和参数超过1的永远不能省略圆括号
    val arr3 = operation(Array(1,2,3,4),ele =>{
      ele+1
    })
    println(arr3.mkString(","))

    //(4.3)匿名函数如果只有一行，则大括号也可以省略
    val arr4 = operation(Array(1,2,3,4),ele => ele+1)
    println(arr4.mkString(","))

    //(4.4)如果参数只出现一次，则参数可以省略切后面参数可以用_代替
    val arr5 = operation(Array(1,2,3,4),_+1)
    println(arr5.mkString(" "))

举一个匿名函数的例子，供大家更好的理解匿名函数的简化写法

def calculator(a: Int, b: Int, op: (Int, Int) => Int): Int = {
 op(a, b)
 }
 // （1）标准版
 println(calculator(2, 3, (x: Int, y: Int) => {x + y}))
 // （2）如果只有一行，则大括号也可以省略
 println(calculator(2, 3, (x: Int, y: Int) => x + y))
 // （3）参数的类型可以省略，会根据形参进行自动的推导;
 println(calculator(2, 3, (x , y) => x + y))
 // （4）如果参数只出现一次，则参数省略且后面参数可以用_代替
 println(calculator(2, 3, _ + _))