spark中函数和方法定义虽然差不多，但是函数要更加灵活，用的最多的是匿名函数写法，尤其在链式编程的时候尤为突出。

 

函数定义方法多样

1.规范化写法,scala 函数的返回值是最后一行代码；

def addInt(a:Int,b:Int) : Int = {
var total : Int = a + b

return total

}

2.不写明返回值的类型，程序会自行判断，最后一行代码的执行结果为返回值；

def addInt(a:Int,b:Int) = {
a+b

}

3。省略返回值类型和等于号，返回的是（）；

def addInt(a:Int,b:Int){
a+b

} 

4.函数只有一行的写法；

def addInt (a:Int,b:Int) = x + y

 

上述这些都和方法的用法差不多，函数最主要的下面这种写法

5.最简单写法：def ,{ },返回值都可以省略，此方法在spark编程中经常使用。

val addInt = (x: Int,y: Int) => x + y 
表示定义函数 addInt ，输入参数有两个分别为x,y，且均为Int类型，返回值为两者的和，类型为Int
这种写法也叫匿名函数

object ClassTest{
  def main(args:Array[String]):Unit={
    var func = (x:Int)=> {　　//或者直接(x:Int)=>x+3
      x+3
    }
    println(func(3))
  }
}

 

闭包：就是函数的嵌套，即在定义一个函数的时候，包含了另外一个函数的定义，在内函数中，可以访问外函数的变量

  def func(n:Int):Int={
    var i=10
    var InnerFunc=(x:Int)=>x * i
    return InnerFunc(n)
  }
  
  def main(args:Array[String]):Unit={
    println(func(3))
  }

这里我们引入一个*变量 i，这个变量定义在闭包函数外面。

这样定义的函数变量 InnerFunc 称为一个"闭包"，因为它引用到函数外面定义的变量，定义这个函数的过程是将这个*变量捕获而构成一个封闭的函数。

 

函数的柯里化

函数的柯里化是指将原来是多个参数的函数变为一个参数的过程，但是这个一个参数的函数返回的是以第二参数为参数的匿名函数：

可以看这篇博客的详细说明

https://zhuanlan.zhihu.com/p/98096436

 

懒惰函数

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

2）案例实操

package com.atguigu.chapter5

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

lazy val res = sum(10, 30)
println("-----------")
println("res=" + res)
}

def sum(n1: Int, n2: Int): Int = {
println("sum被执行")
return n1 + n2
}

}

输出结果：
-----------
sum被执行
res=40