十四、Error处理、泛型

作者: 爱玩游戏的iOS菜鸟 | 来源:发表于2020-02-07 16:52 被阅读0次

错误处理（异常处理）

错误类型

开发过程中常见的错误：

语法错误（编译报错）
逻辑错误 (偏离开发人员本意)
运行时错误（可能会闪退，一般也叫做异常）
...

自定义错误

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)
}

十四、Error处理、泛型

错误处理（异常处理）

错误类型

自定义错误

do-catch捕捉Error

处理Error的2种方式

try?、 try!

rethrows

defer

断言assert

fatalError

局部作用域

泛型（Generics）

泛型

关联类型（Associated Type）

类型约束

协议类型的注意点

泛型解决方案

不透明类型（Opaque Tpye）

some

do实现局部作用域

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Swift5.1语法学习