# 高階函數 ## 函數可以作為參數進行傳遞和返回值進行返回 ```Scala //傳一個a乘b 就返回一個函數，邏輯是實現兩數相乘 //傳一個a*b 返回一個函數，邏輯是實現兩數相乘 //傳一個axb 返回一個函數，邏輯是實現兩數相乘 def funTest6(str:String,fun:(St ...

高階函數

函數可以作為參數進行傳遞和返回值進行返回

//傳一個a乘b 就返回一個函數，邏輯是實現兩數相乘
//傳一個a*b 返回一個函數，邏輯是實現兩數相乘
//傳一個axb 返回一個函數，邏輯是實現兩數相乘
def funTest6(str:String,fun:(String)=>Int):(Int,Int)=>Int = {
  val i: Int = fun(str)
  i match {
    case 0 => (a,b)=>a+b
    case 1 => (a,b)=>a-b
    case 2 => (a,b)=>a*b
    case 3 => (a,b)=>a/b
  }
}

val function: (Int, Int) => Int = funTest6("a*b", (s) => {
  if (s.contains("*") || s.contains("乘")) {
    2
  } else {
    0
  }
})

println(function(2, 3))

匿名函數

沒有名字的函數就是匿名函數。
例如：

(x:Int)=>{函數體} 
x：表示輸入參數類型；Int：表示輸入參數類型；函數體：表示具體代碼邏輯```
傳遞匿名函數至簡原則：
1.	參數的類型可以省略，會根據形參進行自動的推導
2.	類型省略之後，發現只有一個參數，則圓括弧可以省略；其他情況：沒有參數和參數超過 1 的永遠不能省略圓括弧。 
3.	匿名函數如果只有一行，則大括弧也可以省略
4.	如果參數只出現一次，則參數省略且後面參數可以用_代替

練習1：傳遞的函數有一個參數
代碼示例：
```Scala
def main(args: Array[String]): Unit = {
 // （1）定義一個函數：參數包含數據和邏輯函數
def operation(arr: Array[Int], op: Int => Int): Array[Int] = {
  for (elem <- arr) yield op(elem)
}
 // （2）定義邏輯函數
 def op(ele: Int): Int = {
 ele + 1
 }
 // （3）標準函數調用
 val arr = operation(Array(1, 2, 3, 4), op)
 println(arr.mkString(","))
 
 
 // （4）採用匿名函數
 val arr1 = operation(Array(1, 2, 3, 4), (ele: Int) => {
 ele + 1
 })
 println(arr1.mkString(","))
 
 
 
 // （4.1）參數的類型可以省略，會根據形參進行自動的推導;
 val arr2 = operation(Array(1, 2, 3, 4), (ele) => {
 ele + 1
 })
 println(arr2.mkString(","))
 
 
 
 // （4.2）類型省略之後，發現只有一個參數，則圓括弧可以省略；其他情
況：沒有參數和參數超過 1 的永遠不能省略圓括弧。
 val arr3 = operation(Array(1, 2, 3, 4), ele => {
 ele + 1
 })
 println(arr3.mkString(","))
 
 
 
 // (4.3) 匿名函數如果只有一行，則大括弧也可以省略
 val arr4 = operation(Array(1, 2, 3, 4), ele => ele + 1)
 println(arr4.mkString(","))
 //（4.4）如果參數只出現一次，則參數省略且後面參數可以用_代替
 val arr5 = operation(Array(1, 2, 3, 4), _ + 1)
 println(arr5.mkString(","))
 
 } 
}

練習二：傳遞的函數有兩個參數
代碼示例：

object TestFunction {
 def main(args: Array[String]): Unit = {
 def calculator(a: Int, b: Int, op: (Int, Int) => Int): Int 
= {
 op(a, b)
 }
 // （1）標準版
 println(calculator(2, 3, (x: Int, y: Int) => {x + y}))
 // （2）如果只有一行，則大括弧也可以省略
 println(calculator(2, 3, (x: Int, y: Int) => x + y))
 // （3）參數的類型可以省略，會根據形參進行自動的推導;
 println(calculator(2, 3, (x , y) => x + y))
 // （4）如果參數只出現一次，則參數省略且後面參數可以用_代替
 println(calculator(2, 3, _ + _))
 } 
}

