Scala函数

函数至简原则

所谓的至简原则，通过编译器的动态判定功能，将函数声明中能简化的地方全部都进行了简化。简单来说就是：能省则省。

1. 返回语句可以省略return关键字

object MyFunc {

    def main(args: Array[String]): Unit = {

        def func1(): String = {

            return "zhangsan"

        }

        def func2(): String = {

            "zhangsan"

        }

    }

}

1. 只有一条语句，可以省略{}

object MyFunc {

    def main(args: Array[String]): Unit = {

        def func1(): String = "zhangsan"

    }

}

1. 如果编译器可以推断出返回值类型，可以省略返回值类型

object MyFunc {

    def main(args: Array[String]): Unit = {

        def func1() = "zhangsan"

    }

}

1. 如果函数只有一个参数，可以省略参数列表，省略参数列表的情况下，调用函数时也需要省略

object MyFunc {

    def main(args: Array[String]): Unit = {

        def func1= "zhangsan"

        func1

        //调用出错

//func1 ()

    }

}

1. 省略等号

如果函数体中有明确的return语句，那么返回值类型不能省略

object MyFunc {

    def main(args: Array[String]): Unit = {

        def func1(): String = {

            return "zhangsan"

        }

        println(func1())

    }

}

如果函数体返回值类型明确为Unit, 那么函数体中即使有return关键字也不起作用

object MyFunc {

    def main(args: Array[String]): Unit = {

        def func1(): Unit = {

            return "zhangsan"

        }

        println(func1())

    }

}

如果函数体返回值类型声明为Unit, 但是又想省略，那么此时就必须连同等号一起省略

object MyFunc {

    def main(args: Array[String]): Unit = {

        def func1() {

            return "zhangsan"

        }

        println(func1())

    }

}

1. 省略名称和关键字

object MyFunc {

    def main(args: Array[String]): Unit = {

        () => {

            println("zhangsan")

        }

    }

}

高阶函数编程

所谓的高阶函数，其实就是将函数当成一个类型来使用。

1. 函数作为值

object MyFunc {

    def main(args: Array[String]): Unit = {

        def func1(): String = {

            "zhangsan"

        }

        //函数返回值赋值给a

        val a = func1

        //函数本身赋值给b

        val b = func1 _

        //函数本身赋值给c

val c : ()=>Unit = func1

        println(a)

        println(b)

    }

}

1. 函数作为参数

object MyFunc {

    def main(args: Array[String]): Unit = {

        def func1( i:Int ): Int = {

            i * 2

        }

        def func2( f : Int => Int ): Int = {

            f(10)

        }

        println(func2(func1))

    }

}

1. 函数作为返回值

object MyFunc {

    def main(args: Array[String]): Unit = {

        def func1( i:Int ): Int = {

            i * 2

        }

        def func2( ) = {

            func1 _

        }

        println(func2()(10))

    }

}

1. 匿名函数

object MyFunc {

    def main(args: Array[String]): Unit = {

        def func1( f:Int => Int ): Int = {

            f(10)

        }

        println(func1((x:Int)=>{x * 20}))

        println(func1((x)=>{x * 20}))

        println(func1((x)=>x * 20))

        println(func1(x=>x * 20))

        println(func1(_ * 20))

    }

}

1. 控制抽象

object MyFunc {

    def main(args: Array[String]): Unit = {

        def fun1(op: => Unit) = {

            op

        }

        fun1{

            println("xx")

        }

    }

}

1. 闭包

闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。

闭包通常来讲可以简单的认为是可以访问一个函数里面局部变量的另外一个函数。

object MyFunc {

    def main(args: Array[String]): Unit = {

        def func1() = {

            val i = 20

            def func2() = {

                i * 2

            }

            func2 _

        }

        println(func1()())

    }

}

1. 函数柯里化（Currying）

将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数

object MyFunc {

    def main(args: Array[String]): Unit = {

        def add(x:Int)(y:Int) = {

            x+y

        }

        println(add(10)(_))

        println(add(10)(2))

    }

}

函数柯里化的本质

def add(x:Int)=(y:Int)=>x+y

1. 惰性函数

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

object MyFunc {

    def main(args: Array[String]): Unit = {

        def func1(): String = {

            println("fun1...")

            "zhangsan"

        }

        lazy val a = func1()

        println("----------")

        println(a)

    }

}