可以創建匿名函數
def聲明帶名函數，val聲明匿名函數
scala scala> def triple(x:Int):Int = {3*x} scala> triple(2) res1: Int = 6
scala scala> val triple = (x:Int) => 3*x scala> triple(2) res0: Int = 6

函數和數字一樣，可以作為參數被傳遞和操作
scala scala> val fun = scala.math.ceil _ // _ 把函數轉變為變量 scala> Array(1.1,2.2,3.3).map(fun) res2: Array[Double] = Array(2.0, 3.0, 4.0)

聲明以函數為參數的函數
以函數為參數時，要給出函數名，參數類型，返回值類型，作為算法的約束條件。eg：f:(Double)=>Double
以函數為參數的函數，他的函數體要用聲明前面的函數名。eg：f(0.25)
```scala
scala> def valeOnQuarter(f:(Double)=>Double) = f(0.25)
valeOnQuarter: (f: Double => Double)Double

scala> valeOnQuarter(scala.math.ceil _)
res4: Double = 1.0
匿名函數作為參數傳遞給另一個函數作為算法時，該匿名函數會自行做參數類型推斷，自動識別算法的參數和返回值類型，可以不去聲明scala
// 匿名函數作為算法的完整寫法
scala> valeOnQuarter((x:Double)=>3x)
res5: Double = 0.75
// 參數值推斷的寫法
scala> valeOnQuarter(x=>3x)
res6: Double = 0.75
// 終極簡化寫法
scala> valeOnQuarter(3*_)
res7: Double = 0.75
【注】：匿名函數作為參數值時，之所以可以做參數類型推斷，是因為以算法為參數的函數的函數體給出了參數值。如果把一個val變量聲明為匿名函數，則要給出參數類型，以便scala推斷返回值類型scala
scala> val fun = 3*( _: Double)
fun: Double => Double =

scala> fun(2)
res8: Double = 6.0
```

map與foreach

filter

reduceLeft

sortWith

閉包：
一個函數的函數體內，所用到的變量沒有全部在函數內部定義。函數內部定義的變量稱為綁定變量，函數未定義的稱為自由變量。此時含有未定義變量的函數文本處于“開放”狀態，當自由變量根據函數上文動態推斷而來后，函數文本“關閉”，次過程稱為函數的閉包。
即：函數從變量個數 > 參數列表個數到變量個數 = 參數列表個數的過程，稱為閉包
scala scala> val more=1 scala> def add(x:Int)={x+more} // 函數內部沒有給出more的定義，而是根據上文的more=1推斷而來 scala> add(1) res0: Int = 2

閉包的高級形式：匿名函數中包含第二個綁定變量
```scala
scala> def add(more:Int)={(x:Int)=>x+more} // add函數內部有2個參數，卻只有一個參數列表

scala> val add1=add(1) // 此時add1的變量個數和參數列表個數相同
add1: Int => Int =

scala> add1(2)
res2: Int = 3
```

柯里化：
柯里化是一種函數的書寫格式，他把多參函數，轉化為擁有一個參數的函數
柯里化將單個參數單拎出來，以構建用于類型推斷的函數
eg：閉包中的def add(more:Int)={(x:Int)=>x+more}，add函數實際上有2個參數，more和x
```scala
scala> def add(x:Int,y:Int)=x+y // 2參函數的一般形式

scala> def add(x:Int)=(y:Int)=>x+y // 柯里化后的1參函數
add: (x: Int)Int => Int

scala> add(1) // 類型推斷后，add(1)=(y:Int)=>1+y
res5: Int => Int =

scala> add(1)(2)
res6: Int = 3
柯里化簡寫形式scala
scala> def add(x:Int)(y:Int)=x+y
add: (x: Int)(y: Int)Int

scala> add(1)(2) //add(1)(2)的調用，先轉化為add(1)函數，再給這個函數傳參2
res7: Int = 3
```

scala有一個函數級別的模板設計模式，為一個算法起一個別名，聲明返回值類型，在函數體內，用這些別名形成操作模板。調用這種模板函數時，可以將一系列語句組成用大括號擴起來形成函數語句塊，把語句塊作為參數傳進這個模板函數
eg：用控制抽象實現while..until的語法：
```scala
scala> def until(condition: =>Boolean)(fun: =>Unit){
| if(!condition){
| fun
| until(condition)(fun)
| }
| }
until: (condition: => Boolean)(fun: => Unit)Unit

scala> a=5
scala> until{a==1}{a-=1
| println(a)
| }
4
3
2
1

```