scala高级函数快速掌握

scala高级函数

🔥函数对于scala（函数式编程语言）来说非常重要，大家一定要学明白，加油！！！！🔥

一.函数至简原则

1.return可以省略，Scala会把函数体最后一行代码作为返回值

def f0(name:String):String={
         name
      }
      println(f0("scala"))

2.如果函数体内只有一行代码，可以省略花括号

def f2(name:String):String=name

3.如果返回值类型如果能推断出来，：和返回值类型可以一起省略

def f3(name:String)=name

这不就相当于数学上的函数嘛！ f(x)=x。 这也是至简原则的目的，让函数最终尽可能符合我们数学上的使用习惯。

4.如果return没有省略，则返回值类型不能省略

def f4(name:String)={return name
      }//会报错

5.如果函数声明Unit(空类型)，那么即使函数体中使用return也不起作用

def f5(name:String):Unit={return name
      }

6.scala如果期望是无返回值类型，可以省略等号,这种函数也叫做过程，不存在映射关系

def f6(name:String){
       println(name)}

7.如果函数无参数，但是声明了参数列表，那么调用时，小括号，可加可不加

def f7():Unit={
       println(name)}
f7()
f7

8.如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略

def f8:Unit={
       println(name)}
f8

9.如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略,也不需要返回值。也就是匿名函数！lambda表达式

(name:String)=>{println(name)}

lambda表达式没有函数名如何调用呢？

用法1：直接定义个变量，这样就相当于有了名字

val fun =(name:String)=>{println(name)}//lambda表达式的返回值（函数类型）赋给fun 相当于有了名字
fun("scala")

用法2：定义一个函数，以函数作为参数传入

//相当于函数的参数是固定的，这个函数的操作却决于传入的函数val fun =(name:String)=>{println(name)}def f(func:String=>Unit):Unit={//String =>Unit 是函数的类型，代表函数的参数是String类型，返回类型是Unit
    func("scala")}
f(fun)
f((name:String)=>{println(name)})

匿名函数就是一个表达式，它的返回值也就是这个表达式的值。

二.匿名的简化原则

1.参数类型可以省略，会根据形参进行自动推导

f((name)=>{println(name)})//看用法2中定义的函数，传入的参数已经定义死了，必须是String =>Unit（String类型）

2.类型省略之后，如果只有一个参数，圆括号可以省略.

f(name=>{println(name)})

3.匿名函数如果只有一行，大括号也可以省略

f(name=>println(name))

4.如果参数只出现一次，则参数省略且后面可以用_代替,注意对应顺序

f(println(_))

5.如果可以推断出，当前传入的println是一个函数体，而不是调用语句，可以直接省略下划线

f(println)//传入的是一个操作

案例：定义一个“二元运算”函数，只对1和2两个数操作，但是具体的运算通过传入的参数决定

def dualFunction(fun:(Int,Int)=>Int):Int={
    fun(1,2)//具体的参数已经是定死的}val add =(a:Int,b:Int)=>a+b
val minus =(a:Int,b:Int)=>a-b
println(dualFunction(add))
println(dualFunction(minus))
println(dualFunction((a,b)=>a-b))
println(dualFunction(_-_))

三.高阶函数

函数在scala编程里面是一等公民，不想Java只能在类里面定义方法，非常灵活，在一个代码块中就可以定义函数，调用函数。

1.函数可以作为值进行传递，类似给函数起别名

def f(n:Int):Int={
    println("f调用")
    n+1}val f1 = f _    //f _ 代表f这整个函数体val f2:Int=>Int=f   //这样f1（函数对象）就是函数类型（f2:Int=>Int），编译器知道要传函数，所以可以只写个f

2.函数作为参数进行传递

这里就是匿名函数案例演示的那种，参数是定义死的，具体操作看传入的函数（参数）

但是数据一定要定义死嘛？我们可以函数参数和数据参数一起传入

def dualEval(op:(Int,Int)=>Int,a:Int,b:Int):Int={
    op(a,b)}def add(a:Int,b:Int):Int={
    a+b
} 
println(dualEval(add,12,35))//把普通函数作为参数

3.函数作为函数的返回值返回

看到这里我们可以发现，只要是值用到的地方，我们都可以用函数进行代替。

这里就设计到函数嵌套了

def f5():Int=>Unit{//Int => Unit这里说明返回值是函数类型def f6(a:Int)={
       println("f6调用"+6)}
    f6    //return 可以省略}
println(f5())//这里得到的是一个引用（函数），也就是得到的f6（）
println(f5()(25))

应用案例：对数组进行处理，将操作抽象出来，处理完毕之后的结果返回一个新的数组。（也就是大数据map操作）

yield:就是在for循环中，每次循环都会产生一个值，然后将每次产生的值保存，最后组成一个集合。

val arr:Array[Int]=Array(12,45,75,98)//每次只对数组中的一个元素进行操作，这个操作是单独抽象的，只需要单独的定义操作def arrayOperations(array: Array[Int],op:Int=>Int):Array[Int]={for(elem <- array)yield op(elem)}//定义一个加1操作def addOne(elem:Int):Int={
        elem+1}//调用函数var newArray:Array[Int]=arrayOperations(arr,addOne)
      println(newArray.mkString(","))//这里传入匿名函数也是可以的 var newArray2 = arrayOperations(arr,_+1)

