Scala从入门到精通02之函数
1. 函数基础
1.1. 函数基本语法
package com.michael.learn.day02
object FunctionBasic {
def main(args: Array[String]): Unit = {
// 1. define a basic function and call the function
def f(arg: String):Unit = {
println(arg)
}
f("This is a string as the para")
}
}
1.2. 函数和方法的区别
（1）为完成某一功能的程序语句的集合，称为函数。
（2）类中的函数称之方法。
package com.michael.learn.day02
object DifferrenceBetweenFuncAndMethod {
// 1. The method can be override and overwrite
def main(): Unit = {
}
def main(args: Array[String]): Unit = {
// 2. You can declare any syntax in any syntax structure with Scala language
import java.util.Date
new Date()
// 3. Function can not be override and overwrite
def testFunction(): Unit = {
println("No para, No return value")
}
testFunction()
// def testFunction(name:String): Unit = { There is an error, cause function can not be override
// println(name)
// }
// testFunction("michael test")
// 3. You can declare nested functions in Scala language
def testFunction02():Unit = {
def testFunction03(name: String):Unit = {
println("The name you just input is : " + name)
}
testFunction03("michael")
}
testFunction02()
}
}
1.3. 函数定义
package com.michael.learn.day02
object FunctionPara {
def main(args: Array[String]): Unit = {
// 1. Function01: no para, no return
def test1():Unit = {
println("No para, No return value")
}
test1() // No para, No return value
// 2. Function02: No para, return a string
def test2(): String = {
return "No para but return value"
}
println(test2()) // No para but return value
// 3. Function03: Para, no return
def test3(s:String): Unit = {
println("The input string is : "+s)
}
test3("michael test") // The input string is : michael test
// 4. Function04: Para, return value
def test4(s:String): String = {
return s
}
println(test4("input a string and get it back")) // input a string and get it back
// 5. Function05: multiple paras, no return
def test5(name:String, age:Int): Unit = {
println(s"$name, $age")
}
test5("michael", 18) // michael, 18
}
}
1.4. 函数参数
package com.michael.learn.day02
object FunctionPara {
def main(args: Array[String]): Unit = {
// 1. variable parameter
def test(str:String*):Unit = {
println(str)
}
test("hello", "scala") // WrappedArray(hello, scala)
test() // List()
// 2. The variable para is usually placed last if there are more than one para in the para list
def test2(first:String, multiple:String*):Unit = {
println(first + ", " + multiple)
}
test2("first para", "second", "third") // first para, WrappedArray(second, third)
// 3. Default value of para
def test3(name:String = "first", age:Int = 15):Unit = {
println(s"$name, $age")
}
test3("michael", 18) // michael, 18
test3() // first, 15
test3(age=19) // first, 19
}
}
1.5. 函数置简原则
函数至简原则：能省则省
1.5.1. 至简原则细节
- return 可以省略，Scala 会使用函数体的最后一行代码作为返回值
- 如果函数体只有一行代码，可以省略花括号
- 返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
- 如果有 return，则不能省略返回值类型，必须指定
- 如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用
- Scala 如果期望是无返回值类型，可以省略等号
- 如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
- 如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
- 如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
1.5.2. 代码实例
package com.michael.learn.day02
object FunctionMinimizationPrinciple {
def main(args: Array[String]): Unit = {
// Standard function declare
def f(s:String):String = {
return s + "function return"
}
println(f("the standard function ")) // the standard function function return
// 1. return can be omitted in Scala
def f1(s:String):String = {
s + "return is omitted"
}
println(f1("the function without return ")) // the function without return return is omitted
// 2. {} can be omitted if there is only one line code
def f2(s:String):String = s + "{} is omitted"
println(f2("omit brace")) // omit brace{} is omitted
// 3. : and return_type can be omitted if the return value type can be inferred
def f3(s:String) = s + "return type is omitted"
println(f3("omit return type")) // omit return typereturn type is omitted
// 4. return type can not be omitted if there is a return
def f4(s:String):String = return s + "{} is omitted"
println(f4("Don't omit return value")) // Don't omit return value{} is omitted
// 5. The return does not work if return type is Unit
def f5(s:String):Unit = return s + "return does not work"
println(f5("Use unit")) // ()
// 6. = can be omitted if there is no return value
def f6() {"= is omitted"}
println(f6()) // ()
// 7. () can be omitted when call the func if there is no para when defined with para list
def f7():String = {"no para"}
println(f7()) // no para
println(f7) // no para
// 8. () must be omitted when call the func if defined without para list
def f8:String = {"no para list"}
println(f8) // no para list
// println(f8()) // error
// 9. def can be omitted if only care about logic process
def f9 = (x:String) => {println(x + "new function define way with =>")}
def f10(f:String => Unit) = {
f("")
}
f10(f9) // new function define way with =>
println(f10((x:String) => println("def is omitted"))) // def is omitted
}
}
2.函数高级
2.1. 高阶函数
package com.michael.learn.day02
object AdvancedFunction {
def main(args: Array[String]): Unit = {
// 1. call func
foo() // foo is called............
// 2. call foo and give the return value to the variable f
val f = foo() // foo is called............
println(f) // return a string
// 3. passing the func foo as a whole to the variable f1 is the same as passing the func foo as a whole
val f1 = foo _
foo() // foo is called............
f1() // foo is called............
// 4. The _ can be omitted if the return type is specified
val f2:() => String = foo
f2() // foo is called............
// 5. func can be the para of another func
def f3(foo2:(Int, Int) => Int):Int = {
foo2(2, 4)
}
def add(a:Int, b:Int):Int = a + b
println(f3(add _))
println(f3(add))
// 6. func can be the return value
def foo3() = {
def foo4() = {
println("the inner func is called")
}
foo4 _
}
val f4 = foo3()
f4() // the inner func is called
foo3()() // the inner func is called
}
// define func
def foo():String = {
println("foo is called............")
return "return a string"
}
}
2.2. 匿名函数
没有名字的函数就是匿名函数。
(x:Int)=>{函数体} x：表示输入参数类型；Int：表示输入参数类型；函数体：表示具体代码逻辑
2.2.2. 匿名函数基础推导
package com.michael.learn.day02
object AnonymousFunc {
def main(args: Array[String]): Unit = {
// 1. anonymous func usage
def operation(arr: Array[Int], op:Int => Int) = {
for (elem <- arr) yield op(elem)
}
def op(ele:Int):Int = {
ele + 1
}
val arr = operation(Array(1, 2, 3, 4), op)
println(arr.mkString(",")) // 2,3,4,5
// 1.1. anonymous func01
val arr1 = operation(Array(1, 2, 3, 4), (ele:Int) => {ele+1})
println(arr1.mkString(",")) // 2,3,4,5
// 1.2. anonymous func02 : omit para type
val arr2 = operation(Array(1, 2, 3, 4), (ele) => ele + 1)
println(arr2.mkString(",")) // 2,3,4,5
// 1.3. anonymous func03 : omit ()
val arr3 = operation(Array(1, 2, 3, 4), ele => ele + 1)
println(arr3.mkString(",")) // 2,3,4,5
// 1.4. anonymous func04 : omit {}
val arr4 = operation(Array(1, 2, 3, 4), (ele) => ele + 1)
println(arr4.mkString(",")) // 2,3,4,5
// 1.5. anonymous func05 : omit the argument and the following argument can be replaced by _ if the argument appears only once
val arr5 = operation(Array(1, 2, 3, 4), _ + 1)
println(arr5.mkString(",")) // 2,3,4,5
// 2. anonymous func usage02
def calculator(a:Int, b:Int, op:(Int, Int) => Int):Int = {
op(a, b)
}
println(calculator(2, 3, (x:Int, y:Int) => {x + y})) // 5
println(calculator(2, 3, (x:Int, y:Int) => x + y)) // 5
println(calculator(2, 3, (x, y) => x + y)) // 5
println(calculator(2, 3, _ + _)) // 5
}
}
2.2.2. 匿名函数的实例
package com.michael.learn.day02
import scala.collection.mutable.ArrayBuffer
object AdvancedFuncInstance {
def main(args: Array[String]): Unit = {
// 1. map
def map(arr:Array[Int], op: Int => Int) = {
for(ele <- arr) yield op(ele)
}
val arr = map(Array(1, 2, 3, 4), x => x*x)
println(arr.mkString(",")) // 1,4,9,16
// 2. filter
def filter(arr:Array[Int], op:Int => Boolean) = {
var arr1:ArrayBuffer[Int] = ArrayBuffer[Int]()
for(ele <- arr if op(ele)){
arr1.append(ele)
}
arr1.toArray
}
val arr2 = filter(Array(1, 2, 3, 4), _ % 2 == 1)
println(arr2.mkString(",")) // 1,3
// 3. reduce
def reduce(arr:Array[Int], op: (Int, Int) => Int) = {
var init:Int = arr(0)
for(ele <- 1 to arr.length){
init = op(init,ele)
}
init
}
val arr3 = reduce(Array(1, 2, 3, 4), _ * _)
println(arr3) // 24
}
}
2.3. 函数柯里化&闭包
闭包： 如果一个函数，访问到了它的外部（局部）变量的值，那么这个函数和他所处的环境，称为闭包
函数柯里化： 把一个参数列表的多个参数，变成多个参数列表。
package com.michael.learn.day02
object FuncClosure {
def main(args: Array[String]): Unit = {
// 1. closure
def f1() = {
var a:Int = 10
def f2(b:Int) = {
a + b
}
f2 _
}
// 在调用时，f1 函数执行完毕后，局部变量 a 应该随着栈空间释放掉
// 但是在此处，变量 a 其实并没有释放，而是包含在了 f2 函数的内部，形成了闭合的效果
val f = f1()
println(f(3)) // 13
println(f1()(3)) // 13
// 2. func currying
var c:Int = 10
def f4()(b:Int)= {
c + b
}
println(f4()(3)) // 13
}
}
2.4. 递归
一个函数/方法在函数/方法体内又调用了本身，我们称之为递归调用
package com.michael.learn.day02
object Recursion {
def main(args: Array[String]): Unit = {
println(test(5)) // 120
}
// scala 中的递归必须声明函数返回值类型
def test(i:Int): Int ={
if (i == 1){
1
}else {
i * test(i -1)
}
}
}
2.5. 控制抽象
2.5.1. 值调用：把计算后的值传递过去
2.5.2. 名调用：把代码传递过去
package com.michael.learn.day02
object ControlAbstract {
def main(args: Array[String]): Unit = {
// 1. call func value
def f = () => {
println("f is called")
10
}
foo(f())
// 2. call func name
foo2(f())
// 3. implement your own while loop
var i :Int = 1
michalWhile(i <= 10){
println(i)
i +=1
}
}
def foo(a:Int):Unit = {
println(a)
}
def foo2(a: => Int):Unit = {
println(a)
}
def michalWhile(condition: => Boolean)(op: => Unit):Unit = {
if (condition){
op
michalWhile(condition)(op)
}
}
}
2.6. 惰性加载
当函数返回值被声明为 lazy 时，函数的执行将被推迟，直到我们首次对此取值，该函数才会执行。这种函数我们称之为惰性函数。
package com.michael.learn.day02
object LazyLoadFunc {
def main(args: Array[String]): Unit = {
lazy val res = sum(100, 3)
println("========= separator ============")
println("res" + res)
/* console result
========= separator ============
sum func is called
res103
*/
}
def sum(a:Int, b:Int):Int = {
println("sum func is called")
a + b
}
}
注意：lazy 不能修饰 var 类型的变量