普通Try表达式#

普通 try 表达式(本小节提到的 try 表达式特指普通的 try 表达式)包括三个部分: try 块，catch 块和 finally 块

• Try 块，以关键字 try 开始，后面紧跟一个由 表达式与声明 组成的块(用一对花括号括起来，定义了新的局部作用域，可以包含任意表达式和声明，后简称”块”)，try 后面的块内可以抛出异常，并被紧随的 catch 块所捕获并处理(如果不存在 catch 块或未被捕获，则在执行完 finally 块后，继续抛出至调用它的函数)

• Catch 块，一个 try 表达式可以包含零个或多个 catch 块 (当没有 catch 块时必须有 finally 块)

  每个 catch 块以 关键字catch 开头，后跟一条(catchPattern)和一个 表达式与声明 组成的块，catchPattern 通过 模式匹配 的方式匹配待捕获的异常，一旦匹配成功，则交由表达式与声明组成的块进行处理，并且 忽略它后面的所有 catch 块

  当某个 catch 块可捕获的异常类型 均可被定义在它前面的某个 catch 块所捕获时，会在此 catch 块处报”catch 块不可达”的 warning

• Finally 块，以关键字 finally 开始，后面紧跟一个用花括号括起来的 表达式与声明 组成的块

  原则上，finally 块中主要实现一些”善后”的工作，如释放资源等，且要尽量避免在 finally 块中再抛异常

  并且无论异常是否发生(即无论 try 块中是否抛出异常)，finally 块内的内容都会被执行(若异常未被处理，执行完 finally 块后，继续向外抛出异常)

  另外，一个 try 表达式中可以包含一个 finally 块，也可以不包含 finally 块(但此时必须至少包含一个 catch 块)

熟悉的try-catch, 这是C++中拥有的, 仓颉还有一个finally

catch和finally可以共存, 且catch和finally至少有一个

仓颉中的catch是按照模式匹配去捕获异常的

如果存在finally, 则 此块是必执行的 无论try是否抛出异常

其中 catchPattern 有两种模式:

• 通配符模式(“_”): 可以捕获同级 try 块内抛出的任意类型的异常，等价于类型模式中的 e: Exception，即捕获 Exception 及其子类所定义的异常

  示例:

  1
  // 使用通配符模式 捕获异常
  2
  let arrayTest: Array<Int64> = Array<Int64>([0, 1, 2])
  3
  try {
  4
      let lastElement = arrayTest[3]
  5
  } catch (_) {
  6
      print("catch an exception!")
  7
  }
  

