一.高階函數

一.函數式編程中函數的特點

1. 可以創建匿名函數
   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

2. 函數和數字一樣，可以作為參數被傳遞和操作
   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)

3. 聲明以函數為參數的函數
   以函數為參數時，要給出函數名，參數類型，返回值類型，作為算法的約束條件。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
   ```

二.集合類中有用的高階函數（算法為參數）

1. map與foreach

   scala> (1 to 4).map("*" * _).foreach(println)
   *
   **
   ***
   ****

2. filter

   scala> (1 to 9).filter(_% 2==0)
   res14: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 4, 6, 8)

3. reduceLeft

   scala> (1 to 4).reduceLeft(_*_)
   res16: Int = 24

4. sortWith

   scala> "i have a dream".split(" ").sortWith(_.length < _.length)
   res21: Array[String] = Array(i, a, have, dream)

三.閉包

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

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
   ```

四.柯里化

1. 柯里化：
   柯里化是一種函數的書寫格式，他把多參函數，轉化為擁有一個參數的函數
   柯里化將單個參數單拎出來，以構建用于類型推斷的函數
   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
   ```

五.控制抽象

1. 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

   ```