4、Scala函式式基礎
一、內建控制結構
1、if表示式
val filenameNice = if (!args.isEmpty) args(0) else "default.txt"
2、while迴圈
不管是while還是do...while，我們都不能叫做表示式，而應該叫做迴圈，因為它們不會計算出一個新值。它們的值型別是Unit，在scala中Unit和()是相等的
def gcdLoop(x: Long, y: Long): Long = {
var a = x
var b = y
while (a != 0) {
val temp = a
a = b % a
b = temp
}
b
}
do...while...表示式
var line = ""
do {
line = scala.io.StdIn.readLine()
println("Read: " + line)
} while (line != "")
在scala中給var重新賦值，永遠都是返回()(即Unit)
() != ""將永遠返回true
var tempLine = ""
while ((tempLine = scala.io.StdIn.readLine()) != "") // This doesn't work!
println("Read: " + tempLine)
因為while迴圈不計算出值，所以while的程式碼不那麼的函式式，一般都會含有var變數，
scala選擇保留while是因為有些場景使用while的程式碼的可讀性還是很強的
採用遞迴來消除掉var
def gcd(x: Long, y: Long): Long =
if (y == 0) x else gcd(y, x % y)
3、for表示式
用for表示式迭代一個任意集合
val filesHere = (new java.io.File(".")).listFiles
for (file <- filesHere)
println(file)
for表示式中的過濾
for (
file <- filesHere
if file.isFile
if file.getName.endsWith(".scala")
) println(file)
巢狀迭代(nested iteration)
def grep(pattern: String) =
for (
file <- filesHere
if file.getName.endsWith(".scala");
line <- fileLines(file)
if line.trim.matches(pattern)
) println(file + ": " + line.trim)
可以在迭代的過程中，繫結中間值到一個變數
上面的()可以換成{}，這樣每一個語句後面的分號就可以省略
def grepBindValue(pattern: String) =
for {
file <- filesHere
if file.getName.endsWith(".scala")
line <- fileLines(file)
trimmed = line.trim
if trimmed.matches(pattern)
} println(file + ": " + trimmed)
for ... yield ... 可以生成一個新的集合
//返回的是Array，是因為filesHere的型別是Array
def scalaFiles: Array[File] =
for {
file <- filesHere
if file.getName.endsWith(".scala")
} yield file
val forLineLengths: List[Int] =
for {
file <- filesHere.toList
if file.getName.endsWith(".scala")
line <- fileLines(file)
trimmed = line.trim
if trimmed.matches(".*object.*")
} yield trimmed.length
4、異常處理
scala中拋異常使用throw關鍵字，異常的捕獲用catch關鍵字。捕獲到異常後，可以計算並返回一個值
val n = 5
val half: Int =
if (n % 2 == 0)
n / 2
else
throw new RuntimeException("n must be even")
println(half)
try {
//val f = new FileReader("input.txt") //這個會拋FileNotFoundException
// Use and close file
throw new IOException("test")
} catch {
case e @(_: FileNotFoundException | _: IOException) => {
// Handle missing file
println("All Exception = " + e.getMessage)
}
case ex: Exception => {
// Handle other I/O error
println("IOException = " + ex.getMessage)
}
}
val file = new FileReader("input.txt")
try {
// Use the file
} finally {
file.close() // Be sure to close the file
}
5、break和continue
非得使用break的話，我們可以使用scala.util.control中的break
import scala.util.control.Breaks._
import java.io._
val in = new BufferedReader(new InputStreamReader(System.in))
breakable {
while (true) {
println("? ")
if (in.readLine() == "") break
}
}
二、函式
1、本地函式。定義在函式內部的函式為本地函式，智慧被此函式內部呼叫。
def processFile(filename: String, width: Int) = {
//本地函式
def processLine(line: String) = {
if (line.length > width)
println(filename + ": " + line.trim)
}
val source = Source.fromFile(filename)
for (line <- source.getLines())
processLine(line)
}
2、first class function 函式可以作為函式的引數進行傳遞
3、函式的引數
不定長引數
def echo(args: String*) =
for (arg <- args) println(arg)
使用引數名字來給引數設定值
def speed(distance: Float, time: Float): Float =
distance / time
speed(distance = 100, time = 10)
預設引數值
def printTime(out: java.io.PrintStream = Console.out) =
out.println("time = " + System.currentTimeMillis())
printTime()
printTime(Console.err)
4、函式閉包
函式捕獲一個自由變數而變成一個閉包。 每次呼叫函式的時候都產生一個新的閉包。
var more = 1
val addMore = (x: Int) => x + more //函式捕獲一個自由變數而變成一個閉包
addMore(10)
當自由變數的值改變的時候，閉包對自由變數的改變也是可以捕獲的到
more = 9999
addMore(10)
val someNumbers = List(-11, -10, -5, 0, 5, 10)
var sum = 0
someNumbers.foreach(sum += _)
println(sum)
5、尾遞迴
什麼是尾遞迴呢？如果呼叫自身方法的動作是函式體的最後一個動作的話，那麼這個遞迴就是一個尾遞迴
遞迴：更函式式、簡潔以及沒有var，但是函式的呼叫可能會消耗點時間。while迴圈是指令式程式設計，可能會更高效的，因為沒有方法的呼叫。但是如果是尾遞迴的話，編譯器是會優化的，其效率和while迴圈是一樣的
可以使用註解tailrec來標誌是否為尾遞迴
@tailrec
def boom(x: Int): Int =
if (x == 0) throw new Exception("boom!")
else boom(x - 1)
尾遞迴的限制，以下遞迴，不會進行尾遞迴優化，因為jvm的指令集使得尾遞迴的優化受限
遞迴呼叫的函式不是函式體所在的函式
def isEven(x: Int): Boolean =
if (x == 0) true else isOdd(x - 1)
def isOdd(x: Int): Boolean =
if (x == 0) false else isEven(x - 1)
三、高階函式及函式柯里化
高階函式(high-order functions)就是用函式作為引數的函式。高階函式可以減少冗餘程式碼，高階函式可以使得客戶端程式碼簡潔。
def filesEnding(query: String) =
for (file <- filesHere; if file.getName.endsWith(query))
yield file
def filesContaining(query: String) =
for (file <- filesHere; if file.getName.contains(query))
yield file
改造後：
private def filesMatching(matcher: String => Boolean) =
for (file <- filesHere; if matcher(file.getName))
yield file
柯里化
//柯里化函式(curring function)
def curriedSum(x: Int)(y: Int) = x + y
curriedSum(1)(2)
//說明柯里化的過程
def first(x: Int) = (y: Int) => x + y
val second = first(1)
second(2)
示例：自定義迴圈控制語句
var i = 10
while (i == 0) {
i -= 1
println(i)
}
until(i == 0) {
i -= 1
println(i)
}
def until(condition: => Boolean)(block: => Unit) {
if (!condition) {
block
until(condition)(block)
}
}
by name by value
by name 執行的時候才執行，by value呼叫就執行
//by-name parameter
def byNameAssert(predicate: => Boolean) =
if (assertionsEnabled && !predicate)
throw new AssertionError
byNameAssert(5 > 3)
//by-value parameter
def boolAssert(predicate: Boolean) =
if (assertionsEnabled && !predicate)
throw new AssertionError
boolAssert(5 > 3)