溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
一、內置控制結構
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)
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