偏函數

偏函數是一個特質 ,用來專門處理某種數據類型! [註意可以同時處理多種數據類型]

偏函數的定義：

val second: PartialFunction[List[Int], Option[Int]] = {
     case x :: y :: _ => Some(y)
}

註：該偏函數的功能是返回輸入的 List 集合的第二個元素

案例：將集合中的所有的Int類型的數據都加上1

代碼示例：

 //  方式一   過濾器形式
 val list = List(1, 2, 3, 4, "hello")
 val res: List[Int] = list.filter(x => x.isInstanceOf[Int]).map(x => x.asInstanceOf[Int] + 1)
 res.foreach(println)
 
 // 方式二   匹配模式
 val res2: List[Any] = list.map(x => x match {
   case x: Int => x + 1
   case _ =>
   })
 res2.filter(x => x.isInstanceOf[Int]).foreach(println)
 
 // 方式三  使用偏函數  泛型1 輸入的數據類型 泛型2 要處理的數據類型
 val pp = new PartialFunction[Any,Int] {
   // 返回true
   override def isDefinedAt(x: Any) = {
     x.isInstanceOf[Int]
   }
   // 執行下一個方法
   override def apply(v1: Any) = {
     v1.asInstanceOf[Int]+1
   }
 }
 
   //  list.map(pp).foreach(println)
  list.collect(pp).foreach(println)

偏函數原理

上述代碼會被 scala 編譯器翻譯成以下代碼，與普通函數相比，只是多了一個用於參數檢查的函數——isDefinedAt，其返回值類型為 Boolean。

val second = new PartialFunction[List[Int], Option[Int]] {
 //檢查輸入參數是否合格
 override def isDefinedAt(list: List[Int]): Boolean = list match 
{
 case x :: y :: _ => true
 case _ => false
 }
 //執行函數邏輯
 override def apply(list: List[Int]): Option[Int] = list match 
{
 case x :: y :: _ => Some(y)
 }
}

偏函數的執行流程

遍歷list中的每個元素
調用 val e = if (isDefinedAt) {apply}
每得到一個e 就會將e存儲在一個新的集合中返回使用偏函數就不要使用map方法了

偏函數的簡寫形式

val list = List(2, 4, 6, 8, "cat")

//定義一個偏函數
def myPartialFunction: PartialFunction[Any, Int] = {
  case x: Int => x * x
}
list.collect(myPartialFunction).foreach(println)
// 簡寫方式 
list.collect({
  case x:Int=>x*x
}).foreach(println)

偏函數總結

使用構建特質的實現類(使用的方式是PartialFunction的匿名子類)
PartialFunction 是個特質(看源碼)
構建偏函數時，參數形式 [Any, Int]是泛型，第一個表示參數類型，第二個表示返回參數
當使用偏函數時，會遍歷集合的所有元素，編譯器執行流程時先執行isDefinedAt()如果為true ,就會執行 apply, 構建一個新的Int 對象返回
執行isDefinedAt() 為false 就過濾掉這個元素，即不構建新的Int對象.
map函數不支持偏函數，因為map底層的機制就是所有迴圈遍歷，無法過濾處理原來集合的元素
collect函數支持偏函數

模式匹配

模式匹配語法中，採用 match 關鍵字聲明，每個分支採用 case 關鍵字進行聲明，當需要匹配時，會從第一個 case 分支開始，如果匹配成功，那麼執行對應的邏輯代碼，如果匹配不成功，繼續執行下一個分支進行判斷。如果所有 case 都不匹配，那麼會執行 case _分支，類似於 Java 中 default 語句。

基本語法

object TestMatchCase {
 def main(args: Array[String]): Unit = {
 var a: Int = 10
 var b: Int = 20
 var operator: Char = 'd'
 var result = operator match {
 case '+' => a + b
 case '-' => a - b
 case '*' => a * b
 case '/' => a / b
 case _ => "illegal"
  }
 println(result)
 }
}

說明：

