一、异常处理概述

1.1 异常处理的基本概念

在仓颉编程语言中，异常（Exception）是程序执行过程中出现的非正常情况，它会中断正常的程序流程。仓颉采用基于类的异常模型，所有异常都是Exception类或其子类的实例。

1.2 异常分类体系

仓颉将异常分为两大类：

1. Error类：表示系统内部错误和资源耗尽错误，应用程序不应捕获

   • 如OutOfMemoryError、StackOverflowError

2. Exception类：表示程序运行时逻辑错误或IO错误，需要捕获处理

   • 如ArithmeticException、FileNotFoundException

1.3 异常处理原则

仓颉的异常处理遵循以下核心原则：

• 明确性：异常类型应准确描述问题
• 可控性：异常应能被捕获和处理
• 安全性：异常不应泄露敏感信息
• 性能：避免过度使用异常影响性能

二、定义自定义异常

2.1 自定义异常基本语法

自定义异常必须继承Exception或其子类：

open class MyException <: Exception { public init() { super("This is MyException") } public init(message: String) { super(message) } } 

2.2 异常类设计规范

1. 命名规范：以Exception结尾，如InvalidInputException
2. 构造方法：提供默认构造方法和带消息的构造方法
3. 继承层次：合理设计异常继承关系，形成有意义的层次结构

2.3 自定义异常示例

open class NetworkException <: Exception { public var errorCode: Int32 public init(code: Int32) { errorCode = code super("Network error with code: ${code}") } } class TimeoutException <: NetworkException { public init() { super(code: 408) } } 

三、抛出异常（throw）

3.1 throw关键字用法

使用throw关键字抛出异常实例：

throw IllegalArgumentException("Argument cannot be null") 

3.2 抛出条件

1. 显式抛出：开发者使用throw主动抛出
2. 隐式抛出：运行时系统检测到错误自动抛出
   • 如除零错误、数组越界等

3.3 抛出规则

1. 只能抛出Exception子类实例
2. Error及其子类不能手动抛出
3. 未捕获的异常会由系统默认处理函数处理

3.4 抛出示例

func divide(a: Int64, b: Int64): Int64 { if (b == 0) { throw ArithmeticException("Division by zero") } return a / b } 

四、捕获和处理异常（try-catch）

4.1 基本语法结构

try { // 可能抛出异常的代码 } catch (e: ExceptionType1) { // 处理ExceptionType1 } catch (e: ExceptionType2) { // 处理ExceptionType2 } finally { // 无论是否发生异常都会执行的代码 } 

4.2 try表达式的变体

1. 普通try表达式：包含catch和finally块
2. try-with-resources：自动资源管理（类似Java的try-with-resources）

4.3 捕获多类型异常

使用|连接多个异常类型：

try { // ... } catch (e: IOException | NetworkException) { println("IO or Network error: ${e}") } 

4.4 通配符捕获

使用_捕获所有异常：

try { // ... } catch (_) { println("An exception occurred") } 

4.5 finally块特性

1. 无论是否发生异常都会执行
2. 即使catch块中有return也会执行
3. 常用于资源释放

五、常见运行时异常

5.1 标准运行时异常列表

异常类	描述
ArithmeticException	算术运算异常（如除零）
NegativeArraySizeException	创建大小为负的数组
IndexOutOfBoundsException	数组/集合索引越界
NoneValueException	访问None值（如Option为None时调用getOrThrow）
ConcurrentModificationException	并发修改集合
ClassCastException	类型转换失败
IllegalArgumentException	非法参数

5.2 异常处理示例

func processArray(arr: Array<Int64>, index: Int64) { try { if (index < 0 || index >= arr.size) { throw IndexOutOfBoundsException("Invalid index: ${index}") } println(arr[index]) } catch (e: IndexOutOfBoundsException) { println("Error: ${e.message}") } catch (e: Exception) { println("Unexpected error: ${e}") } } 

六、Option类型与异常处理

6.1 Option类型概述

Option<T>是仓颉标准库中的泛型枚举，用于表示可能为None的值：

public enum Option<T> { Some(T) | None } 

6.2 Option与异常的比较

特性	异常	Option
错误表示	抛出异常	返回None
性能	较差（栈展开）	较好
显式性	隐式控制流	显式处理
适用场景	非预期错误	预期可能的空值

6.3 Option的基本用法

func safeDivide(a: Int64, b: Int64): Option<Int64> { if (b == 0) { return None } return Some(a / b) } let result = safeDivide(10, 2) match (result) { case Some(value) => println("Result: ${value}") case None => println("Division failed") } 

6.4 Option的解构方式

1. 模式匹配：

   match (optionValue) { case Some(v) => // 处理有值情况 case None => // 处理无值情况 } 

2. getOrThrow：

   let value = optionValue.getOrThrow() // None时抛出NoneValueException 

3. coalescing操作符(??)：

   let value = optionValue ?? defaultValue 

4. 问号操作符(?)：

   let length = optionString?.length() // 返回Option<Int64> 

6.5 Option的最佳实践

1. 避免过度使用getOrThrow：这会抵消Option的优势
2. 优先使用模式匹配：提供最清晰的处理逻辑
3. 链式操作：利用map、flatMap等方法组合操作

   let result = getUser(id) .map(user => user.name) .map(name => name.toUpperCase()) ?? "Default" 

七、异常处理最佳实践

7.1 异常使用准则

1. 只针对异常情况：不应将异常用于正常控制流
2. 提供有意义的错误信息：异常消息应清晰描述问题
3. 保持异常不可变：异常实例创建后不应修改状态
4. 避免捕获基类Exception：应捕获最具体的异常类型

7.2 性能优化建议

1. 避免深层嵌套的try块：影响性能且难以维护
2. 预检查代替异常捕获：

   // 不推荐 try { println(arr[index]) } catch (e: IndexOutOfBoundsException) { // ... } // 推荐 if (index >= 0 && index < arr.size) { println(arr[index]) } else { // 处理错误 } 

7.3 设计模式应用

1. 特例模式：使用特殊对象代替异常

   class EmptyUser <: User { // 实现空对象行为 } func getUser(id: Int64): User { // 找不到时返回EmptyUser而非抛出异常 } 

2. 结果封装：使用Result类型统一封装结果和错误

   enum Result<T, E> { Ok(T) | Err(E) } 

八、总结与展望

仓颉编程语言的异常处理机制提供了灵活的错误处理能力，通过Exception和Option两种互补机制，可以应对不同类型的错误场景。关键要点包括：

1. 异常层次结构：基于类的异常体系提供了良好的扩展性
2. try-catch-finally：完整的异常捕获和处理语法
3. Option类型：为可能缺失的值提供了类型安全的处理方式
4. 性能与安全：平衡了错误处理能力与运行时性能

在实际开发中，应根据具体场景选择合适的错误处理方式：

• 对于不可恢复的错误（如内存耗尽），使用Error让其传播
• 对于可预期的错误（如用户输入无效），使用Option或自定义异常
• 对于非预期的运行时错误（如空指针），使用Exception捕获处理

通过合理运用仓颉的异常处理机制，可以构建出健壮、可维护的应用程序，有效处理各种错误情况，提升用户体验和系统稳定性。