Scala函数及其高阶应用

Posted 2022-07-28 钟钟终

函数基本概念

object test01 
  def main(args: Array[String]): Unit =
  
    //return 可以省略，函数体最后一行代码为返回值
    def f0(name:String):String=
      name
    
    println(f0("zhong"))
    println("--------------------------")

    //一行代码，可省略花括号
    def f1(name:String):String=name
    println(f0("zhong"))
    println("--------------------------")

    //返回值类型可以推断出来，则可以省略
    def f2(name:String)=name   //f(x)=x
    println(f0("zhong"))
    println("--------------------------")

    //有return则必须写返回值
    //返回声明为unit，return则不起作用，可不写

    //无返回值类型，可省略等号
    def f3(name:String): Unit =
      println(name)
    
    f3("zhong")
    println("--------------------------")
    //函数无参，但声明了参数列表，调用时小括号可加可不加
    def f4():Unit=
      println("zhong")
    
    f4()
    f4
    println("--------------------------")
                  
    //函数没有参数列表，小括号可以省略，调用时小括号必须省
    def f5:Unit=
      println("zhong")
    
    f5
    println("--------------------------")
    //如果不关心名称，只关心逻辑处理，那么def也可省略
    (name:String)=>println(name)  //lambda表达式
  

匿名函数

object test01 
  def main(args: Array[String]): Unit = 
    val fun=(name:String)=>println(name)
    fun("zhong")

    //以函数作为函数输入
    def f(func:String=>Unit):Unit=
      func("zhong")
    
    f(fun)
    f((name:String)=>println(name))
    //可省略大会括号
    f((name:String)=>println(name))
    //可省略返回值
    f((name)=>println(name))
    //一个参数，可省略括号
    f(name=>println(name))
    //参数只出现一次，可用_代替
    f(println(_))
    //若传入是一个函数体，非调用语句，可省略_
    f(println)
  

固定数值，传入函数

object test01 
  def main(args: Array[String]): Unit = 
    //定义一个二元运算，只操作1和2两个数，集体运算通过参数传入
     def f(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(f(add))
    println(f(minus))
    println("----------------------")
    println(f((a:Int,b:Int)=>a+b))
    println(f((a:Int,b:Int)=>a-b))
    println("----------------------")
    println(f((a,b)=>a+b))
    println(f((a,b)=>a-b))
    println("----------------------")
    println(f(_+_))
    println(f(_-_))
    println(f((a,b)=>b-a))
    println(f(-_+_))
  

函数作为值进行传递

object test01 
  def main(args: Array[String]): Unit = 
   def f(n:Int):Int=
     println("f调用")
     n+1
   
    val result=f(123)
    println(result)
    //函数作为值进行传递
    val f1:Int=>Int=f
    val f2=f _
    println(f1)
    println(f1(24))
    println(f2)
    println(f2(24))
  

函数作为参数进行传递，函数可作为函数的返回值返回

object test01 
  def main(args: Array[String]): Unit = 
   //函数作为参数进行传递，定义二元运算函数
    def f(op:(Int,Int)=>Int,a:Int,b:Int):Int=
      op(a,b)
    
    val a=f((a,b)=>a+b,12,35)
    println(a)
    //函数可作为函数的返回值返回
    def f1():Int=>Unit=
      def f2(a:Int):Unit=
        println("f2调用 "+a)
      
      f2
    
    val f3=f1()
    println(f3(33))
    println(f1()(25))
  

应用案例：相当于map操作

object test01 
  def main(args: Array[String]): Unit = 
    val arr:Array[Int]=Array(12,34,65,88)
    //对数组进行处理，将操作抽象出来，处理完毕后返回一个新的数组
    def arrayOps(array: Array[Int],op:Int=>Int):Array[Int]=
      for(elem<-array) yield op(elem)
    
    //定义一个加1操作，调用
    val arr1=arrayOps(arr,a=>a+1)
    println(arr1.mkString(","))

    //定义一个乘2操作
    val arr2=arrayOps(arr,a=>a*2)
    println(arr2.mkString("|"))