Swift学习笔记(五)-错误处理和泛型

错误处理

你可以用任何遵循 Error协议的类型来表示错误。

enum PrinterError: Error {
    case outOfPaper
    case noToner
    case onFire
}

throw/throws

使用 throw 来抛出一个错误并且用throws 来标记一个可以抛出错误的函数。如果你在函数里抛出一个错误，函数会立即返回并且调用函数的代码会处理错误。

func send(job: Int, toPrinter printerName: String) throws -> String {
    if printerName == “Never Has Toner” {
        throw PrinterError.noToner
    }
    return “Job sent”
}

do-catch

有好几种方法来处理错误。一种是使用 do-catch 。在 do 代码块里，你用 try 来在能抛出错误的函数前标记。在 catch 代码块， 错误会自动赋予名字 error ，如果你不给定其他名字的话 这段话意思应该是catch关键词默认带隐式参数error吧。

do {
    let printerResponse = try send(job: 1040, toPrinter: “Bi Sheng”)
    print(printerResponse)
} catch {
    print(error)
}

你可以提供多个 catch 代码块来处理特定的错误。你可以在 catch 后写一个 模式 (什么模式，你说的莫非是pattern? )，用法和 switch 语句里的 case 一样。

do {
    let printerResponse = try send(job: 1440, toPrinter: “Gutenberg”)
    print(printerResponse)
} catch PrinterError.onFire {
    print(“I’ll just put this over here, with the rest of the fire.”)
} catch let printerError as PrinterError {
    print(“Printer error: \(printerError).”)
} catch {
    print(error)
}

try?

另一种处理错误的方法是使用try?来转换结果为 可选项(你说的是optional)? 。如果函数抛出了错误，那么错误被忽略并且结果为nil。否则，结果是一个包含了函数返回值的 可选项 。

let printerSuccess = try? send(job: 1884, toPrinter: “Mergenthaler”)
let printerFailure = try? send(job: 1885, toPrinter: “Never Has Toner”)

defer

使用defer来写在函数返回后也会被执行的代码块，无论是否错误被抛出。你甚至可以在没有错误处理的时候使用 defer，来简化需要在多处地方返回的函数。

var fridgeIsOpen = false
let fridgeContent = [“milk”, “eggs”, “leftovers”]
 
func fridgeContains(_ food: String) -> Bool {
    fridgeIsOpen = true
    defer {
        fridgeIsOpen = false
    }
    
    let result = fridgeContent.contains(food)
    return result
}
fridgeContains(“banana”)
print(fridgeIsOpen)

泛型

把名字写在尖括号<>里来创建一个泛型方法或者类型。

func makeArray<Item>(repeating item: Item, numberOfTimes: Int) -> [Item] {
    var result = [Item]()
    for _ in 0..<numberOfTimes {
        result.append(item)
    }
    return result
}
makeArray(repeating: “knock”, numberOfTimes:4)

你可以为函数、方法、类、枚举以及结构体创建泛型。

*// Reimplement the Swift standard library’s optional type*
enum OptionalValue<Wrapped> {
    case none
    case some(Wrapped)
}
var possibleInteger: OptionalValue<Int> = .none
possibleInteger = .some(100)

在类型名称后紧接 where来明确一系列需求——比如说，来要求类型实现一个协议，要求两个类型必须相同，或者要求类必须继承自特定的父类。

func anyCommonElements<T: Sequence, U: Sequence>(_ lhs: T, _ rhs: U) -> Bool
    where T.Iterator.Element: Equatable, T.Iterator.Element == U.Iterator.Element {
        for lhsItem in lhs {
            for rhsItem in rhs {
                if lhsItem == rhsItem {
                    return true
                }
            }
        }
        return false
}
anyCommonElements([1, 2, 3], [3])

<T: Equatable>和<T> … where T: Equatable这两种写法是完全相同的。

Swift学习群

欢迎加入本人的Swift学习微信群，一同互相监督学习，我微信：reese90