如果所有 case 都不匹配，那麼會執行 case _ 分支，類似於 Java 中 default 語句，若此時沒有 case _ 分支，那麼會拋出 MatchError。
每個 case 中，不需要使用 break 語句，自動中斷 case。
match case 語句可以匹配任何類型，而不只是字面量。
=> 後面的代碼塊，直到下一個 case 語句之前的代碼是作為一個整體執行，可以使用{}括起來，也可以不括。

模式守衛

如果想要表達匹配某個範圍的數據，就需要在模式匹配中增加條件守衛。
代碼演示：

object TestMatchGuard {
 def main(args: Array[String]): Unit = {
 def abs(x: Int) = x match {
 case i: Int if i >= 0 => i
 case j: Int if j < 0 => -j
 case _ => "type illegal"
 }
 println(abs(-5))
 } 
}

模式匹配類型

匹配常量

Scala 中，模式匹配可以匹配所有的字面量，包括字元串，字元，數字，布爾值等等
代碼演示：

object TestMatchVal {
 def main(args: Array[String]): Unit = {
 println(describe(6))
 }
 def describe(x: Any) = x match {
 case 5 => "Int five"
 case "hello" => "String hello"
 case true => "Boolean true"
 case '+' => "Char +"
 }
}

匹配類型

需要進行類型判斷時，可以使用前文所學的 isInstanceOf[T]和 asInstanceOf[T]，也可使用模式匹配實現同樣的功能。
代碼實現：

object TestMatchClass {
 def describe(x: Any) = x match {
 case i: Int => "Int"
 case s: String => "String hello"
 case m: List[_] => "List"
 case c: Array[Int] => "Array[Int]"
 case someThing => "something else " + someThing
 }
 def main(args: Array[String]): Unit = {
    println(describe(List(1, 2, 3, 4, 5)))
    println(describe(Array(1, 2, 3, 4, 5, 6)))
    println(describe(Array("abc")))
 }
}

匹配數組

scala 模式匹配可以對集合進行精確的匹配，例如匹配只有兩個元素的、且第一個元素為 0 的數組
代碼實現：

