scala函數參數

1、高級函數

把一個函數作爲參數傳遞給另一個函數的方式，在函數式編程中稱爲高級函數。

//絕對值函數
def abs(n:Int)={
  if(n<0) -n
  else n
}
//階乘函數
def factorial(n:Int):Int={
  def go(n:Int,acc:Int):Int=
    if(n<=0) acc
    else go(n-1,n*acc)

  go(n,1)
}
//輸出Int的絕對值
private def formatAbs(x:Int)={
  val msg="the absolute value of %d is %d"
  msg.format(x,abs(x))
}

//輸出Int的階乘
private def formatFactorial(n:Int)={
  val msg="the factorial of %d is %d"
  msg.format(n,factorial(n))
}

//定義一個高級函數，使用指定的函數作爲參數
//注意這裏的參數類型：f是擁有一個Int類型參數且返回Int類型的函數，滿足指定條件的函數就可以作爲參數傳遞
def formatResult(name:String,n:Int,f:Int=>Int)={
  val msg="the %s of %d is %d"
  msg.format(name,n,f(n))
}

def main(args: Array[String]): Unit = {

  println(formatAbs(-40))
  println(formatFactorial(10))

  println(formatResult("absolute value",-40,abs))
  println(formatResult("factorial value",10,factorial))
}

輸出：

the absolute value of -40 is 40

the factorial of 10 is 3628800

the absolute value of -40 is 40

the factorial value of 10 is 3628800

 

//使用匿名函數作爲參數

println(formatResult("absolute value",-40,(n:Int)=>{

  if(n<0) -n

  else n

}))

輸出：the absolute value of -40 is 40

 

2、多態函數

這裏的“多態”是函數的多態，也稱之爲“泛型函數”。

1）簡單的多態實現

//遍歷並打印數組中的內容
def printArr(arr:Array[Int])={
  for(a:Int<-arr){
    print(a)
  }
}

printArr(Array(1,2,3,4,5))

輸出：1,2,3,4,5

 

//使用泛型函數遍歷並打印數組中的內容

//注意這裏需要爲函數指定參數類型T
def printArr[T](arr:Array[T])={
  for(a:T<-arr){
    println(a)
  }
}

printArr(Array(1,2,3,4,5))
printArr(Array("str1","str2","str3","str4","str5"))

輸出：1,2,3,4,5  str1,str2,str3,str4,str5

 

2）通過類型實現多態

舉例以下的函數定義：

def partiall[A,B,C](a:A,f:(A,B)=>C):B=>C=(b:B)=>f(a,b)

函數指定輸入參數類型爲A、B、C三種類型

函數有兩個參數：類型A的參數a及函數參數f，f接收AB類型的參數，並返回C

函數返回值：返回值類型爲B=>C

函數體：(b:B)=>f(a,b)，也是一個參數類型爲B，返回值爲f(a,b)的函數

使用如下代碼執行函數：

 

val a:Int=10

val b:Float=20L



val p=partiall[Int,Float,String](a,(m:Int,n:Float)=>{

  "this result is %s and %s".format(m,n)

})

println(p(b))

輸出：

this result is 10 and 20.0

其中(m:Int,n:Float)=>{"this result is %s and %s".format(m,n)}爲匿名函數

 

3、柯里化函數

舉個簡單的例子：

def add(x:Int,y:Int)=x+y

val a=add(10,20)

def add(x:Int)(y:Int)=x+y

val b=add(10)(20)

效果是一樣的。

函數add柯里化的演變過程如下：

def add(x:Int,y:Int)= def add(x:Int)=(y:Int)=>x+y= def add(x:Int)(y:Int)

函數：def add(x:Int)=(y:Int)=>x+y只有一個參數x，返回接收y參數的匿名函數，返回結果是x+y，這樣是不是就好理解了。