Swift 进阶（十）错误处理、泛型

错误处理

错误类型

开发过程中常见的错误有

• 语法错误（编译报错）
• 逻辑错误
• 运行时错误（可能会导致闪退，一般也叫做异常）
• ....

自定义错误

Swift中可以通过Error协议自定义运行时的错误信息

enum SomeError: Error {
    case illegalArg(String)
    case outOffBounds(Int, Int)
    case outOfMemory
}

函数内部通过throw抛出自定义Error，可能会抛出Error的函数必须加上throws声明

func divide(_ num1: Int, _ num2: Int) throws -> Int {
    if num2 == 0 {
        throw SomeError.illegalArg("0不能作为除数")
    }
    return num1 / num2
}

需要使用try调用可能会抛出Error的函数

var result = try divide(20, 10)

抛出错误信息的情况

do—catch

可以使用do—catch捕捉Error

do {
    try divide(20, 0)
} catch let error {
    switch error {
    case let SomeError.illegalArg(msg):
        print("参数错误", msg)
    default:
        print("其他错误")
    }
}

抛出Error后，try下一句直到作用域结束的代码都将停止运行

func test() {
    print("1")
    
    do {
        print("2")
        print(try divide(20, 0)) // 这句抛出异常后面的代码不会执行了
        print("3")
    } catch let SomeError.illegalArg(msg) {
        print("参数异常:", msg)
    } catch let SomeError.outOffBounds(size, index) {
        print("下标越界:", "size=\(size)", "index=\(index)")
    } catch SomeError.outOfMemory {
        print("内存溢出")
    } catch {
        print("其他错误")
    }
    
    print("4")
}

test()

//1
//2
//参数异常: 0不能作为除数
//4

catch作用域内默认就有error的变量可以捕获

do {
    try divide(20, 0)
} catch {
    print(error)
}

处理Error

处理Error的两种方式

通过do—catch捕捉Error

do {
    print(try divide(20, 0))
} catch is SomeError {
    print("SomeError")
}

不捕捉Error，在当前函数增加throws声明，Error将自动抛给上层函数

如果最顶层函数main函数依然没有捕捉Error，那么程序将终止

func test() throws {
    print("1")
    print(try divide(20, 0))
    print("2")
}

try test()

// 1
// Fatal error: Error raised at top level

调用函数如果是写在函数里面，没有进行捕捉Error就会报错，而写在外面就不会

然后我们加上do-catch发现还是会报错，因为捕捉Error的处理不够详细，要捕捉所有Error信息才可以

这时我们加上throws就可以了

func test() throws {
    print("1")
    do {
        print("2")
        print(try divide(20, 0))
        print("3")
    } catch let error as SomeError {
        print(error)
    }
    
    print("4")
}

try test()

// 1
// 2
// illegalArg("0不能作为除数")
// 4

或者再加上一个catch捕获其他所有Error情况

func test() {
    print("1")
    do {
        print("2")
        print(try divide(20, 0))
        print("3")
    } catch let error as SomeError {
        print(error)
    } catch {
        print("其他错误情况")
    }

    print("4")
}

test()

看下面示例代码，执行后会输出什么

func test0() throws {
    print("1")
    try test1()
    print("2")
}

func test1() throws {
    print("3")
    try test2()
    print("4")
}

func test2() throws {
    print("5")
    try test3()
    print("6")
}

func test3() throws {
    print("7")
    try divide(20, 0)
    print("8")
}

try test0()

执行后打印如下，并会抛出错误信息

try

可以使用try?、try!调用可能会抛出Error的函数，这样就不用去处理Error

func test() {
    print("1")
    
    var result1 = try? divide(20, 10) // Optional(2), Int?
    var result2 = try? divide(20, 0) // nil
    var result3 = try! divide(20, 10) // 2, Int
    
    print("2")
}

test()

a、b是等价的

var a = try? divide(20, 0)
var b: Int?

do {
     b = try divide(20, 0)
} catch { b = nil }

rethrows

rethrows表明，函数本身不会抛出错误，但调用闭包参数抛出错误，那么它会将错误向上抛

