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，这样是不是就好理解了。