Scala的一些高阶函数区别与用法

函数与方法的区别：（scala）

1.与类和实例无绑定关系的function都属于函数（function）数据显示传递val语句可以定义函数，def也可以
2.与类和实例有绑定关系的function都属于方法（method）数据隐士传递
def functionName ([参数列表]) : [return type]

纯函数：

纯函数没有任何副作用 ，除了它的输入以外，函数结果不依赖于其他任何事情。对于给定的输入，一个纯函数唯一的作用是就是产生一个输出 – 此外无任何作用。可以将纯函数想象为了一个管道，有输入流入，然后输出流出，在流入流出的过程中没有任何损耗。纯函数好处：（易调试、易并行、易组合、易推断、易测试）
//纯函数
def add(a: Int,b: Int) = a + b
println(add(1,2)) //3

偏函数：

偏函数（Partial Function），是一个数学概念，它不是“函数”的一种，它跟函数是是平行概念。
Scala中的Partial Function是一个Trait，其类型为PartialFunction[A,B]，其中接收类型为A的参数，返回一个类型为B的结果，只能传递给偏函数一个参数，因为case语句只能声明一个变量。
val f: PartialFunction[Int, String] = {
case 1 => “one”
case 2 => “two”
case 3 => “three”
case _ => “other”
}
println(f(1)) //one
println(f(2)) //two
println(f(3)) //three
println(f(4)) //other
//case语句被编译成函数
val second: PartialFunction[List[Int],Int] = {
case x :: y :: _ => y
}
new PartialFunction[List[Int], Int] {
def apply(xs: List[Int]) = xs match {
case x :: y :: _ => y
}
def isDefinedAt(xs: List[Int]) = xs match {
case x :: y :: _ => true
case _ => false
}
}
//偏函数内部一些方法：
1.isDefinedAt:判断传入来的参数是否在这个偏函数所处理的范围内。
println(f.isDefinedAt(1)) //true
println(f.isDefinedAt(“11”)) //报错
如果不加case _ f.isDefinedAt(5) //false

2.orElse:将多个偏函数组合起来一起使用，效果类似case语句
val f1: PartialFunction[Int,String] = { case 1 => “one”}
val f2: PartialFunction[Int,String] = { case 2 => “two”}
val f3: PartialFunction[Int,String] = { case 3 => “three”}
val f4: PartialFunction[Int,String] = { case _ => “other”}
val f = f1 orElse f2 orElse f3 orElse f4
println(f(6)) //other

3.andThen:相当于方法连续调用，比如g(f(x))。
pf1的结果返回类型必须和pf2的参数传入类型必须一致，否则会报错。
val pf1: PartialFunction[Int,String] = { case 1 => “one”}
val pf2: PartialFunction[String,String] = { case str if str eq(“one”) => “this is one”}
val pf = pf1 andThen pf2
println(pf(1)) //this is one

4.applyOrElse:接收2个参数，第一个是调用的参数，第二个是回调函数，如果第一个调用的参数匹配，返回匹配的值，否则调用回调函数。
val f: PartialFunction[Int, String] = {
case 1 => “one”
case 2 => “two”
case 3 => “three”
case _ => “other”
}
val pf1 = f.applyOrElse(1,{num: Int=> “three”})
println(pf1) //one
val pf2= f.applyOrElse(6,{num: Int=> “three”})
println(pf2) //other
val pf3 = f.applyOrElse(3,{num: Int=> “three”})
println(pf3) //three

部分应用函数：

部分应用函数（Partial Applied Function）也叫片应用函数。一个函数有N个参数，而我们为其提供少于N个参数，类似于柯里化。
//偏应用函数
def add(a: Int,b: Int,c: Int) = a+b+c
def addA = add(1,: Int,: Int)
println(addA(2,3)) //6
def addBC = add(_: Int,10,100)
println(addBC(1)) //111

匿名函数：

参数放=右边，有防止拼写错误的作用 =>
//匿名函数
var add = (x: Int,y: Int) => x + y
println(add(1,2)) //3

柯里化(Currying)

柯里化（Currying）是把接受两个参数的函数变换成接受一个参数的函数，新的函数返回一个以原有第二个参数为参数的函数。作用：代码简洁
//柯里化
def add(x: Int)(y: Int) = x + y
println(add(1)(3)) //4 必须两个参数
val sum: (Int,Int) => Int = _ + _
val sumCurried: Int => Int => Int = sum.curried
println(sumCurried(sum(1,2))) //得到柯里化版本利用柯里化形式使用第三方函数会有

闭包：

闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。闭包可以简单的认为是可以访问一个函数里面局部变量的另外一个函数。
//闭包 简单易懂写法
val y = 10def add(x: Int) = x + y
println(add(5)) //15

返回一个函数的函数

//返回函数的函数（函数参数是函数）（很抽象）
def sum(f: Int => Int): (Int, Int) => Int = {
def sumF(a: Int, b: Int): Int =
if (a > b) 0
else f(a) + sumF(a + 1, b)
sumF
}
//返回函数的函数简单写法
def add(f:Int=>Int)(a:Int,b:Int):Int={
if(a>b) 0 else f(a)+add(f)(a+1,b)
}
println(sum(x =>x + x)(1,4)) //20
println(add(x => x)(1,4)) //10