第5章 函式

5.1函式

程式程式碼：

object section5_1 extends App {

 // def gcd(x:Int,y:Int):Int=if(x%y==0) y else gcd(y,x%y)

  

  //def關鍵字宣告函式  gcd為函式名  x,y為函式引數  ：Int為返回值型別

  def gcd(x:Int,y:Int):Int={

    if(x%y==0)

return y       //return關鍵字不能省略

    else

      return gcd(y,x%y)

  }

  val x=gcd(5,20)

  println(s"x的值是$x")

  

}
 

測試效果：

5.2值函式

Scala語言中函式也是物件 也可以像變數一樣被賦值，即值函式

注：=>為函式對映符，就是將左邊的某種型別轉換成右邊的某種型別

object section5_2 extends App {

  val sum=(x:Int,y:Int)=>{

  println(x+y)

  x+y    //函式返回值

  }

  val x=sum(5,6)

  println(s"x的值$x")

  

  val y=(x:Double)=>{

    x*2

  }

  val m=y(3)

   println(s"m的值$m")

   

   val arrint=Array(1,2,3,4)

   //定義一個值函式

   val increament=(x:Int)=>x+1         

  //使用時直接將increament作為map函式的引數使用      

  val result=arrint.map(increament)       //等同於arrint.map(_+1)

   println(result.mkString("|"))

   

   val result1=arrint.map((x:Int)=>x*2)

   println(result1.mkString("|"))

   

     val result2=arrint.map((x)=>x*3)

   println(result2.mkString("|"))

   

     val result3=arrint.map(x=>x+2)

   println(result3.mkString("|"))

   

     val result4=arrint.map(_+1)

   println(result4.mkString("|"))

   

}

 
 

測試效果：

5.3高階函式

高階函式就是操作其他函式的函式。Scala 中允許使用高階函式, 高階函式可以使用其他函式作為引數，或者使用函式作為輸出結果。

f:(Double)=>Double表示輸入型別和返回型別都是Double型別

object section5_3 extends App {

  //新建一個高階函式

  def higherOderFunction(f:(Double)=>Double)=f(100)

  def sqrt(x:Double)=Math.sqrt(x)

  val x=higherOderFunction(sqrt)

  println(s"x的值是$x")

  

  def higherOderFunction1(factor:Int):Double=>Double={

    println("返回新的函式")

    (x:Double)=>factor*x

  }

  val multiply=higherOderFunction1(100)

  val  y=multiply(10)

  println(s"y的值是$y")

  

  val a1=Array("Spark","Hive","Hadoop")

  val result=a1.map(_*2)              //相當於val result=a1.map((x:String)=>x*2)

  println(result.mkString("|"))

  

  val l=List("Spark"->1,"Hive"->2,"Hadoop"->3)

  println(l.map(x=>x._1))//取鍵名

  println(l.map(x=>x._2))//取鍵值

  

  println(l.map(_._1))//取鍵名

  println(l.map(_._2))//取鍵值

  

  val listInt=List(1,2,3)

  val r=listInt.flatMap(x=>x match{

    case 1=>List(1)

    case _=>List(x*2,x*3,x*4)

  }  )

  println(r)

  

  val arr1=Array(1,2,3,4,5)

  val r3=arr1.reduce((x:Int,y:Int)=>{

    println(x,y);

    x+y

  })

}
 

執行結果：

5.4 閉包

程式程式碼：

object section5_4 extends App {

  def a(f:Double=>Double,p:Double=>Unit):Double={

    val x=f(10)

    p(x)

    x

  }

  

  val f=(x:Double)=>x*2

  val p=(x:Double)=>println(x)

 

  val x=a(f,p)

  println(x)

}

執行結果：

5.5函式柯里化

注：柯里化函式多個引數用圓括號分隔，而高階函式只用一個圓括號

程式程式碼：

object section5_5 extends App {

  def higherOderFunction(factor:Int)={

    (x:Double)=>factor*x

  }

  val a=higherOderFunction(10)

  println(a)

  

  

    val b=higherOderFunction(10)(50)   // val b=a(50)

  println(b)

  

  

  def multiply(factor:Int)(x:Double)=factor*x

  val c=multiply(10)(50)

  println(c)

  

  //

  

  val paf=multiply(10)_

  val d =paf(50)

  println(d)

}

5.6 部分應用函式

程式程式碼：

object p82 extends App {

  def product(x1:Int,x2:Int,x3:Int)=x1*x2*x3

  val a=product(1,2,3)

  println(a)

  

  //定義一個1引數的部分應用函式

  def product_1=product(_:Int,2,3)

 val b= product_1(2)

 println(b)

 

   //定義一個1引數的部分應用函式

  def product_2=product(_:Int,_:Int,3)

   val c= product_2(2,3)

 println(c)

 

def product_4=product _

val d= product_4(2,3,4)

 println(d)

}

執行結果：

5.7 偏函式

程式程式碼：

object p83 extends App {

  val sample=1 to 10

  val isEven: PartialFunction [Int,String]={

    case x if x %2==0=>x+"is even"

  }

  println(isEven)

  val a=isEven(10)

  println(a)

  

  

  val isOdd: PartialFunction[Int,String]={

    case x if x%2==1 =>x+" is odd"

  }

    println(isOdd)

 // val c=isOdd(10)

 // println(c)

  

   val d=isOdd(11)

  println(d)

}

執行結果：