scala 學習筆記(07) 一等公民的函數 - yjmyzz－IT工程師數位筆記本

文章出處

在scala中一切皆對象，一切皆函數，函數跟Int，String、Class等其它類型是處于同等的地位，換句話說，使用函數跟使用普通的類型一樣，沒什么區別，因此：

1、函數可以賦值給變量，可以當參數傳遞

  def helloWorld(msg: String): Unit = {
    println("Hello," + msg)
  }

  def foo = {
    println("foo")
  }

  def main(args: Array[String]) {
    //函數賦值給變量
    var d = helloWorld _
    d("jimmy") //Hello,jimmy
    //直接定義匿名函數
    d = (msg: String) => println("你好," + msg)
    d("楊俊明") //你好,楊俊明

    //無參函數，作為另一個函數的參數
    var x = (a: Unit, b: String) => {
      a
      println(b)
    }

    x(foo,"ha ha")
    //foo
    //haha
  }

上面這些代碼都是合法的

2、函數可以嵌套

既然class里可以定義class，函數是一等公民，理應享受跟class同樣的待遇，因此當然也可以嵌套

  def funA(arr: Array[String]) = {
    def funB(a: String) = {
      '[' + a.trim + ']'
    }
    arr.foreach(x => println(funB(x)))
  }

  def main(args: Array[String]) {
    funA(Array("a", " b ", "c ", " f"))
    //  [a]
    //  [b]
    //  [c]
    //  [f]
  }

3、所謂的偏函數

  def add(a: Int, b: Int, c: Int) = {
    a + b + c
  }

  def main(args: Array[String]) {
    val add2 = add(_: Int, _: Int, 0)
    println(add2(1, 2)) //3
  }

利用這個技巧，可以實現帶缺省參數，參數個數不同的"重載"版本

4、閉包

  def fun = {
    var i = 10;
    def funTest = {
      println(i)
      i = i + 1
    }
    funTest
    println(i)
  }

  def main(args: Array[String]) {
    fun
  }

funTest訪問了funTest定義范圍之外的變量 i

5、高階函數

  def main(args: Array[String]) {

    (1 to(9, 2)).map("*" *).foreach(x => println(" " * ((9 - x.length) / 2) + x))

//        *
//       ***
//      *****
//     *******
//    *********
    
  }

打印一顆小樹冠，代碼如此簡單？算法邏輯見下圖，這不是重點，重點是上面這行代碼是函數疊函數，to是對象1的一個函數，1 to (9,2)，即從1到9，每次遞增2，最終即為1，3，5，7，9，然后用map函數映射成一行行星號，然后再用foreach函數，結合前置空格輸出

// move         len
//    4    *     1
//    3   ***    3
//    2  *****   5
//    1 *******  7
//    0********* 9

6、克里化（curring）

  def add_1(a: Int, b: Int, c: Int) = {
    a + b + c
  }

  def add_2(a: Int) = (b: Int, c: Int) => {
    a + b + c
  }

  def add_3(a: Int) = (b: Int) => (c: Int) => {
    a + b + c
  }

  def main(args: Array[String]) {
    println(add_1(1, 2, 3)) //6
    println(add_2(1)(2, 3)) //6
    println(add_3(1)(2)(3)) //6
  }

這個一直沒明白真正的用途，號稱是可以用來做參數的類型智能推斷，但我感覺只是可以把參數拆散，在參數的調用方式上，略有『鏈式』編程的風格

7、參數隱式轉換

  def add(a: Int, b: Int) = a + b

  def foo(a:Int)={
    println(a)
  }

  def boo(a:String)={
    println(a)
  }

  implicit def convert(x: String): Int = {
    x match {
      case "one" => 1
      case "two" => 2
      case "three" => 3
      case _ => 0
    }
  }

  def main(args: Array[String]) {
    println(add("one", "two"))//3
    foo("one")//1
    boo("one")//one
  }

我們并沒有定義一個形如add(a:String,b:String)的加法函數，但是最終即成功調用了add("one","two")，秘密在于implicit做了參數的隱式轉換，這一個很強大的武器，威力過于巨大，上面的這個轉換，會把當前代碼作用域的所有String參數，默認都按這個規則轉換，foo("one")輸出1就是證明，所以沒掌握精通前，建議小心使用。

文章列表