《programming in scala》2ed chap7学习笔记

import java.io.FileReader

/**
 * Created by ly on 13-12-25.
 */
object BuiltInControlStructures {
  def main(args: Array[String]) {
    // 用val而不是var， 更容易equational reasoning
    val filename = if (!args.isEmpty) args(0) else "default.txt"


    /*
    The while and do-while constructs are called “loops,” not expressions,
because they don’t result in an interesting value. The type of the result is
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
    }

    var line = ""
    do {
      line = readLine()
      println("Read: " + line)
    } while (line != "")

    // 赋值语句的返回值是unit value，而不是Java中的被赋值的值，(var a = b) == ()

    /*
    while没有返回值所以是不纯函数的，尽量少用，可以用其他方式替代，比如递归
    If there isn’t a good justification for a particular while or do-while loop,
try to find a way to do the same thing without it.
     */
    def gcd(x: Long, y: Long): Long =
      if (y == 0) x else gcd(y, x % y)


    /*
    7.3 For expressions
     */
    val filesHere = (new java.io.File(".")).listFiles
    for (
      file <- filesHere // “ file <- filesHere ” syntax, which is called a generator
      if file.isFile // filter
      if file.getName.endsWith(".scala") // filter
    ) println(file)

    // Nested iteration
    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"); // 必须有;,将()改为{}可以省略，因为the Scala compiler will not infer semicolons while inside parentheses.
        line <- fileLines(file)
        if line.trim.matches(pattern)
      ) println(file + ": " + line.trim)
    grep(".*gcd.*")

    def grep2(pattern: String) =
      for {
        file <- filesHere
        if file.getName.endsWith(".scala")
        line <- fileLines(file)
        trimmed = line.trim // Mid-stream variable bindings，避免重复计算，没有val
        if trimmed.matches(pattern)
      } println(file + ": " + trimmed)
    grep2(".*gcd.*")

    // Producing a new collection
    // for clauses yield body; yield { body }一定要在整个body之外


    // Throwing exceptions
    val n = 10
    val half = if (n % 2 == 0) n / 2 else throw new RuntimeException("n must be even") // Technically, an exception throw has type Nothing .

    /* finally最好只处理clean up的事情，不要去返回值
    Usually finally clauses do some kind of clean up
    such as closing a file; they should not normally change the value computed
      in the main body or a catch clause of the try .
    */
    val file = new FileReader("input.txt")
    try {
      // Use the file
    } finally {
      file.close()
      // Be sure to close the file
    }
    def f(): Int = try {
      return 1
    } finally {
      return 2
    }
    println(f()) // 2
    def g(): Int = try {
        1
      } finally {
        2
      }
    println(g()) // 1; The best way to think of finally clauses is as a way to ensure some side effect happens, such as closing an open file.

    /* 7.5 Match expressions
    默认没有break，不会错误地fall through，有value
     */

    /*
    7.6 Living without break and continue
    The simplest approach is to replace every continue by an if and every break by a boolean variable.

    The Breaks class implements break by throwing an exception that is
caught by an enclosing application of the breakable method. Therefore,
the call to break does not need to be in the same method as the call to
breakable .
     */
    import scala.util.control.Breaks._
    import java.io._
    val in = new BufferedReader(new InputStreamReader(System.in))
    breakable {
      while (true) {
        println("? ")
        if (in.readLine() == "") break
      }
    }

    /*
    7.7 Variable scope
    One difference between Java and Scala exists, however, in that Scala allows you to define variables of the same name in
nested scopes.
     */
    val a = 1; // 这个;是必须的
    {
      val a = 2 // Compiles just fine， 但是最好不要这样用， shadow
      println(a)
    }
    println(a)

  }

}