1 前言

大家好，定制app开发我是楚生辉，定制app开发在未来的日子里我们一定制app开发起来学习相关的技术，定制app开发一起努力奋斗，定制app开发遇见更好的自己！

定制app开发本文详细的介绍了scala的匿名函数，有需要的小伙伴可以学习~

中定义匿名函数的语法很简单，箭头左边是参数列表，右边是函数体。

使用匿名函数后，我们的代码变得更简洁了,让我们程序员估计关注于逻辑处理

下面的就定义了一个接受一个Int类型输入参数,返回值为x+1匿名函数:

(x:Int) => x+11

2.快速入门

没有名字的函数就是匿名函数。(x:Int)=>{函数体}

x：表示输入参数类型；Int：表示输入参数类型；函数体：表示具体代码逻辑

在快速入门的案例中，我们定义了一个dualFunction函数，在这个函数中，传入一个函数作为参数，实现简单的加减运算

def main(args: Array[String]): Unit = {    // 定义一个二元运算函数，只操作1与2两个数，但是具体的运算通过参数传递    def dualFunction(fun:(Int,Int) => Int ) : Int = {        fun(1,2)    }    // 定义 add与minus两个匿名函数    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:Int,b:Int) => a + b))    println(dualFunction((a:Int,b:Int) => a - b))    // 因为a与b只出现过一次，所以直接可以用_来代替，如果顺序是b-a，我们可以转化为    // -a + b  也即 -_ + _    println(dualFunction(_ + _))    println(dualFunction(_ - _))}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3.案例实操

3.1 传递一个参数

需求 1：传递的函数有一个参数

传递匿名函数至简原则：

参数的类型可以省略，会根据形参进行自动的推导
类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过 1 的永远不能省略圆括号。
匿名函数如果只有一行，则大括号也可以省略
如果参数只出现一次，则参数省略且后面参数可以用_代替

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(","))}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

3.2 传递两个参数

需求 2：传递的函数有两个参数

object TestFunction {    def main(args: Array[String]): Unit = {        def calculator(a: Int, b: Int, op: (Int, Int) => Int): Int         = {            op(a, b)        }        // （1）标准版        println(calculator(2, 3, (x: Int, y: Int) => {x + y}))        // （2）如果只有一行，则大括号也可以省略        println(calculator(2, 3, (x: Int, y: Int) => x + y))        // （3）参数的类型可以省略，会根据形参进行自动的推导;        println(calculator(2, 3, (x , y) => x + y))        // （4）如果参数只出现一次，则参数省略且后面参数可以用_代替        println(calculator(2, 3, _ + _))    }}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.3 多层嵌套函数

定义一个函数func，它接受一个一个Int类型的参数，返回一个函数f1,它返回的函数fi，接受一个String类型的参数，同样返回一个函数f2，函数f2接收一个Char类型的参数，返回一个Boolean的值,如果传入0，空字符串，0就返回false

def main(args: Array[String]): Unit = {    def func(i: Int): String => (Char => Boolean) = {        def f1(s: String): Char => Boolean = {            def f2(c: Char): Boolean = {                if (i == 0 && s == "" && c == '0') false else true            }            f2        }        f1    }    println(func(0)("")('0'))    println(func(0)("")('1'))}// 返回值为 falsetrue1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18