• 类型模式: 可以捕获指定类型(或其子类型)的异常，语法上主要有两种格式:

  identifier : ExceptionClass

  此格式可以捕获 类型为 ExceptionClass 及其子类的异常，并将捕获到的异常实例转换成 ExceptionClass，然后 与 identifier 定义的变量进行绑定，接着就可以在 catch 块中通过 identifier 定义的变量访问捕获到的异常实例

  identifier : ExceptionClass_1 | ExceptionClass_2 | ... | ExceptionClass_n

  此格式可以通过连接符| 将多个异常类进行拼接，连接符 | 表示”或”的关系: 可以捕获 类型为 ExceptionClass_1 及其子类的异常，或者捕获类型为 ExceptionClass_2 及其子类的异常，依次类推，或捕获类型为 ExceptionClass_n 及其子类的异常(假设 n 大于 1)

  当待捕获异常的类型 属于上述”或”关系中的任一类型或其子类型时，此异常将被捕获

  但是由于无法静态地确定被捕获异常的类型，所以会 将被捕获异常的类型转换成由|连接的所有类型的最小公共父类，并将异常实例与 identifier 定义的变量进行绑定

  因此在此类模式下，catch 块内只能通过 identifier 定义的变量访问 ExceptionClass_i(1 <= i <= n) 的 最小公共父类中的成员变量和成员函数

  当然，也可以使用通配符代替类型模式中的 identifier，差别仅在于不会进行绑定操作

  关于类型模式用法的示例如下:

  1
  // 第一种情况
  2
  main() {
  3
      try {
  4
          throw ArithmeticException()
  5
      } catch (e: Exception) {                                          // 捕获
  6
          print("Exception and its subtypes can be caught here")
  7
      }
  8
  }
  

  1
  // 第二种情况
  2
  // 用户定义的异常
  3
  open class Father <: Exception {
  4
      var father: Int64 = 0
  5
      func whatFather() {
  6
          print("I am Father")
  7
      }
  8
  }
  9
  class ChildOne <: Father {
  10
      var childOne: Int64 = 1
  11
      func whatChildOne() {
  12
          print("I am ChildOne")
  13
      }
  14
      func whatChild() {
  15
          print("I am method in ChildOne")
  16
      }
  17
  }
  18
  class ChildTwo <: Father {
  19
      var childTwo: Int64 = 2
  20
      func whatChildTwo() {
  21
          print("I am ChildTwo")
  22
      }
  23
      func whatChild() {
  24
          print("I am method in ChildTwo")
  25
      }
  26
  }
  27
  
  28
  // main 函数
  29
  main() {
  30
      var a = 1
  31
      func throwE() {
  32
          if (a == 1) {
  33
              ChildOne()
  34
          } else {
  35
              ChildTwo()
  36
          }
  37
      }
  38
      try {
  39
          throwE()
  40
      } catch (e: ChildOne | ChildTwo) {
  41
          e.whatFather()                    // ok: e 是一个 Father 对象
  42
          //e.whatChildOne()                // error: e 是一个 Father 对象
  43
          //e.whatChild()                   // error: e 是一个 Father 对象
  44
          print(e.father)                   // ok: e 是一个 Father 对象
  45
          //print(e.childOne)               // error: e 是一个 Father 对象
  46
          //print(e.childOTwo)              // error: e 是一个 Father 对象
  47
      }
  48
  
  49
      return 0
  50
  }
  

使用 finally 块的例子如下:

1
// 使用异常类型模式 捕获
2
try {
3
    throw IndexOutOfBoundsException()
4
} catch (e: ArithmeticException | IndexOutOfBoundsException) {
5
    print("exception info: " + e.toString())
6
} catch (e: Exception) {
7
    print("neither ArithmeticException nor IndexOutOfBoundsException, exception info: " + e.toString())
8
} finally {
9
    print("the finally block is executed")
10
}

异常捕获, catch使用模式匹配, 总是匹配目标异常类及其子类

但catch只会执行一个, finally如果存在总会被执行

一个catch可以匹配多个不同的异常类, 每个异常类使用|分隔, 但此时 如果捕获到目标异常, 此异常将会被转换为 所有异常类的最小公共父类 然后再绑定到标识符

使用时, 也只能访问最小公共父类的成员

猜测, 仓颉中所有异常类 均需要有一个祖先类: Exception

Try-With-Resources表达式#

Try-with-resources 表达式主要是为了自动释放非内存资源

不同于普通 try 表达式，try-with-resources 表达式中的 catch 块和 finally 块均是可选的，并且 try 关键字其后的块之间可以**插入一个或者多个 ResourceSpecification**用来申请一系列的资源(ResourceSpecification 并不会影响整个 try 表达式的类型)

这里所讲的资源对应到语言层面即指 对象，因此 ResourceSpecification 其实就是实例化一系列的对象(多个实例化之间使用,分隔)

有些迷糊了, 什么是ResourceSpecification, 暂时没有具体的涉及到 仓颉中的相关内容

但, 非内存资源猜测可能是: 文件描述符? 网络套接字? 数据库句柄? 之类的

不过 finally和catch都可以不存在

使用 try-with-resources 表达式的例子如下所示:

1
class MyResource <: Resource {
2
    var flag = false
3
    public func isClosed() { flag }
4
    public func close() { flag = true }
5
    public func hasNextLine() { false }
6
    public func readLine() { "line" }
7
    public func writeLine(_: String) {}
8
}
9