这里的应用是以后处理大数据，来了一堆集合，数据就是那些，但是需要进行很多步操作， 我们通过这样可以单独定义他 们的操作。

案例:通过函数嵌套的方式接受三个参数，当这三种类型参数都为假时，返回fales。

def f1(i:Int):String=>(Char=>Boolean)={def f2(s:String):Char=>Boolean={def f3(c:Char):Boolean={if(i==0&&s==""&&c=='0')falseelsetrue}
        f3
      }
      f2
    }
println(f1(0)("")('0'))//结果为false//可以用匿名函数进行简化书写,但是这种书写也会被函数的柯里化给代替def func1(i:Int):String=>(Char=>Boolean)={
    s=>c=>if(i==0&&s==""&&c=='0')falseelsetrue}

四.柯里化和闭包

闭包：如果一个函数，访问到了它的外部（局部）变量的值，那么这个函数和他所处的环境成为闭包

函数柯里化：把一个参数列表的多个参数，变成多个参数列表，每个参数都是一个小括号

函数性编程语言（scala）定是支持闭包的。它可以延长他所使用的参数的做作用域（如上面那个案例，内层函数用到了外层函数的一个局部变量或者是一个参数，为了我们在调用的时候还能分层调用，在调用的时候第二步还能使用外层函数的参数，那么闭包会把外层函数的参数或者局部变量和内层函数打包起来，保存到一个函数对象里面，存放在堆内存里面）。

柯里化：

def addCurrying(a:Int)(b:Int):Int={
        a+b
      }//一旦使用了柯里化，底层一定使用了闭包
      println(addCurrying(23)(32))}

五.递归

递归：一个函数/方法在函数/方法体内又调用了本身

方法调用自身

方法必须要有跳出的逻辑

方法调用自身时，传递的参数应该有规律

Scala中递归必须声明返回值类型

//递归计算阶乘def fact(n:Int):Int={if(n==0)return1//这个return不能省，因为scala只能自动返回最后一行，这里不是最后一行
    fact(n-1)*n
}//尾递归：递归最后一行返回的只有对于自身的调用，没有其他额外的计算，这样当前这层函数不用保存任何东西，这样就用压栈了，节省空间。def tailFact(n:Int):Int={@tailrec//如果写的不是尾递归，idea会报错def loop(n:Int,currRes:Int):Int={if(n==0)return currRes
        loop(n-1,currRes*n)//每次调用我不需要保存上一层的任何信息，不用压栈，做一个栈帧的覆盖就节省空间了。}
    loop(n,1)}//尾递归只有函数式编程语言才支持，比如Java就不支持

六.抽象控制

1.值调用：把计算后的值传递过去

2.名调用：把代码传递过去

//传值参数def f0(a:Int):Unit={
    println("a"+a)}def f1():Int={
    println("f1调用")12}
f0(f1)//传名参数,传递的不再是具体的值，而是代码块def f2(a:=>Int):Unit={//注意这里参数的类型
    println("a:"+a)
    println("a:"+a)}
f2(f1())//每一次用到a的时候，都会把f2中完整的代码块执行一遍。

传名调用的案例：自己实现一个while循环函数

//1.用闭包实现一个函数，将代码块作为参数传入，递归调用def myWhile(condition:=>Boolean):(=>Unit)=>Unit={//内层函数需要递归调用，参数就是循环体(代码块)def doLoop(op:=>Unit):Unit={if(condition){
        op
          myWhile(condition)(op)//尾递归}}
    doLoop _
}

n=10
myWhile(n>=1){
    println(n)
    n-=1}//参数是一个代码块时，小括号可以省略//2.用匿名函数实现def myWhile2(condition:=>Boolean):(=>Unit)=>Unit={//内层函数需要递归调用，参数就是循环体(代码块)
    op=>{if(condition){
        op
          myWhile2(condition)(op)//尾递归}}}//3.用函数柯里化实现def myWhile(condition:=>Boolean)(op:=>Unit):Unit={if(condition){
       op
        myWhile3(condition)(op)}}

七.惰性加载

说明：函数的返回值被声明lazy时，函数的执行将被推迟，直到我们首次对此取值，该函数才会被执行，这种函数我们称之为惰性函数。

（不用到，不执行加载）

lazyval result:Int= sum(13,47)
println("1.函数调用")
println("2.result="+result)def sum(a:Int,b:Int):Int={
    printlb("3.sum调用")}//最后输出顺序时1 3 2