func exec(_ fn: (Int, Int) throws -> Int, _ num1: Int, _ num2: Int) rethrows {
    print(try fn(num1, num2))
}

// Fatal error: Error raised at top level
try exec(divide, 20, 0)

空合并运算符就是用了rethrows来进行声明的

defer

defer语句，用来定义以任何方式（抛错误、return等）离开代码块前必须要执行的代码

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
    // .....
    try divide(20, 0)
    
    // close将会在这里调用
}

try processFile("test.txt")

// open
// close
// Fatal error: Error raised at top level

defer语句的执行顺序与定义顺序相反

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

func test(_ num: Int) -> Int {
    if num >= 0 {
        return 1
    }
    fatalError("num不能小于0")
}

在某些不得不实现，但不希望别人调用的方法，可以考虑内部使用fatalError函数

class Person { required init() {} }
class Student: Person {
    required init() {
        fatalError("don't call Student.init")
    }
    
    init(score: Int) {
        
    }
}

var stu1 = Student(score: 98)
var stu2 = Student()

局部作用域

可以使用do实现局部作用域

do {
    let dog1 = Dog()
    dog1.age = 10
    dog1.run()
}

do {
    let dog2 = Dog()
    dog2.age = 10
    dog2.run()
}

泛型（Generics）

基本概念

泛型可以将类型参数化，提高代码复用率，减少代码量

func swapValues<T>(_ a: inout T, _ b: inout T) {
    (a, b) = (b, a)
}

var i1 = 10
var i2 = 20
swap(&i1, &i2)
print(i1, i2) // 20, 10

struct Date {
    var year = 0, month = 0, day = 0
}

var d1 = Date(year: 2011, month: 9, day: 10)
var d2 = Date(year: 2012, month: 10, day: 20)
swap(&d1, &d2)
print(d1, d2) // Date(year: 2012, month: 10, day: 20), Date(year: 2011, month: 9, day: 10)

泛型函数赋值给变量

func test<T1, T2>(_ t1: T1, _ t2: T2) {}
var fn: (Int, Double) -> () = test

泛型类型

class Stack<E> {
    var elements = [E]()
    
    func push(_ element: E) {
        elements.append(element)
    }
    
    func pop() -> E {
        elements.removeLast()
    }
    
    func top() -> E {
        elements.last!
    }
    
    func size() -> Int {
        elements.count
    }
}

class SubStack<E>: Stack<E> {
    
}

var intStack = Stack<Int>()
var stringStack = Stack<String>()
var anyStack = Stack<Any>()

struct Stack<E> {
    var elements = [E]()
    
    mutating func push(_ element: E) {
        elements.append(element)
    }
    
    mutating func pop() -> E {
        elements.removeLast()
    }
    
    func top() -> E {
        elements.last!
    }
    
    func size() -> Int {
        elements.count
    }
}

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.pop()) // 11
print(stack.size()) // 0

enum Score<T> {
    case point(T)
    case grade(String)
}

let score0 = Score<Int>.point(100)
let score1 = Score.point(99)
let score2 = Score.point(99.5)
let score3 = Score<Int>.grade("A")

关联类型（Associated Type）

关联类型的作用：给协议中用到的类型定义一个占位名称

protocol Stackable {
    associatedtype Element
    mutating func push(_ element: Element)
    mutating func pop() -> Element
    func top() -> Element
    func size() -> Int
}

struct Stack<E>: Stackable {
    var elements = [E]()
    
    mutating func push(_ element: E) {
        elements.append(element)
    }
    
    mutating func pop() -> E {
        elements.removeLast()
    }
    
    func top() -> E {
        elements.last!
    }
    
    func size() -> Int {
        elements.count
    }
}

class StringStack: Stackable {
    var elements = [String]()
    
    func push(_ element: String) {
        elements.append(element)
    }
    
    func pop() -> String {
        elements.removeLast()
    }
    
    func top() -> String {
        elements.last!
    }
    
    func size() -> Int {
        elements.count
    }
}

var ss = StringStack()
ss.push("Jack")
ss.push("Rose")