10
main() {
11
    try (input = MyResource(),
12
        output = MyResource()) {
13
        while (input.hasNextLine()) {
14
            let lineString = input.readLine()
15
            output.writeLine(lineString)
16
        }
17
    } catch (e: Exception) {
18
        print("Exception happened when executing the try-with-resources expression")
19
    } finally {
20
        print("end of the try-with-resources expression")
21
    }
22
}

在 try-with-resources 表达式中的 ResourceSpecification 的类型必须实现 Resource 接口:

1
interface Resource {
2
    func isClosed(): Bool
3
    func close(): Unit
4
}

看起来, 应该是在try中创建资源, 然后出try块之后, 会自动尝试调用close()接口自动释放资源?

主要的应该依靠 实现Resource接口

Try-with-resources 表达式会首先(依声明顺序)执行实例化对应的一系列资源申请(上例中，先实例化 input 对象，再实例化 output 对象)，在此过程中若某个资源申请失败(例如，output 实例化失败)，则在它之前申请成功的资源(如 input 对象)会被全部释放(释放过程中若抛出异常，会被忽略)，并抛出申请此资源(output 对象)失败的异常

如果所有资源均申请成功，则继续执行 try 之后紧跟的块

在执行块的过程中，无论是否发生异常，之后均会按照资源申请时的逆序依次自动释放资源(上例中，先释放 output 对象，再释放 input 对象)

在释放资源的过程中，若某个资源在被释放时发生异常，并不会影响其它资源的继续释放，并且整个 try 表达式抛出的异常遵循如下原则:

1. 如果 try 之后紧跟的块中有异常抛出，则 释放资源的过程中抛出的异常 会被忽略;

2. 如果 try 之后紧跟的块中没有抛出异常，释放资源的过程中抛出的首个异常将会被抛出(后续释放资源过程中抛出的异常均会被忽略)

资源会根据声明顺序进行申请, 如果存在一个资源申请失败, 则会抛出申请失败的异常 并 释放已经成功申请的资源(如果释放时抛异常, 此异常会被忽略)

资源释放时抛异常, 并不影响其他资源的释放

Try-with-resources 中, 如果try块抛异常, 则 实际会抛出第一个被抛出的异常, 其他异常会被忽略(实际上 其他异常可能只有释放资源时抛出的异常)

但我有一点不明白, 为什么在执行块的过程中, 申请的资源就会被逆序自动释放? 而不是块执行完毕?

怎么想都应该是 块里执行完毕之后在释放比较合理

需要说明的是，try-with-resources 表达式中一般没有必要再包含 catch 块和 finally 块，也不建议用户再手动释放资源

因为 try 块执行的过程中 无论是否发生异常，所有申请的资源都会被自动释放，并且执行过程中产生的异常均会被向外抛出

但是，如果需要显式地捕获 try 块 或 资源申请和释放过程中可能抛出的异常 并处理，仍可在 try-with-resources 表达式中包含 catch 块和 finally 块:

1
try (input = MyResource(),
2
    output = MyResource()) {
3
    while (input.hasNextLine()) {
4
        let lineString = input.readLine()
5
        output.writeLine(lineString)
6
    }
7
} catch (e: Exception) {
8
    print("Exception happened when executing the try-with-resources expression")
9
} finally {
10
    print("end of the try-with-resources expression")
11
}

事实上，上述 try-with-resources 表达式等价于下述普通 try 表达式:

