错误处理（异常处理）
错误类型
开发过程中常见的错误：
- 语法错误（编译报错）
- 逻辑错误 (偏离开发人员本意)
- 运行时错误（可能会闪退，一般也叫做异常）
...
自定义错误
- Swift可以通过Error协议自定义运行时的错误信息
- 函数内部通过throw抛出自定义Error，可能会抛出Error的函数必须加上throws申明
- 需要使用try调用可能会抛出Error的函数
enum MyError :Error {
case illegalArt(String)
}
func divide(_ num1: Int,_ num2: Int) throws -> Int{
if num2 == 0 {
throw MyError.illegalArt("0不能作为除数")
}
return num1 / num2
}
var result = try divide(20, 0)
print(result)
do-catch捕捉Error
- 使用 do-catch 捕捉Error
- 抛出Error后，try下一句直到作用域结束的代码都将停止运行
enum MyError :Error {
case illegalArt(String)
case outOfBounds(Int, Int)
case outOfMemory
}
func divide(_ num1: Int,_ num2: Int) throws -> Int{
if num2 == 0 {
throw MyError.illegalArt("0不能作为除数")
}
return num1 / num2
}
func test() throws {
print("1")
do {
print("2")
print(try divide(20, 0))
print("3")
} catch let MyError.illegalArt(tip) {
print("参数异常:",tip)
}catch let MyError.outOfBounds(size, index){
print("下标越界异常:size = \(size),index = \(index)")
}catch let MyError.outOfMemory{
print("内存溢出")
}catch{
print("其他错误")
}
}
try test()
/**
输出：
1
2
参数异常: 0不能作为除数
*/
处理Error的2种方式
- 通过do-catch捕捉Error
- 不捕捉Error，在当前函数增加throws声明,Error将自动上抛给上层函数
-
如果最顶层函数（main函数）依然没有捕捉Error，那么程序将终止
程序终止
enum MyError :Error {
case illegalArt(String)
case outOfBounds(Int, Int)
case outOfMemory
}
enum NewError :Error{
case unKnownError(String)
}
func divide(_ num1: Int,_ num2: Int) throws -> Int{
if num2 == 0 {
throw MyError.illegalArt("0不能作为除数")
}
if num2 == 1 {
throw NewError.unKnownError("任何数除以1结果都是其本身")
}
return num1 / num2
}
func test() throws {//第3、4个do-catch错误处理没有穷尽，所以需要throws上抛 如果处理详尽，可以无需throws
do{
print(try divide(20, 0))
} catch let error as MyError {//强制类型转换成功
print(error)
}catch{
print("其他错误")
}
do{
print(try divide(20, 1))
} catch let error as MyError {//强制类型转换失败
print(error)
}catch{
print("其他错误")
}
do{
print(try divide(20, 0))
} catch is MyError {//判断错误类型
print("MyError")
}
do{
print(try divide(20, 1))
} catch is MyError {//此处无法处理Error上抛 程序终止
print("MyError")
}
}
try test()
/*输出：
illegalArt("0不能作为除数")
其他错误
MyError
Fatal error: Error raised at top level: example.NewError.unKnownError("任何数除以1结果都是其本身"):
*/
第3、4个do-catch错误处理没有穷尽，所以需要throws上抛 如果处理详尽，可以无需throws
try?、 try!
- 可以使用try?、try!调用可能会抛出Error的函数，这样就不用去处理Error
func test(){
var result1 = try? divide(20, 10)//Optional(2),Int?
var result2 = try? divide(20, 0)//nil
var result3 = try! divide(20, 10)//2, Int
}
test()
//下面a与b完全等价
var a = try? divide(20, 0)
var b: Int?
do {
b = try divide(20, 0)
}catch{
}
rethrows
- rethrows表明：函数本身不会抛出错误，但调用闭包参数抛出错误，那么它将错误向上抛
-
??空合运算符就是这么声明的
?? 函数声明
var fn = { (a: Int,b: Int) throws -> Int in
a / b
}//闭包表达式
func exec(_ fn:(Int, Int) throws -> Int, _ num1:Int, _ num2: Int) rethrows {
print(try fn(num1,num2))
}
try exec(fn, 10, 20)
try exec(divide(_:_:), 10, 20)
defer
- defer语句：用来定义以任何方式（抛错误，return等）离开代码块前必须要执行的代码
- defer语句将在延迟至当前作用域结束之前执行
- defer语句的执行顺序，与定义顺序相反
func open(_ fileName:String) -> Int{
print("open")
return 0
}
func close(_ file:Int) {
print("close")
}
func processFile(_ fileName:String) throws {
let file = open(fileName)
defer {
close(file)
}
//使用file
//...
do {
try divide(20,0)
} catch let error {
switch error {
case let MyError.illegalArt(tip):
print(tip)
default:
print("其他错误")
}
}
//close将会在此处调用
}
try processFile("LOL.txt")
/**输出：
open
0不能作为除数
close
*/
func fn1() {
print("fn1")
}
func fn2() {
print("fn2")
}
func test() {
defer {
fn1()
}
defer {
fn2()
}
}
test()
/*输出：
fn2
fn1
*/
断言assert
- 很多编程语言都有断言机制：不符合指定条件就抛出运行时错误，常用于调试(Debug)阶段的条件判断
- 默认条件下，Swift的断言只会在Debug模式下生效，Release模式下忽略
- 增加Swift Flags修改断言的默认行为
- -assert-config Release 强制关闭断言
- -assert-config Debug 强制开启断言
fatalError
- 如果遇到严重问题，希望结束程序运行时，可以直接使用fatalError函数抛出错误（该错误无法通过do-catch捕捉）
- 使用fatalError函数，就不需要再写return
- 在某些不得不实现，但不希望别人调用的方法，可以考虑内部使用fatalError函数
局部作用域
- 可以使用do 实现局部作用域
泛型（Generics）
泛型
泛型可以将类型参数化，提高代码复用率，减少代码量
//将类型参数化
func swapValues<T>(_ a: inout T , _ b: inout T){
(a,b) = (b,a)
}
var v1 = 10
var v2 = 20
swap(&v1, &v2)//v1:20 v2: 10
var a1 = 10.5
var a2 = 20.6
swap(&a1, &a2)//v1:20.6 v2: 10.5
struct Date {
var year = 0
var month = 0
var day = 0
}
var date1 = Date(year: 2019, month: 12, day: 31)
var date2 = Date(year: 2020, month: 01, day: 01)
swap(&date1, &date2)
//date1:Date(year: 2020, month: 1, day: 1)
//date2:Date(year: 2019, month: 12, day: 31)
//泛型函数赋值给变量
func test<T1,T2>(_ a: T1, _ b: T2) {
}
var fn :(Int, Double)->() = test(_:_:)//此时确定参数类型
//类
class Stack <Element>{
var elements = [Element]()
func push(_ element:Element) {
elements.append(element)
}
func pop() -> Element {
elements.removeLast()
}
func top() -> Element {
elements.last!
}
func size() -> Int {
elements.count
}
}
//类继承
class SubStack<Element> : Stack<Element> {
}
var stack = Stack<Int>()
stack.push(11)
stack.push(22)
stack.push(33)
print(stack.top())//33
print(stack.pop())//33
print(stack.pop())//22
print(stack.size())//1
//结构体
struct Stack <Element>{
var elements = [Element]()
//结构体、枚举中修改自身内存必须要加mutating
mutating func push(_ element:Element) {
elements.append(element)
}
mutating func pop() -> Element {
elements.removeLast()
}
func top() -> Element {
elements.last!
}
func size() -> Int {
elements.count
}
}
//在类、结构体、枚举的初始化器中，如已添加元素，则根据元素类型自动判断类型 无需指明类型（即使加上也不会错）
var stack = Stack<Double>(elements: [10])//10可以赋值给Double类型
stack.push(11)
stack.push(22)
stack.push(33)
print(stack.top())//33
print(stack.pop())//33
print(stack.pop())//22
print(stack.size())//2
//枚举
enum Score <T> {
case point(T)
case grade(String)
}
let score1 = Score.point(100)
let score2 = Score<Int>.point(95)
let score3 = Score.point(99.5)
let score4 = Score<Int>.grade("A")//此处声明的类型为point的泛型类型 需要确定枚举类型分配内存
print(score1,score2,score3,score4)
关联类型（Associated Type）
- 作用：给协议中用到的类型定义一个占位名称
- 协议中可以拥有多个关联类型
protocol Stackable {
associatedtype Element//关联类型
mutating func push(_ element:Element)
mutating func pop() -> Element
func top() -> Element
func size() -> Int
}
//给关联类型设定真实类型
class Stack : Stackable{
typealias Element = Int
//或者给所有的用到的Element换为String
var elements = [Element]()
//结构体、枚举中修改自身内存必须要加mutating
func push(_ element:Element) {
elements.append(element)
}
func pop() -> Element {
elements.removeLast()
}
func top() -> Element {
elements.last!
}
func size() -> Int {
elements.count
}
}
//使用泛型
class Stack <E>: Stackable{
var elements = [E]()
//结构体、枚举中修改自身内存必须要加mutating
func push(_ element:E) {
elements.append(element)
}
func pop() -> E {
elements.removeLast()
}
func top() -> E {
elements.last!
}
func size() -> Int {
elements.count
}
}
类型约束
protocol Stackable {
associatedtype Element :Equatable
}
class Stack<E: Equatable>: Stackable {
typealias Element = E
}
func equal<S1: Stackable,S2: Stackable>(_ s1: S1, _ s2: S2) -> Bool where S1.Element == S2.Element,S1.Element : Hashable{
return false
}//S1 S2必须遵守Stackable 并且S1和S2的关联类型相同 且S1的管理按类型是遵守Hashable协议
var s1 = Stack<Int>()
var s2 = Stack<Int>()
var s3 = Stack<String>()
equal(s1, s2)//编译通过
equal(s1, s3)//编译报错 function 'equal' requires the types 'Int' and 'String' be equivalent
协议类型的注意点
- 如果协议中有associatedtype 会下面的报错，具有“自身”或关联的类型要求的协议只能用作通用约束，在初始化时，无法明确对象类型
那这种情况如何解决呢
泛型解决方案
protocol Runnable {
associatedtype Speed
var speed:Speed { get }
}
class Person : Runnable{
var speed: Double {
4.5
}
}
class Car : Runnable{
var speed: Int {
100
}
}
func get<T:Runnable>(_ type: Int) -> T {
if type == 0 {
return Person() as! T//强制类型转换有风险 慎用！此处仅解决上述报错
}
return Car() as! T
}
//如果类型声明与泛型不同则报错
var r1:Person = get(0)//Person实例
var r2:Car = get(1)//Car实例
不透明类型（Opaque Tpye）
上面的问题，解决方案2：使用Opaque Tpye
//some 只能返回一种类型
func get(_ type: Int) -> some Runnable {
// if type == 0 { //取消注释即报错
// return Person()
// }
return Car()
}
var r1 = get(0)
var r2 = get(1)
疑问：既然只返回一种类型，这个some不是很多余吗？
答：并不多余 可以隐藏返回的真实类型 且Car中的方法是无法调用的 只能访问procotol中的speed属性
some
some 除了可以用在返回值类型上，一般还可以用在属性类型上
protocol Runnable {
associatedtype Speed
var speed:Speed { get }
}
class Dog : Runnable{
typealias Speed = Double
var speed: Speed{
3.0
}
}
class Person{
var pet:some Runnable {
return Dog()
}
}
do实现局部作用域
可以单独使用do实现局部作用域
do{
let value1:Int = 10
print(value1)
}
do{
let value1:Int = 10
print(value1)
}