协议中可以拥有多个关联类型

protocol Stackable {
    associatedtype Element
    associatedtype Element2
    mutating func push(_ element: Element)
    mutating func pop() -> Element
    func top() -> Element
    func size() -> Int
}

类型约束

protocol Runnable { }
class Person { }

func swapValues<T: Person & Runnable>(_ a: inout T, _ b: inout T) {
    (a, b) = (b, a)
}

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
}

var stack1 = Stack<Int>()
var stack2 = Stack<String>()
equal(stack1, stack2)

协议类型的注意点

看下面的示例代码来分析

protocol Runnable { }
class Person: Runnable { }
class Car: Runnable { }

func get(_ type: Int) -> Runnable {
    if type == 0 {
        return Person()
    }
    
    return Car()
}

var r1 = get(0)
var r2 = get(1)

如果协议中有associatedtype

protocol Runnable {
    associatedtype Speed
    var speed: Speed { get }
}

class Person: Runnable {
    var speed: Double { 0.0 }
}

class Car: Runnable {
    var speed: Int { 0 }
}

这样写会报错，因为无法在编译阶段知道Speed的真实类型是什么

可以用泛型来解决

protocol Runnable {
    associatedtype Speed
    var speed: Speed { get }
}

class Person: Runnable {
    var speed: Double { 0.0 }
}

class Car: Runnable {
    var speed: Int { 0 }
}

func get<T: Runnable>(_ type: Int) -> T {
    if type == 0 {
        return Person() as! T
    }
    
    return Car() as! T
}

var r1: Person = get(0)
var r2: Car = get(1)

还可以使用some关键字声明一个不透明类型

some限制只能返回一种类型

protocol Runnable {
    associatedtype Speed
    var speed: Speed { get }
}

class Person: Runnable {
    var speed: Double { 0.0 }
}

class Car: Runnable {
    var speed: Int { 0 }
}

func get(_ type: Int) -> some Runnable {
    return Car()
}

var r1 = get(0)
var r2 = get(1)

some除了用在返回值类型上，一般还可以用在属性类型上

protocol Runnable {
    associatedtype Speed
}

class Dog: Runnable {
    typealias Speed = Double
}

class Person {
    var pet: some Runnable {
        return Dog()
    }
}

泛型的本质

我们通过下面的示例代码来分析其内部具体是怎样实现的

func swapValues<T>(_ a: inout T, _ b: inout T) {
    (a, b) = (b, a)
}

var i1 = 10
var i2 = 20
swap(&i1, &i2)
print(i1, i2) // 20, 10

var d1 = 10.0
var d2 = 20.0
swap(&d1, &d2)
print(d1, d2) // 20.0, 10.0

反汇编之后

从调用两个交换方法来看，最终调用的都是同一个函数，因为函数地址是一样的；但不同的是分别会将Int的metadata和Double的metadata作为参数传递进去，所以推测metadata中应该分别指明对应的类型来做处理

可选项的本质

可选项的本质是enum类型

我们可以进到头文件中查看

我们平时写的语法糖的真正写法如下

var age: Int? = 10

本质写法如下：
var ageOpt0: Optional<Int> = Optional<Int>.some(10)
var ageOpt1: Optional = .some(10)
var ageOpt2 = Optional.some(10)
var ageOpt3 = Optional(10)

var age: Int? = nil

本质写法如下：
var ageOpt0: Optional<Int> = .none
var ageOpt1 = Optional<Int>.none

var age: Int? = .none
age = 10
age = .some(20)
age = nil

switch中可选项的使用

switch age {
case let v?: // 加上?表示如果有值会解包赋值给v
    print("some", v)
case nil:
    print("none")
}

switch age {
case let .some(v):
    print("some", v)
case .none:
    print("none")
}

多重可选项

var age_: Int? = 10
var age: Int?? = age_
age = nil

var age0 = Optional.some(Optional.some(10))
age0 = .none
var age1: Optional<Optional> = .some(.some(10))
age1 = .none

var age: Int?? = 10
var age0: Optional<Optional> = 10