1
try {
2
    var freshExc = None<Exception>                    // 一个可以存储任何异常的新变量
3
    let input = MyResource()
4
    try {
5
        var freshExc = None<Exception>
6
        let output = MyResource()
7
        try {
8
            while (input.hasNextLine()) {
9
                let lineString = input.readLine()
10
                output.writeLine(lineString)
11
            }
12
        } catch (e: Exception) {
13
            freshExc = e
14
        } finally {
15
            try {
16
                if (!output.isClosed()) {
17
                    output.close()
18
                }
19
            } catch (e: Exception) {
20
                match (freshExc) {
21
                    case Some(v) => throw v           // 用户代码中引发的异常将被抛出
22
                    case None => throw e
23
                }
24
            }
25
            match (freshExc) {
26
                case Some(v) => throw v
27
                case None => ()
28
            }
29
        }
30
    } catch (e: Exception) {
31
        freshExc = e
32
    } finally {
33
        try {
34
            if (!input.isClosed()) {
35
                input.close()
36
            }
37
        } catch (e: Exception) {
38
            match (freshExc) {
39
                case Some(v) => throw v
40
                case None => throw e
41
            }
42
        }
43
        match (freshExc) {
44
            case Some(v) => throw v
45
            case None => ()
46
        }
47
    }
48
} catch (e: Exception) {
49
    print("Exception happened when executing the try-with-resources expression")
50
} finally {
51
    print("end of the try-with-resources expression")
52
}

可以看到，try 块(即用户代码)中 若抛出的异常会被记录在 freshExc 变量中，并最终被层层向外抛出，其优先级高于 释放资源的过程中可能出现的异常

try-with-resources 表达式的类型是 Unit

这应该是个典型代码了, 可以认真分析一下

1
try {
2
    var freshExc = None<Exception>                  // 一个可以存储任何异常的新变量
3
    let input = MyResource()
4
    try {
5
        var freshExc = None<Exception>
6
        let output = MyResource()
7
        try {                                       // 用户代码
8
            while (input.hasNextLine()) {
9
                let lineString = input.readLine()
10
                output.writeLine(lineString)
11
            }
12
        } catch (e: Exception) {                    // 尝试捕获 用户代码异常
13
            freshExc = e                            // 捕获到了, 记录 用户代码异常
14
        } finally {
15
            try {
16
                if (!output.isClosed()) {           // 尝试释放资源
17
                    output.close()
18
                }
19
            } catch (e: Exception) {                // 尝试捕获 释放资源异常
20
                match (freshExc) {                  // 如果捕获到了, 就模式匹配 用户代码异常
21
                    case Some(v) => throw v         // 匹配到 用户代码异常存在, 则 抛出用户代码异常
22
                    case None => throw e            // 匹配到 None, 即 用户代码异常不存在, 则 抛出资源释放异常
23
                }
24
            }
25
            match (freshExc) {                      // 如果没有捕获到资源释放异常, 模式匹配 用户代码异常
26
                case Some(v) => throw v             // 匹配到 用户代码异常存在, 则 抛出用户代码异常
27
                case None => ()                     // 匹配到 None, 即 用户代码异常不存在, 模式匹配值为()
28
            }
29
        }
30
    } catch (e: Exception) {                        // 尝试捕获内层代码中的异常
31
        freshExc = e                                // 捕获到 则记录 内层异常
32
    } finally {
33
        try {
34
            if (!input.isClosed()) {                // 尝试释放资源
35
                input.close()
36
            }
37
        } catch (e: Exception) {                    // 尝试捕获 释放资源异常
38
            match (freshExc) {                      // 如果捕获到了释放资源异常, 模式匹配 内层异常
39
                case Some(v) => throw v             // 模式匹配 内层异常存在, 则抛出内层异常
40
                case None => throw e                // 模式匹配 None, 即内层异常不存在, 则抛出资源释放异常
41
            }
42
        }
43
        match (freshExc) {                          // 如果资源释放没有异常, 则模式匹配 内层异常
44
            case Some(v) => throw v                 // 模式匹配 内层确实抛出异常, 则 抛出内层异常
45
            case None => ()                         // 模式匹配 None, 则 内层异常不存在, 整个`try`表达式无异常
46
        }
47
    }
48
} catch (e: Exception) {
49
    print("Exception happened when executing the try-with-resources expression")
50
} finally {
51
    print("end of the try-with-resources expression")
52
}

其实也不是很复杂, 严格匹配异常并处理