scala函數至簡原則是什麼？

• 1.return可以省略，Scala會使用函數體的最後一行代碼作爲返回值
• 2.如果函數體只有一行代碼，可以省略花括號
• 3.返回值類型如果能夠推斷出來，那麼可以省略（:和返回值類型一起省略）
• 4.如果有return，則不能省略返回值類型，必須指定
• 5.如果函數明確聲明unit，那麼即使函數體中使用return關鍵字也不起作用
• 6.Scala如果期望是無返回值類型，可以省略等號 這種形式稱爲過程
• 7.如果函數無參，但是聲明瞭參數列表，那麼調用時，小括號，可加可不加
• 8.如果函數沒有參數列表，那麼小括號可以省略，調用時小括號必須省略
• 9.如果不關心名稱，只關心邏輯處理，那麼函數名（def）可以省略

代碼示例

object Scala05_TestFun_review {
  def main(args: Array[String]): Unit = {
    /*
    //正常定義函數
    def f0(name:String): String ={
      return name
    }
    println(f0("atguigu"))
    //（1）return可以省略，Scala會使用函數體的最後一行代碼作爲返回值
    def f1(name:String): String ={
      name
    }
    println(f1("atguigu"))

    //（2）如果函數體只有一行代碼，可以省略花括號
    def f2(name:String): String = name
    println(f2("atguigu"))

    //（3）返回值類型如果能夠推斷出來，那麼可以省略（:和返回值類型一起省略）
    def f3(name:String)= name
    println(f3("atguigu"))

    //（4）如果有return，則不能省略返回值類型，必須指定
    def f4(name:String) ={
      return name
    }

    //（5）如果函數明確聲明unit，那麼即使函數體中使用return關鍵字也不起作用
    def f5(name:String): Unit ={
      return name
    }
    println(f5("atguigu"))

    //（6）Scala如果期望是無返回值類型，可以省略等號   這種形式稱爲過程
    def f6(name:String){
      println(name)
    }
    f6("banzhang")

    //（7）如果函數無參，但是聲明瞭參數列表，那麼調用時，小括號，可加可不加
    def f7(): Unit ={
      println("jingjing")
    }
    f7
    f7()

    //（8）如果函數沒有參數列表，那麼小括號可以省略，調用時小括號必須省略
    def f8: Unit ={
      println("jingjing")
    }
    //f8()
    f8
    */

    //（9）如果不關心名稱，只關心邏輯處理，那麼函數名（def）可以省略
    // 1.擴展f9的功能   2.具體擴展的功能是通過fun函數傳遞，很靈活
    def f9(fun:(String)=>Unit): Unit ={
      fun("jingjing")
    }

    //def f10(s:String): Unit ={
    //  println(s)
    //}
    //f9(f10)

    //匿名函數 ：沒有名字的函數，通過lambda表達式實現     (參數)=>{函數體}
    //f9((s:String)=>{println(s)})

    //（1）參數的類型可以省略，會根據形參進行自動的推導
    //f9((s)=>{println(s)})

    //（2）類型省略之後，發現只有一個參數，則圓括號可以省略；其他情況：沒有參數和參數超過1的永遠不能省略圓括號。
    //f9(s =>{println(s)})

    //（3）匿名函數如果只有一行，則大括號也可以省略
    //f9(s =>println(s))

    //（4）如果參數只出現一次，則參數省略且後面參數可以用_代替
    //f9(println(_))

  //  （5） 如果可以推斷出，println是一個函數體，而不是調用語句，那麼(_)可以省
  //  f9(println)

    //反推導     f9((s:String)=>println(s))

    //加深大家理解
    //定義一個函數，接受一個函數類型的參數，該函數類型有兩個參數
    def f11(fun:(Int,Int)=>Int):Int={
      fun(1,2)
    }

    //println(f11((x:Int,y:Int)=>{x + y}))
    //println(f11((x,y)=>x + y))
    println(f11(_ + _))

  }
}