闭包
- 如下 addMore 成为一个“闭包”。因为它引用到函数外面定义的变量。定义这个函数的过程，是将和这个自由变量捕获二构成一个封闭的函数。
scala> var more =1
more: Int = 1
scala> val addMore = (x:Int) => x + more
addMore: Int => Int = <function1>
scala> addMore (100)
res1: Int = 101
scala> more = 9999
more: Int = 9999
scala> addMore ( 10)
res2: Int = 10009
可变参数
- Scala中使用
*来知名该参数为重复参数
scala> def echo (args: Any *) =
| for (arg <- args) println(arg)
echo: (args: Any*)Unit
scala> val arr = Array("java","scala","python")
arr: Array[String] = Array(java,scala,python)
scala> echo ("Hello",123,true,arr)
Hello
123
true
[Ljava.lang.String;@2c282004
- 若要只传入数组的值，可用以下方法
scala> echo(arr: _*)
命名参数
- 顾名思义 就是在调用函数时，参数传入和函数定义刘表是一一对应，允许使用任意顺序。如下：
scala> def add(one: Double, two: Double) :Double = one + tow
add: (one: Double, two: Double) Double
scala> add(two=10, one=2)
res1: Double = 12.0
高阶函数
- 函数的参数也可以是另一个函数
val arr = Array("javaisgood", "thisscala", " 123456")
def strMatcher(matcher: (String) => Boolean) = {
for(str <- arr; if matcher(str))
yield str
}
def strEnding(str: String) = strMatcher(_.endsWith(str))
def strContaining(str: String) = strMatcher(_.contains(str))
def strRegex(str: String) = strMatcher(_.matches(str))
柯里化函数
- 柯里化是把接收多个参数变换成接收一个单一参数（最初函数的第一个参数）的函数，返回接收余下的参数而且返回结果的新函数的技术。
// common function
def add(x: Int, y: Int) = {
println("x: " + x)
println("y: " + y)
x + y
}
//curry function
def _add(x: Int)(y:Int) = {
println("_x: " + x)
println("_y: " + y)
x + y
}
// split
def first(x: Int) = (y: Int) => {
println("__x: " + x)
println("__y: " + y)
x + y
}
first: (x: Int)Int => Int
scala> val second=first(1)
second: Int => Int = <function1>
scala> second(2)
res1: Int = 3
scala> val onePlus = _add(1)_
onePlus: Int => Int = <function1>
- 其中
_作为第二参数列表的占位符
Call By Name & Call By Value
Call by value（传值调用）
使用 （变量 ：类型）
Call by name（传名调用）
使用 （变量 ： => 类型）
注意 ":" 和 "=>"之间一定要有空格
def main(args: Array[String]) {
// testOne
testCallByNameAndValue(1,testLoop(6))
// testTwo
testCallByNameAndValue(testLoop(6),1)
}
// x为传值调用，y为传名调用
def testCallByNameAndValue(x: Int,y: => Int) = {
println("scala")
1
}
def testLoop(a: Int):Int = {
for (i <- (0 until a)) println("Iteration" + i)
1
}
// results of execution
// testOne
scala
// testTwo
Iteration0
Iteration1
Iteration2
Iteration3
Iteration4
Iteration5
scala
总结：
Call By Value :无论方法是否使用该参数都要先将该参数的值计算出来再传入
Call By Name :只有在该参数被方法使用时才计算该参数的值
定义新的的控制结构
scala> def twice (op:Double => Double, x:Double) =op(op(x))
twice: (op: Double => Double, x: Double)Double
scala> twice(_ + 1, 5)
res0: Double = 7.0
- 在Scala中，如果调用的函数只有一个参数，可以使用
{}来代替()
