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

四.柯里化和闭包

闭包:如果一个函数,访问到了它的外部(局部)变量的值,那么这个函数和他所处的环境成为闭包

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

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

柯里化:

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

五.递归

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

方法调用自身

方法必须要有跳出的逻辑

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

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

//递归计算阶乘
def fact(n:Int):Int={
    if (n==0) return 1 //这个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时,函数的执行将被推迟,直到我们首次对此取值,该函数才会被执行,这种函数我们称之为惰性函数。

(不用到,不执行加载)

lazy val result:Int = sum(13,47)
println("1.函数调用")
println("2.result="+result)

def sum(a:Int,b:Int):Int={
    printlb("3.sum调用")
}

//最后输出顺序时1 3 2