内建控制结构
scala 内建的控制结构很少，只有 if while for try match 和函数调用 几种。 因为scala 从语法层面支持函数字面量。几乎所有的scala控制结构都会产生值.函数式语言把程序看成是计算值的活动。
if
object InBuildControl {
def main(args: Array[String]): Unit = {
var filename = "default.txt"
if ( ! args.isEmpty)
filename = args(0)
}
} // 指令式风格
object InBuildControl {
def main(args: Array[String]): Unit = {
val filename =
if (! args.isEmpty) args(0)
else "defult.txt"
println(filename)
}
} //函数式风格
println(if (! args.isEmpty) args(0) else "default.txt")
while
object InBuildControl {
def main(args: Array[String]): Unit = {
println(gcdLoop(6,4))
}
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
}
}
var line = ""
do{
line = readLine() //readline()该方法已经过时了
println("read" + line)
}while (line != "")
} //do...while 循环
Unit类型的值是 unit ，写为 ()
给变量赋值操作等式本身返回的也是unit 值
纯指令式风格（递归）实现 求解最大公约数
def gcd(x:Long,y:Long):Long = if (y == 0)x else gcd(y,x%y)
for
for (i <- 1 to 5) println(i) // 12345
for (i <- 1 until 5) println(i) //1234
for (i <- 1 until 5 if i > 2) println(i) //34 if 过滤
/*
i <- 1 to 5
1 to 5 是 Range 类型
i <- 1 to 5 是发生器（generator）（python叫生成器），每一次枚举，名为 i 的新的 val 就被元素值初始化。编译器能够推断出它是Int类型。
*/
for (
i <- 1 to 10
if i > 2
if i % 2 != 0
)print(i) //多个条件过滤 i>2 且 i%2 !=0 才运行此打印命令
val filesHere = (new java.io.File(".")).listFiles
def fileLines(file: java.io.File) =
scala.io.Source.fromFile(file).getLines.toList
def grep(pattern: String) = {
for(
file <- filesHere
if file.getName.endsWith(".scala")
line <- fileLines(file)
if line.trim.matches(pattern) //多层嵌套
)println(file + ":" + line.trim)
}
#类似于：
for file in filesHere:
if file.endswith(".scala"):
for line in file.readlines():
if line.strim.matches(pattern):
print (file + ":" + line.trim)
val filesHere = (new java.io.File(".")).listFiles
def fileLines(file: java.io.File) =
scala.io.Source.fromFile(file).getLines.toList
def grep(pattern: String) = {
for(
file <- filesHere
if file.getName.endsWith(".scala")
line <- fileLines(file)
//if line.trim.matches(pattern) //多次用到了 line.trim
trimmed = line.trim //流式变量 trimmed 是val 类型的，
if trimmed.matches(pattern)
)//println(file + ":" + line.trim)
println(file + ":" + trimmed)
}
val filesHere = (new java.io.File(".")).listFiles
def fileLines(file: java.io.File) =
scala.io.Source.fromFile(file).getLines.toList
def grep(pattern: String) = {
for(
file <- filesHere
if file.getName.endsWith(".scala")
line <- fileLines(file)
if line.trim.matches(pattern) //多层嵌套
) yield line.trim.length // 返回每一行去掉空格之后的长度
} // 最终返回一个数组 Array[Int]
try
使用throw 抛出异常
先创建一个异常对象，然后用throw 抛出
throw new IllegalArgumentException
var aNum = 5
if(aNum % 2 == 0)
print("haha")
else
throw new RuntimeException("anum must be even")// throw 抛出的异常类型为Nothing，因此得到的值为Nothing
var aNum = 5
try{
if(aNum % 2 == 0)
print("haha")
else
throw new RuntimeException("anum must be even")
}catch {
case ex:RuntimeException =>print("aiyou") //捕获 Run...异常，然后调用指定的函数
case ex:IllegalArgumentException => print("hehe") //如果异常不再这两个case之内，那么就会向上传导
}
try...catch...finally
def urlFor(path: String)={
try{
new URL(path)
}catch{
case e: MalformedURLException =>new URL("https://www.baidu.com")
}finally {
print("iiiii")
}
}
def f():Int = try{ return 1} finally {return 2} // 始终返回 2，其实是 2覆盖了 1
def g():Int = try{1} finally {2} //返回1
match
val aArg = "aha"
aArg match{
case "haha" =>println("right") //隐含了break
case "hehe" => println("wrong") // case 后面接的不止是Int，String类型，可以是任何类型的常量或其他东西。
case _ => println("i dont't know") // _ 占位符， 表示默认情况 _ 是常用的用来匹配未知变量的通配符。
}
val aArg = "haha"
val name =
aArg match{
case "haha" => "right" // 返回值
case "hehe" => "wrong"
case _ => "i don't know"
}
println(name)
scala 中 没有 break 和continue
变量的作用范围
大括号｛｝ 起到引入新的作用范围的作用。大括号能起到遮蔽括号内外同名变量的作用。
因此不同于java的不能创建同名变量，scala可以在大括号内外创建同名变量。
object InBuildControl{
def main(args: Array[String]): Unit = {
val i = 10
for(z <- 1 until 2){
val i = 12
println(i) //12
}
println(i) //10
}
}
子{} 可以访问父{} 的变量
object InBuildControl{
def main(args: Array[String]): Unit = {// 祖 层开始
val i = 10
val a = 23
for(z <- 1 until 2){ //父 层开始
val i = 12 //遮蔽了祖层的同名变量 i
println(i) //12
for (j <- 1 until 2){ //子 层开始
println(i) //12 虽然祖、父层都有i，但是父层遮蔽了祖层的i，所以这里读取的是父层的i
println(a) //23 只有祖 层 才有a 所以没有所谓遮蔽
}//子层结束
}//父层结束
println(i) // 10 打印本层的 i
}//祖层结束
}