1.函式定義

如下，定義一個函式，用來比較兩數大小得出最大值

def max(x: Int, y: Int): Int = {
  if (x> y) x
  else y
}

以上述定義的函式為例，看下scala函式的基本構成

max 函式可以簡寫為如下

def max(x: Int, y: Int) = if (x > y) x else y

函式呼叫

println(max(3, 5)) // 執行結果：5

2.方法定義

Scala 有方法與函式，二者在語義上的區別很小，Scala 方法是類的一部分，而函式是一個物件可以賦值給一個變數，換言之就是在類中定義的函式即是方法。

如下，定義了兩個方法，用於讀取指定檔案並列印輸出所有長度超過設定值得行

package com.harvey

import scala.io.Source

object LongLines {

  def processFile(filename : String, width : Int): Unit = {
    val source = Source.fromFile(filename)
    for (line <- source.getLines) {
      processLine(filename, width, line)
    }
  }

  private def processLine(filename : String, width : Int, line : String): Unit = {
    if (line.length > width) {
      println(filename + ":" + line.trim)
    }
  }
}
 

main方法呼叫執行

package com.harvey

object FindLongLines {
  def main(args: Array[String]): Unit = {
    val width = 45;
    val filename = "D:\\code\\study\\scalademo\\src\\main\\java\\com\\harvey\\LongLines.scala"
    LongLines.processFile(filename, width)
  }
}

執行結果：

D:\code\study\scalademo\src\main\java\com\harvey\LongLines.scala:def processFile(filename : String, width : Int): Unit = {
D:\code\study\scalademo\src\main\java\com\harvey\LongLines.scala:private def processLine(filename : String, width : Int, line : String): Unit = {
 

3.本地函式

上述例子中，使用的private修飾了processLine方法，使之成為私有方法（類比java中的私有方法），只能在LongLines 類中使用，Scala中還提供了另一種方式，可以把函式定義在別的函式之內，即巢狀函式，如果本地變數一樣，修改程式碼如下

def processFile(filename: String, width: Int): Unit = {
  def processLine(filename: String, width: Int, line: String): Unit = {
    if(line.length > width) {
      println(filename + ": " + line)
    }
  }
  val source = Source.fromFile(filename)
  for (line <- source.getLines){
    processLine(filename, width, line)
  }
}

執行結果同上

4.頭等函式

Scala的函式是頭等函式，不僅可以定義和呼叫函式，還可以寫成匿名的字面量，並作為值傳遞。
對數執行遞增操作的函式字面量例子：

(x: Int) => x + 1

=>指明這個函式把左邊的東西（任意整數x）轉變成右邊的東西（x + 1），即把任意整數對映成x + 1，簡單理解就是=>左邊是表示輸入，右邊表示轉換操作

函式值就是物件也是函式，可以存入變數，也可以使用括號來呼叫

var incr = (x: Int) => x + 1
print(incr(10)) // 執行結果：11

如果想讓函式字面量包含多條語句，可以使用花括號包住函式體，例如

var incr = (x: Int) => {
  print("result = ")
  x + 1
}
print(incr(10)) // 執行結果：result = 11

5.函式字面量的短格式

Scala 提供了許多方法來取出冗餘資訊並把函式字面量寫的更簡短，例如

var someNumbers = List(-1, -3, 2, 4, 9, -9)
var result = someNumbers.filter((x: Int) => x > 0)
print(result) // 執行結果：List(2, 4, 9)

可以將filter中的函式進行簡寫，去掉型別

var result = someNumbers.filter(x => x > 0)

6.佔位符語法

如果想讓函式字面量更簡潔，可以把下劃線當做一個或更多引數的佔位符，只要每個引數在函式字面量中出現一次，比如，_>0 檢查值是否大於零

var result = someNumbers.filter(_> 0)

可以把_看作表示式需要被“填入”的“空白”。這個空白在每次函式呼叫的時候用函式的引數填入。例如
someNumbers初始化值為List(-1, -3, 2, 4, 9, -9)，filter(_>0)，裡面的_首先使用-1替換，即-1>0，然後再用-3替換，依次類推。

需要注意，有時把下劃線當作引數的佔位符，編譯器可能無法推斷缺失的引數型別，例如

val f = _ + _

會報如下錯誤

missing parameter type for expanded function ((x$1, x$2) => x$1.$plus(x$2))
    val f = _ + _

這種情況下，使用冒號指定型別即可

val f = (_: Int) + (_: Int)
print(f(2, 8)) // 執行結果：10

7.部分應用函式

下劃線不僅能替換單個引數，還可以替換整個引數列表，例如：寫成println()或println。如下

someNumbers.foreach(println(_))

Scala把這種簡短格式直接看作你輸入瞭如下程式碼：

someNumbers.foreach(x => println(x))

上面例子中的下劃線不是單個引數的佔位符，而是整個引數列表的佔位符，以這種方式使用下劃線時，其實就是一個部分應用函式。我們再看個例子，如下

def sum(a: Int, b: Int, c: Int) = a + b + c
print(sum(1, 2, 3)) // 執行結果：6

部分應用函式是一種表示式，不需要函式所需要的所有引數，比如：要建立呼叫sum的部分應用表示式，而不提供任何3個所需引數，只要在“sum”之後加上下劃線，然後可以把得到的函式存入變數

var a = sum _
print(a(1, 2, 3)) // 執行結果：6

實際發生的事情是這樣的：名為a的 變數只是一個函式值物件。這個函式值由scala編譯器依照部分應用函式表示式sum _，自動產生類的例項。編譯器產生的類有一個apply方法帶3個引數。之所以帶3個引數是因為sum _表示式缺少的引數數量為3，Scala編譯器把表示式a(1, 2, 3)翻譯成對函式值的apply方法的呼叫，傳入3個引數1、2、3。因此a(1, 2, 3)是下列程式碼的短格式

a.apply(1, 2, 3)

8.閉包

在理解閉包是什麼意思前，我們先來看個例子

val addMore = (x: Int) => x + more
print(addMore(10))

執行報錯：

Error:(37, 35) not found: value more
    val addMore = (x: Int) => x + more

x變數是一個繫結變數，它在函式的上下文有明確意義，被定義函式的唯一引數是Int，值函式呼叫的時候被賦值，稱這種變數為繫結變數（Bound Variable）。more是一個沒有給定含義的不定變數，這裡的more是一個自由變數（Free Variable）。所以在使用的時候，編譯器會報錯。改寫上述程式碼如下

var more = 1
val addMore = (x: Int) => x + more
print(addMore(10)) // 執行結果：11

像這種執行時確定more型別及值的函式稱為閉包,more是個自由變數，在執行時其值和型別得以確定
這是一個由開放(free)到封閉的過程，因此稱為閉包。

9.重複引數

Scala中，可以指明函式的最後一個引數是重複的，即可變引數，類似java中動態引數。標註一個重複引數，在引數型別後面加一個星號

scala> def echo(args: String*) = for(arg <- args) println(arg)
echo: (args: String*)Unit
scala> echo()
scala> echo("hello")
hello
scala> echo("hello", "scala")
hello
scala

可能你會想到，在傳入多個引數的時候，把引數封裝為一個Array，我們來看下，是否可以

val arr = Array("hello", "scala")
echo(arr)

執行報錯：

Error:(51, 10) type mismatch;
 found   : Array[String]
 required: String
    echo(arr)

函式內部，重複引數的型別是宣告引數型別的陣列，想要實現將陣列中的每個元素當做引數，而不是當做單一的引數傳給echo，在陣列引數後面新增一個冒號和_*符號，如下

scala> echo(arr: _*)
hello
scala