错误处理
错误类型
开发过程中常见的错误有
- 语法错误(编译报错)
- 逻辑错误
- 运行时错误(可能会导致闪退,一般也叫做异常)
- ....
自定义错误
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
原文链接:http://www.cnblogs.com/funkyRay/p/swift-jin-jie-shi-cuo-wu-chu-li-fan-xing.html