object TestMatchArray {
 def main(args: Array[String]): Unit = {
 for (arr <- Array(Array(0), Array(1, 0), Array(0, 1, 0), 
Array(1, 1, 0), Array(1, 1, 0, 1), Array("hello", 90))) { // 對
一個數組集合進行遍歷
 val result = arr match {
 case Array(0) => "0" //匹配 Array(0) 這個數組
 case Array(x, y) => x + "," + y //匹配有兩個元素的數組，然後將將元素值賦給對應的 x,y
 case Array(0, _*) => "以 0 開頭的數組" //匹配以 0 開頭和
數組
 case _ => "something else"
 }
 println("result = " + result)
 }
 }

匹配列表

方式一代碼實現：

object TestMatchList {
 def main(args: Array[String]): Unit = {
 //list 是一個存放 List 集合的數組
 //請思考，如果要匹配 List(88) 這樣的只含有一個元素的列表,並原值返回.應該怎麼寫
 for (list <- Array(List(0), List(1, 0), List(0, 0, 0), List(1, 
0, 0), List(88))) {
 val result = list match {
 case List(0) => "0" //匹配 List(0)
 case List(x, y) => x + "," + y //匹配有兩個元素的 List
 case List(0, _*) => "0 ..."
 case _ => "something else"
 }
 println(result)
 }
 }
}

方式二代碼實現：

object TestMatchList {
 def main(args: Array[String]): Unit = {
 val list: List[Int] = List(1, 2, 5, 6, 7)
 list match {
 case first :: second :: rest => println(first + "-" + 
second + "-" + rest)
 case _ => println("something else")
  }
 } 
}

匹配元組

代碼實現：

object TestMatchTuple {
 def main(args: Array[String]): Unit = {
 //對一個元組集合進行遍歷
 for (tuple <- Array((0, 1), (1, 0), (1, 1), (1, 0, 2))) {
 val result = tuple match {
 case (0, _) => "0 ..." //是第一個元素是 0 的元組
 case (y, 0) => "" + y + "0" // 匹配後一個元素是 0 的對偶元組
 case (a, b) => "" + a + " " + b
 case _ => "something else" //預設
 }
 println(result)
 }
 }
}

匹配對象及樣例類

代碼示例：

class User(val name: String, val age: Int)
object User{
 def apply(name: String, age: Int): User = new User(name, age)
 def unapply(user: User): Option[(String, Int)] = {
 if (user == null)
 None
 else
 Some(user.name, user.age)
 } 
}
object TestMatchUnapply {
 def main(args: Array[String]): Unit = {
 val user: User = User("zhangsan", 11)
 val result = user match {
 case User("zhangsan", 11) => "yes"
 case _ => "no"
 }
 println(result)
 } 
}

小結

val user = User("zhangsan",11)，該語句在執行時，實際調用的是 User 伴生對象中的apply 方法，因此不用 new 關鍵字就能構造出相應的對象。
當將 User("zhangsan", 11)寫在 case 後時[case User("zhangsan", 11) => "yes"]，會預設調用 unapply 方法(對象提取器)，user 作為 unapply 方法的參數，unapply 方法將 user 對象的 name 和 age 屬性提取出來，與 User("zhangsan", 11)中的屬性值進行匹配
case 中對象的 unapply 方法(提取器)返回 Some，且所有屬性均一致，才算匹配成功,屬性不一致，或返回 None，則匹配失敗。
若只提取對象的一個屬性，則提取器為 unapply(obj:Obj):Option[T]，若提取對象的多個屬性，則提取器為 unapply(obj:Obj):Option[(T1,T2,T3…)]，若提取對象的可變個屬性，則提取器為 unapplySeq(obj:Obj):Option[Seq[T]]

函數柯里化&閉包

閉包定義：

閉包：如果一個函數,訪問到了它的外部（局部）變數的值，那麼這個函數和他所處的環境,稱為閉包
代碼示例：

package cn.doitedu.data_export

import org.apache.commons.lang3.RandomUtils
object CloseTest {
  def main(args: Array[String]): Unit = {
    val fx = (a:Int,b:Int)=>{
      a+b
    }

    val fxx = (a:Int) => {
      (b:Int)=>a+b
    }

    val res = fxx(3)(10)

    val f = () => {
      var p = RandomUtils.nextInt(1,10)

      val inner = () => {
        p += 1
        p
      }
      inner
    }

    val x1= f()
    println(x1())
    println(x1())

    println("-----------")

    val x2 = f()
    println(x2())
    println(x2())
    println(x2())
  }
}

柯里劃函數的定義：

函數柯里化：把一個參數列表的多個參數,變成多個參數列表。
意義: 方便數據的演變, 後面的參數可以藉助前面的參數推演 , foldLeft的實現
有多個參數列表的函數就是柯里化函數，所謂的參數列表就是使用小括弧括起來的函數參數列表
curry化最大的意義在於把多個參數的function等價轉化成多個單參數function的級聯，這樣所有的函數就都統一了，方便做lambda演算。在scala里，curry化對類型推演也有幫助，scala的類型推演是局部的，在同一個參數列表中後面的參數不能藉助前面的參數類型進行推演，curry化以後，放在兩個參數列表裡，後面一個參數列表裡的參數可以藉助前面一個參數列表裡的參數類型進行推演。這就是為什麼 foldLeft這種函數的定義都是curry的形式

惰性載入

當函數返回值被聲明為 lazy 時，函數的執行將被推遲，直到我們首次對此取值，該函數才會執行。這種函數我們稱之為惰性函數。
代碼示例：

def main(args: Array[String]): Unit = {
 lazy val res = sum(10, 30)
 println("----------------")
 println("res=" + res)
}
def sum(n1: Int, n2: Int): Int = {
 println("sum 被執行。。。")
 return n1 + n2
}

運行結果：
----------------
sum 被執行。。。
res=40

註意：lazy 不能修飾 var 類型的變數

隱式轉換

隱式函數

隱式轉換可以在不需改任何代碼的情況下，擴展某個類的功能
練習：通過隱式轉化為 Int 類型增加方法。

//創建一個隱式方法，在def 前面加上關鍵字 implicit  讓一個類型具有更加豐富的功能
implicit def stringWrapper(str:String)={
  new MyRichString(str)
}

class MyRichString(val str:String){
  def fly()={
    println(str+",我是字元串，我能飛！！")
  }

