错误处理
表示并抛出错误
在Swift中，错误用符合Error协议的类型的值来表示。这个空协议表明该类型可以用于错误处理。
enum VendingError:Error {
case invalidSelection // 选择无效
case insufficientFunds(coinsNeeded: Int) // 金额不足
case outOfStock // 缺货
}
抛出一个错误可以让你表明有意外情况发生，导致正常的执行流程无法继续执行。抛出错误使用throw关键字。
throw VendingError.insufficientFunds(coinsNeeded: 2)
处理错误
某个错误被抛出时，附近的某部分代码必须负责处理这个错误，例如纠正这个问题、尝试另外一种方式、或是向用户报告错误。
throwing 函数传递错误
为了表示一个函数、方法或构造器可以抛出错误，在函数声明的参数列表之后加上throws关键字。一个标有throws关键字的函数被称作throwing函数。如果这个函数指明了返回值类型，throws关键词需要写在箭头->的前面。
class VendingMachine {
var price = 5
var count = 10
func vend(coins: Int) throws {
// 投入的金额不足抛出错误 金额不足
guard coins >= price else {
throw VendingError.insufficientFunds(coinsNeeded: price-coins)
}
// 剩余量不足时抛出错误 缺货
guard count - coins / price > 0 else {
throw VendingError.outOfStock
}
count = count - num;
}
}
Do-Catch 处理错误
可以使用一个do-catch语句运行一段闭包代码来处理错误。如果在do子句中的代码抛出了一个错误，这个错误会与catch子句做匹配，从而决定哪条子句能处理它。
let machine = VendingMachine()
do {
try machine.vend(coins: 3)
}
catch VendingError.outOfStock {
print("货品不足")
}
catch VendingError.insufficientFunds(let coinsNeeded) {
print("还需要投入\(coinsNeeded)个硬币")
}
// 打印 还需要投入3个硬币
将错误转换成可选值
可以使用try?通过将错误转换成一个可选值来处理错误。如果在评估try?表达式时一个错误被抛出，那么表达式的值就是nil。
enum SumError: Error {
case arrayIsEmpty
}
func getSum(numbers: Array<Int>) throws -> Int {
if numbers.count == 0 {
throw SumError.arrayIsEmpty
}
else {
var sum = 0
for num in numbers {
sum += num
}
return sum
}
}
let sum = try? getSum(numbers: [])
if let x = sum {
print(x)
} else {
print("数组为空")
}
禁用错误传递
有时你知道某个throwing函数实际上在运行时是不会抛出错误的，在这种情况下，你可以在表达式前面写try!来禁用错误传递，这会把调用包装在一个不会有错误抛出的运行时断言中。如果真的抛出了错误，你会得到一个运行时错误。
let photo = try! loadImage(atPath: "./Resources/John Appleseed.jpg")
指定清理操作
可以使用defer语句在即将离开当前代码块时执行一系列语句。该语句让你能执行一些必要的清理工作，不管是以何种方式离开当前代码块的，无论是由于抛出错误而离开，还是由于诸如return或者break的语句。
func processFile(filename: String) throws {
if exists(filename) {
let file = open(filename)
defer {
close(file)
}
while let line = try file.readline() {
// 处理文件。
}
// close(file) 会在这里被调用，即作用域的最后。
}
}
上面的代码使用一条defer语句来确保open(_:)函数有一个相应的对close(_:)函数的调用。
类型转换
检查类型
用类型检查操作符is来检查一个实例是否属于特定子类型。若实例属于那个子类型，类型检查操作符返回true，否则返回false。
class Animal {
}
class Dog: Animal {
var name: String
init(name: String) {
self.name = name
}
}
class Cat: Animal {
var name: String
init(name: String) {
self.name = name
}
}
let someDog = Dog(name: "旺财")
let someCat = Cat(name: "Kitty")
var animals: [Animal] = [someDog, someCat]
for animal in animals {
print(animal is Dog)
}
// true
// false
当实例的类型不确定，可以用类型检查来判断类型。如果能够确定类型那么这个判断就是多余的：
let ret = someDog is Dog // 'is' test is always true
向下转型
因为向下转型可能会失败，类型转型操作符带有两种不同形式。条件形式as?返回一个你试图向下转成的类型的可选值。强制形式as!把试图向下转型和强制解包转换结果结合为一个操作。
当你不确定向下转型可以成功时，用类型转换的条件形式as?。条件形式的类型转换总是返回一个可选值，并且若下转是不可能的，可选值将是nil。这使你能够检查向下转型是否成功。
只有你可以确定向下转型一定会成功时，才使用强制形式as!。当你试图向下转型为一个不正确的类型时，强制形式的类型转换会触发一个运行时错误。
for animal in animals {
if let cat = animal as? Cat {
print(cat.name)
}
}
// Kitty
Any 和 AnyObject 的类型转换
Swift为不确定类型提供了两种特殊的类型别名：
-
Any可以表示任何类型，包括函数类型。 -
AnyObject可以表示任何类类型的实例。
var things: [Any] = [1, 2.5, "hello", (3, 5.0), someDog, someCat]
for thing in things {
switch thing {
case let someInt as Int:
print("\(someInt) is Int")
case let someDouble as Double:
print("\(someDouble) is Double")
case let someString as String:
print("\(someString) is String")
case let (x, y) as (Int, Double):
print("\(x) is Int, \(y) is Double")
case let someDog as Dog:
print("Dog is \(someDog.name)")
case let someCat as Cat:
print("Cat is \(someCat)")
default:
print("other")
}
}
// 1 is Int
// 2.5 is Double
// hello is String
// 3 is Int, 5.0 is Double
// Dog is 旺财
// Cat is Kitty
