Chiriri's blog
Iekr
2021-12-15
目录

函数式编程

# 函数式编程

解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用这些封装好的步骤，解决问题。

Scala 语言是一个完全函数式编程语言。万物皆函数。

函数的本质：函数可以当做一个值进行传递

# 函数和方法的区别

  1. 核心概念
    1. 为完成某一功能的程序语句的集合，称为函数。
    2. 类中的函数称之方法。
    3. 定义在方法或者函数内部 称为函数

（1）Scala 语言可以在任何 的语法结构中声明任何的语法

（2）函数没有重载和重写的概念；方法可以进行重载和重写

（3）Scala 中函数可以嵌套定义

object TestFunction {

    // (2)方法可以进行重载和重写，程序可以执行
    def main(): Unit = {

    }

    def main(args: Array[String]): Unit = {
        // （1）Scala语言可以在任何的语法结构中声明任何的语法
        import java.util.Date
        new Date()

        // (2)函数没有重载和重写的概念，程序报错
        def test(): Unit ={
            println("无参，无返回值")
        }
        test()

        def test(name:String):Unit={
            println()
        }

        //（3）Scala中函数可以嵌套定义
        def test2(): Unit ={

            def test3(name:String):Unit={
                println("函数可以嵌套定义")
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# 函数定义

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

        // 函数1：无参，无返回值
        def test1(): Unit ={
            println("无参，无返回值")
        }
        test1()

        // 函数2：无参，有返回值
        def test2():String={
            return "无参，有返回值"
        }
        println(test2())

        // 函数3：有参，无返回值
        def test3(s:String):Unit={
            println(s)
        }
        test3("jinlian")

        // 函数4：有参，有返回值
        def test4(s:String):String={
            return s+"有参，有返回值"
        }
        println(test4("hello "))


        // 函数5：多参，无返回值
        def test5(name:String, age:Int):Unit={
            println(s"$name, $age")
        }
        test5("dalang",40)
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

# 函数参数

  1. 可变参数
  2. 如果参数列表中存在多个参数，那么可变参数一般放置在最后
  3. 参数默认值，一般将有默认值的参数放置在参数列表的后面
  4. 带名参数
 // （1）可变参数
        def test( s : String* ): Unit = {
            println(s)
        }

        // 有输入参数：输出 Array
        test("Hello", "Scala")

        // 无输入参数：输出List()
        test()

        // (2)如果参数列表中存在多个参数，那么可变参数一般放置在最后
        def test2( name : String, s: String* ): Unit = {
            println(name + "," + s)
        }

        test2("jinlian", "dalang")

        // (3)参数默认值
        def test3( name : String, age : Int = 30 ): Unit = {
            println(s"$name, $age")
        }

        // 如果参数传递了值，那么会覆盖默认值
        test3("jinlian", 20)

        // 如果参数有默认值，在调用的时候，可以省略这个参数
        test3("dalang")

        // 一般情况下，将有默认值的参数放置在参数列表的后面
        def test4( sex : String = "男", name : String ): Unit =      {
            println(s"$name, $sex")
        }
		// Scala函数中参数传递是，从左到右
        //test4("wusong") 

        //（4）带名参数
        test4(name="ximenqing")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

# 函数至简原则（重点）

函数至简原则：能省则省

  1. return 可以省略，Scala 会使用函数体的最后一行代码作为返回值
  2. 如果函数体只有一行代码，可以省略花括号
  3. 返回值类型如果能够推断出来，那么可以省略（: 和返回值类型一起省略）
  4. 如果有 return，则不能省略返回值类型，必须指定
  5. 如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用
  6. Scala 如果期望是无返回值类型，可以省略等号
  7. 如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
  8. 如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
  9. 如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
object TestFunction {

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

        // （0）函数标准写法
        def f( s : String ): String = {
            return s + " jinlian"
        }
        println(f("Hello"))

        // 至简原则:能省则省

        //（1） return可以省略,Scala会使用函数体的最后一行代码作为返回值
        def f1( s : String ): String =  {
            s + " jinlian"
        }
        println(f1("Hello"))

        //（2）如果函数体只有一行代码，可以省略花括号
        def f2(s:String):String = s + " jinlian"


        //（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
        def f3( s : String ) = s + " jinlian"
        println(f3("Hello3"))

        //（4）如果有return，则不能省略返回值类型，必须指定。
        def f4() :String = {
            return "ximenqing4"
        }
        println(f4())

        //（5）如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用
        def f5(): Unit = {
            return "dalang5"
        }
        println(f5())

        //（6）Scala如果期望是无返回值类型,可以省略等号
        // 将无返回值的函数称之为过程
        def f6() {
            "dalang6"
        }
        println(f6())

        //（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
        def f7() = "dalang7"
        println(f7())
        println(f7)

        //（8）如果函数没有参数列表，那么小括号可以省略,调用时小括号必须省略
        def f8 = "dalang"
        //println(f8())
        println(f8)

        //（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
        def f9 = (x:String)=>{println("wusong")}

        def f10(f:String=>Unit) = {
            f("")
        }

        f10(f9)
        println(f10((x:String)=>{println("wusong")}))
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

# 函数高阶用法

函数可以作为值进行传递

//（1）调用foo函数，把返回值给变量f

        //val f = foo()
        val f = foo
        println(f)

        //（2）在被调用函数foo后面加上 _，相当于把函数foo当成一个整体，传递给变量f1
        val f1 = foo _

        foo()
        f1()
		//（3）如果明确变量类型，那么不使用下划线也可以将函数作为整体传递给变量
		var f2:()=>Int = foo 
    }

    def foo():Int = {
        println("foo...")
        1
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

函数可以作为参数进行传递

 // （1）定义一个函数，函数参数还是一个函数签名；f表示函数名称;(Int,Int)表示输入两个Int参数；Int表示函数返回值
    def f1(f: (Int, Int) => Int): Int = {
        f(2, 4)
    }
    
    // （2）定义一个函数，参数和返回值类型和f1的输入参数一致
    def add(a: Int, b: Int): Int = a + b
    
    // （3）将add函数作为参数传递给f1函数，如果能够推断出来不是调用，_可以省略
    println(f1(add))
println(f1(add _))
//可以传递匿名函数
1
2
3
4
5
6
7
8
9
10
11
12

函数可以作为函数返回值返回

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

}
f2 _
}

val f = f1()
// 因为f1函数的返回值依然为函数，所以可以变量f可以作为函数继续调用
f()
// 上面的代码可以简化为
f1()()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 匿名函数

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

（2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过 1 的永远不能省略圆括号。

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

（4）如果参数只出现一次，则参数省略且后面参数可以用_代替

（5）如果可以推断出，println 是一个函数体，而不是调用语句，那么 (_) 可以省略

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

        // （1）定义一个函数：参数包含数据和逻辑函数
        def operation(arr: Array[Int], op: Int => Int) = {
            for (elem <- arr) yield op(elem)
        }

        // （2）定义逻辑函数
        def op(ele: Int): Int = {
            ele + 1
        }

        // （3）标准函数调用
        val arr = operation(Array(1, 2, 3, 4), op)
        println(arr.mkString(","))

        // （4）采用匿名函数
        val arr1 = operation(Array(1, 2, 3, 4), (ele: Int) => {
            ele + 1
        })
        println(arr1.mkString(","))

        // （4.1）参数的类型可以省略，会根据形参进行自动的推导;
        val arr2 = operation(Array(1, 2, 3, 4), (ele) => {
            ele + 1
        })
        println(arr2.mkString(","))

        // （4.2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过1的永远不能省略圆括号。
        val arr3 = operation(Array(1, 2, 3, 4), ele => {
            ele + 1
        })
        println(arr3.mkString(","))

        // (4.3) 匿名函数如果只有一行，则大括号也可以省略
        val arr4 = operation(Array(1, 2, 3, 4), ele => ele + 1)
        println(arr4.mkString(","))

        //（4.4）如果参数只出现一次，则参数省略且后面参数可以用_代替
        val arr5 = operation(Array(1, 2, 3, 4), _ + 1)
        println(arr5.mkString(","))
    	
    	//（5）如果可以推断出，println是一个函数体，而不是调用语句，那么(_)可以省略
    	
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

# 函数柯里化和闭包

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

函数柯里化：把一个参数列表的多个参数，变成多个参数列表。

object TestFunction {

    def main(args: Array[String]): Unit = {
        def f1()={
			var a:Int = 10
            def f2(b:Int)={
                a + b
            }
            f2 _
        }

        // 在调用时，f1函数执行完毕后，局部变量a应该随着栈空间释放掉
        val f = f1() 

        // 但是在此处，变量a其实并没有释放，而是包含在了f2函数的内部，形成了闭合的效果
        println(f(3))

        
        println(f1()(3))

        // 函数柯里化，其实就是将复杂的参数逻辑变得简单化,函数柯里化一定存在闭包
        def f3()(b:Int)={
             a + b
        }

        println(f3()(3))
        
        
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# 递归

一个函数 / 方法在函数 / 方法体内又调用了本身，我们称之为递归调用

object TestFunction {

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

        // 阶乘
        // 递归算法
        // 1) 方法调用自身
        // 2) 方法必须要有跳出的逻辑
        // 3) 方法调用自身时，传递的参数应该有规律
        // 4) scala中的递归必须声明函数返回值类型

        println(test(5))
    }

    def test(i : Int) : Int = {
        if (i == 1) {
            1
        } else {
            i * test(I - 1)
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 控制抽象

值调用：把函数运行后的值传递过去

object TestControl {

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

        def f = ()=>{
            println("f...")
            10
        }

        foo(f())
    }

    def foo(a: Int):Unit = {
        println(a)
        println(a)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

名调用：把代码块传递过去

object TestControl {

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

        def f = ()=>{
            println("f...")
            10
        }

        foo(f())
    }

	//def foo(a: Int):Unit = {
    //代码块写法为 变量命名 => 返回值类型   a: =>Int
    def foo(a: =>Int):Unit = {//注意这里变量a没有小括号了 变成 a: =>Int
        println(a)
        println(a)
    }
}
//输出结果：
//f...
//10
//f...
//10
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Java 只有值调用；Scala 既有值调用，又有名调用

自定义一个 while 循环

object TestFunction {

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

        var i:Int = 1
        myWhile(i <= 10){
            println(i)
            i +=1
        }
    }

    def myWhile(condition: =>Boolean)(op: =>Unit):Unit={

        if (condition){
            op
            myWhile(condition)(op)
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 惰性函数

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

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

    lazy val res = sum(10, 30) //通过lazy关键字
    println("----------------")
    println("res=" + res)
}

def sum(n1: Int, n2: Int): Int = {
    println("sum被执行。。。")
    return n1 + n2
}
1
2
3
4
5
6
7
8
9
10
11

输出结果

----------------
sum被执行。。。
res=40
1
2
3
编辑 (opens new window)
上次更新: 2023/12/06, 01:31:48
流程控制
面向对象

← 面向对象→

最近更新
01
k8s
06-06
02
进程与线程
03-04
03
计算机操作系统概述
02-26
更多文章>
Theme by Vdoing | Copyright © 2022-2025 Iekr | Blog