  def jump()={
    str + ":我能跳！"
  }
}

package com.doit.day02
import com.doit.day01.AnythingElse.Else._
/**
 * 隱式轉換：說白了就是給一個函數，參數，類 賦予更加強大的功能
 */
object _10_隱式轉換 {
  def main(args: Array[String]): Unit = {
    //1 本身是int 類型的，但是他卻可以調用richInt這個類裡面的方法
    /**
     *  implicit def intWrapper(x: Int)= {
     *  //相當於創建了一個 RichInt的對象
     *    new runtime.RichInt(x)
     *  }
     *  我寫了一個隱式方法，傳進去一個參數，返回給我的是一個對象， 並且在這個方法最前面加上了implicit 關鍵字 ，那麼
     *  這個參數的類型 就具備了該類的方法
     */
    val str: String = "zss"
    str.fly()
  }
}

隱式參數

普通方法或者函數中的參數可以通過 implicit 關鍵字聲明為隱式參數，調用該方法時，
就可以傳入該參數，編譯器會在相應的作用域尋找符合條件的隱式值
說明：

同一個作用域中，相同類型的隱式值只能有一個
編譯器按照隱式參數的類型去尋找對應類型的隱式值，與隱式值的名稱無關。
隱式參數優先於預設參數

代碼示例：

//定義了一個方法，方法中的參數設置的是隱式參數
def add(implicit a: Int, b: String) = {
  a + b.toInt
}

//定義兩個變數，前面用implicit  修飾  變成隱式的
implicit val a:Int = 10
implicit val b:String = "20"

//調用方法的時候，如果沒有傳參數，那麼他會去上下文中找是否又隱式參數，如果有
//他就自己偷偷的傳進去了，如果沒有，會直接報錯
add

隱式類

在 Scala2.10 後提供了隱式類，可以使用 implicit 聲明類，隱式類的非常強大，同樣可
以擴展類的功能，在集合中隱式類會發揮重要的作用。
說明：

其所帶的構造參數有且只能有一個
隱式類必須被定義在“類”或“伴生對象”或“包對象”里，即隱式類不能是頂級的。

代碼示例：

implicit class snake(ant:Ant){
  def eatElephant()={
    println("i can eat elephant!!")
  }
}

val ant: Ant = new Ant
ant.eatElephant()

隱式解析機制

首先會在當前代碼作用域下查找隱式實體（隱式方法、隱式類、隱式對象）。
如果第一條規則查找隱式實體失敗，會繼續在隱式參數的類型的作用域里查找。類型的作用域是指與該類型相關聯的全部伴生對象以及該類型所在包的包對象。

代碼示例：

package com.chapter10
import com.chapter10.Scala05_Transform4.Teacher
//（2）如果第一條規則查找隱式實體失敗，會繼續在隱式參數的類型的作用域里查找。
類型的作用域是指與該類型相關聯的全部伴生模塊，
object TestTransform extends PersonTrait {
 def main(args: Array[String]): Unit = {
 //（1）首先會在當前代碼作用域下查找隱式實體
 val teacher = new Teacher()
 teacher.eat()
 teacher.say()
 }
 class Teacher {
 def eat(): Unit = {
 println("eat...")
 }
 } 
}
trait PersonTrait {
}
object PersonTrait {
 // 隱式類 : 類型 1 => 類型 2
 implicit class Person5(user:Teacher) {
 def say(): Unit = {
 println("say...")
 }
 }
}

Scala高階語法

高階函數

函數可以作為參數進行傳遞和返回值進行返回

匿名函數

偏函數

偏函數的定義：

案例：將集合中的所有的Int類型的數據都加上1

偏函數原理

偏函數的執行流程

偏函數的簡寫形式

偏函數總結

模式匹配

基本語法

模式守衛

模式匹配類型

匹配常量

匹配類型

匹配數組

匹配列表

匹配元組

匹配對象及樣例類

函數柯里化&閉包

閉包定義：

柯里劃函數的定義：

惰性載入

隱式轉換

隱式函數

隱式參數

隱式類

隱式解析機制