scala函数整理

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

这里的写法是省略了变量类型之后的写法

var func : Int =>Int =(x:Int)=>{x+3}

函数字面量的一些简单写法看这篇博客

https://www.w3cschool.cn/scaladevelopmentguide/u6s21jbe.html

函数和方法最大的区别是函数可以作为参数传入方法中，即使有一些方法看似直接调用名字也能作为传参，但是内部已经被修改成函数了。

这是函数和方法的互相调用

object FunctionAndMethodDifferent {

  //在函数内容调用一个已经存在的方法
  val f = (a: Int) => {
    //val r = m(a)
    //r
    m(a)
  }
  //定义一个函数
  val ff = (x: Int) => x * x
  //定义一个方法
  //方法中调用函数
  def mm(a: Int) = {
    //val r = ff(a)
    //r
    ff(a)
  }

  def m(x: Int): Int = {
    println("doit")
    x * x
  }
  def main(args: Array[String]): Unit = {

    val arr = Array(1,2,3,4,5)
    arr.map(m)
    //数组的map方法，要求传入一个函数，输入一个参数，返回一个值
    //为什么传入一个m就是可以的呢？
    //因为实际上，你传入的是一个方法名，scala帮你转换成函数，实际传入的就是一个函数
    val f = m _ //生成了一个函数，整函数中调用了m方法
    arr.map(f)
    arr.map(m _)

    //m _ 这种语法，到底是生成了一个跟m方法运算逻辑一样的函数，还是整函数调用了m方法呢
    //经过测试，将方法转换后生成了一个新的函数，函数中调用了该方法
    val func =  m _

    val r = func(5)

    println(r)
  }
}

这是函数作为参数被调用

object MethodDemo {
  def m(f: Int => String, x: Int): Unit = {
    val res = f(x)
    println(res)
  }

  def m2(f: (Int, Double) => Double, a: Int, b: Double): Unit = {
    val r = f(a, b)
    println(r)
  }
  def main(args: Array[String]): Unit = {

    //调用一个自己定义的方法，这个方法可以接收一个函数

    m(x => x.toString + "DOIT", 888)

    m2((x, y) => x * y, 5, 6.6)
  }
}

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

  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

 

常用函数链接

https://blog.csdn.net/qq_26442553/article/details/79026281