scala基础-函数的小体会

1、函数的定义

函数可以不依赖于类独立存在

scala> def fun1(name : String){
     |    println("name is " + name)
     | }
fun1: (name: String)Unit

scala> val fun2 = fun1 _
fun2: String => Unit = $$Lambda$1016/35032559@2ca1e49a

scala> fun2("Jerry")
name is Jerry

scala> var fun3 = fun2
fun3: String => Unit = $$Lambda$1016/35032559@2ca1e49a

scala> fun3("Tom")
name is Tom

2、匿名函数

函数可以没有名称，直接赋给变量
变量 = 参数 => 函数体

scala> val fun4 = (name : String) => println("My name is " + name)
fun4: String => Unit = $$Lambda$1059/502458215@4d0d568f

scala> fun4("Marry")
My name is Marry

3、高阶函数

3.1 函数的参数也可以是函数

scala> def fun5(num : Int): Int={num + 5}
fun5: (num: Int)Int

scala> def fun6(func:(Int)=>Int, num: Int):Int = {func(num)}
fun6: (func: Int => Int, num: Int)Int

scala> fun6(fun5,5)
res9: Int = 10

与匿名函数的配合使用：

scala> def func(func:(Int)=>Int,num:Int){println(func(num))}
func: (func: Int => Int, num: Int)Unit

scala> func((num:Int)=>num + 5,5)
10
// (num:Int)=>num + 5  为匿名函数

3.2 函数的返回值也可以是函数

scala> def funcReturn(nameA:String)=(nameB:String)=>println(nameA + "\t" + nameB)
//         函数名        函数        返回函数参数   函数体
funcReturn: (nameA: String)String => Unit

scala> val f1 = funcReturn("Jerry")
f1: String => Unit = $$Lambda$1121/103074823@289e4d14

scala> val f2 = f1("Tom")
Jerry   Tom
f2: Unit = ()

3.3 高阶函数的写法

如果在函数的参数作用的函数体内，只使用一次这个参数的具体的值的话，那么参数的具体的名称可使用“_”下划线来代替：

scala> def func(func:(Int)=>Int,num:Int){println(func(num))}
func: (func: Int => Int, num: Int)Unit
// 匿名函数的调用
scala> func((num:Int)=>num + 5,5)
10
// 因为只有一个参数，可根据类型推倒得到匿名函数的num参数类型，故省略“：Int”
scala> func((num)=>num + 5,5)
10
// 因为只有一个参数，所以可以省略()
scala> func(num=>num + 5,5)
10
/*因为在函数的参数作用的函数体内，只使用一次这个参数的具体的值的话，
那么参数的具体的名称可使用“_”下划线来代替*/
scala> func(_ + 5,5)
10

scala多种写法示例2：

scala> val array = Array(1, 2, 3, 4, 5, 6)
array: Array[Int] = Array(1, 2, 3, 4, 5, 6)
// 使用map对每个元素进行操作
scala> array.map(eachItem => eachItem * 2 )
res31: Array[Int] = Array(2, 4, 6, 8, 10, 12)
// 因为只有一个参数，故可以使用“_”来简写
scala> array.map(_ * 2 )
res32: Array[Int] = Array(2, 4, 6, 8, 10, 12)
// foreach的使用，对map后的每个元素进行操作，只有一个参数，故可使用“_”
scala> array.map(_ * 2 ).foreach(println(_))
2
4
6
8
10
12
// 只有一个参数也可以省略"()"
scala> array.map(_ * 2 ).foreach(println _)
2
4
6
8
10
12
// 同样因为只有一个参数，且无其他操作，可以完全省略
scala> array.map(_ * 2 ).foreach(println)
2
4
6
8
10
12
// 加入filter的使用
scala> array.map(_ * 2 ).filter(_ % 3 == 0)
res36: Array[Int] = Array(6, 12)

scala> array.map(_ * 2 ).filter(_ % 3 == 0).foreach(println)
6
12

reduce的使用：

scala> (1 to 100).reduceLeft(_+_)
res11: Int = 5050
// _ + _ 第一个"_" 为1 ，第二个"_" 为2，相加的结果3作为第三个参数传入，3为第四参数，得到3 + 3

4、闭包

函数的变量超出函数作用域的时候依然可以对函数的变量进行使用，我们称之为闭包。

scala> def funcReturn(nameA:String)=(nameB:String)=>println(nameA + "\t" + nameB)
//         函数名        函数        返回函数参数   函数体
funcReturn: (nameA: String)String => Unit

scala> val f1 = funcReturn("Jerry")
f1: String => Unit = $$Lambda$1121/103074823@289e4d14

scala> val f2 = f1("Tom")
Jerry   Tom
f2: Unit = ()

Jerry作为funcReturn的参数，可以在f2中继续被访问到。

5、柯里化函数

// 对应一个常规函数计算x+y
scala> def sum(x:Int, y:Int)=x + y
sum: (x: Int, y: Int)Int

scala> sum(1, 2)
res0: Int = 3

// 以函数作为返回值定一个函数计算x + y，也就是柯里化函数
scala> def sumCurrying(x: Int)=(y: Int)=>x + y
sumCurrying: (x: Int)Int => Int

scala> sumCurrying(1)(2)
res1: Int = 3

// 链式函数定义一个x+y,柯里化函数
scala> def sumCurryingBetter(x: Int)(y: Int)=x+y
sumCurryingBetter: (x: Int)(y: Int)Int

// 以下是两种调用方式
scala> sumCurryingBetter(1)(2)
res2: Int = 3

scala> val resn = sumCurryingBetter(1)_
resn: Int => Int = $$Lambda$1151/750444785@3bf4b018

scala> resn(2)
res3: Int = 3