1 前言

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

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

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

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

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

(x:Int) => x+1

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(_ - _))
}

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

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, _ + _))
    }
}

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'))
}

// 返回值为 
false
true

func(0)("")('0') func(0)代表f1，func(0)(“”)则代表的f2