Scala函数式编程

Scala函数

基础函数定义：

def 函数名(参数1 : 参数类型, 参数2 : 参数类型 ...) : 返回值类型{
  函数体
}

//例子
def test(n:Int):Int={
    return n
}

可变参数

//可以传入不定量的参数，底层使用数组存储了，和java类似
def test(n:Int*):Unit={
    print(n)
}

//类似于Java中 
    public int test(int...n){
            System.out.println(n);
    }

//注意：一个函数中只能有一个可变参数，且要放在最后面

带默认值参数

def test(n:Int=15,str:String="小白说"):Unit={
 
}

//一般我们也把带默认值的参数放在参数列表后面

参数带名调用函数
写参数时如果带名则可以不按顺序

def test(n:Int,str:String):Unit={
}

//调用
test(str="xiaobai",n=15)

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

    def sum(a:Int,b:Int):Int=a+b
    //注意lazy修饰的必须是val常量类型
    lazy val result:Int=sum(15,29)
    print(result)

函数至简原则：

匿名函数：
匿名函数就是不需要函数名，因为我们只关注它内部的实现，而不需要名称
匿名函数常作为参数使用

    //定义一个以函数为参数的函数
    //且作为参数的函数必须是String,Int两个参数，返回值为Unit
      def f(func:String=>Unit):Unit={
        func("你好呀")
      }
    //将一个匿名函数作为函数的参数
      f(name:String=>{print(name)})

传递匿名函数至简原则

简化后的

 f(print(_))

函数可以作为参数传递，也可以作为值传递，函数也可以作为一个返回值返回

实际示例
定义一个函数，只操作1，2这两个数，但是具体操作根据作为参数的函数决定

    //定义一个函数，只操作1，2这两个数，但是具体操作根据作为参数的函数决定
    def dualFunction(func:(Int,Int)=>Int):Int={
      func(1,2)
    }
    var add=(a:Int,b:Int)=>a+b
    var minus=(a:Int,b:Int)=>a-b
    print(dualFunction(minus))
    print(dualFunction(add))

定义一个函数，对数组每个元素都进行处理，把处理操作抽象出来，处理完成后的结果返回成一个新数组

    //定义一个函数，对数组每个元素都进行处理，把处理操作抽象出来，处理完成后的结果返回成一个新数组
    def arrayOperation(array: Array[Int],op:Int=>Int):Array[Int]={
      for (elem<-array)
        //yield简介对于for循环的每次迭代，yield都会生成一个将被记住的值。就像有一个你看不见的缓冲区，for循环的每一次迭代都会将另一个新的值添加到该缓冲区。
        //当for循环结束运行时，它将返回所有已赋值的集合。
        yield op(elem)
    }
    //定义一个 +10 的操作
    var array=arrayOperation(Array(1,6,9,4,3,7,5,1,80),_+10)
    for (elem <- array) {
      println(elem)
    }
println(array.mkString(","))

结果：

简化过程 函数作为参数

    def option(num: Int):Int={
       num+10
    }


    (num:Int)=>num+10


    //参数类型会通过形参自动推导
    num=>num+10


    _+10