Swift3.0可选类型(Optional)倾心总结

本篇主要对Swift3.0版本的可选类型经常使用的场景及注意点加以总结，当做以后可以随时翻译的资料；因为本篇为自己编码时候的总结，难免会有遗漏，希望广大读者加以补充

Swift3.0 Optional类型

首先我们先看下Objective-C与Swift语言对于可选nil的不同理解:

Objective-C中的nil:表示缺少一个合法的对象，是指向不存在对象的指针，对结构体、枚举等类型不起作用(会返回NSNotFound)
Swift中的nil:表示任意类型的值缺失，是一个确定的值，要么是该类型的一个值要么什么都没有(即为nil)

一、申明可选常量或变量

let status: Int? = 1   // 申明可选Int类型的常量,初始值为1 
var defaultAddress: String? = "江苏南京"   // 申明可选String类型的变量,初始值为"江苏南京"
var student: Person? // 申明可选Person(自定义的类)的变量，初始值为nil

注意：Int?与Int不相同，Int?表示可选的Int类型，可以赋值为nil，而Int不可以赋值为nil

二、使用"!"强制解析获取可选类型的值(不建议直接使用)

var defaultAddress: String? = "江苏南京"
if defaultAddress != nil { // !=或==可以用来判断是否为nil
    print("您的地址是\(defaultAddress!)") // 使用!强制解析
} else {
    print("对不起，您不存在地址信息")
}

var student: Person?
print("学生为\(student!)") // XCode会提示运行错误，因为student初始值为nil，强制解析不行

三、使用可选绑定获取可选类型的值(建议的用法)

var defaultAddress: String? = "江苏南京"
if let address = defaultAddress { // 如果defaultAddress有值或类型转换成功，则将值赋值给address直接使用
    print("您的地址是\(address)")  // 使用address代替defaultAddress，且不需要加!强制解析
} else {
    print("对不起，您不存在地址信息")
}

四、隐式解析可选类型(用于申明时肯定有初始值，但后面可能为nil)

var mobileNumber: Int64! = 13912345678 // 第一次申明有初始值
print("您的电话号码是\(mobileNumber)") // 不需要使用!强制解析
// 打印内容:**您的电话号码是****Optional(13912345678)**
// 还是不建议直接强制解析，因为实际项目中可能中间已经对该值做了改变，若为nil则会运行错误导致APP崩溃
if let number = mobileNumber { // 建议的做法
    print("您的电话号码是\(number)")
// 打印内容:**您的电话号码是****13912345678**
} else {
    print("您没有记录电话号码")
}

五、空合运算符(用于判断变量或常量是否为nil)

// 空合运算符：a ?? b 判断a是否为nil，若a不为nil对a解封，否则返回b的值
var status: Int? // 申明可选Int类型的变量status，初始值为nil
status ?? 0 // 因为status为nil，则返回0
// ?? 即为以下if else的缩写
func testOption() -> Int {
    let status: Int? = 1
    if status == nil {
        return 0
    } else {
        return status!
    }
}

六、函数/方法返回类型为可选类型

A:返回值为可选类型的值(如Int?、String?、(Int, String)?、[Int]?、[Int: String]?等)

func returnPossibleValue(value: Bool) -> String? { // 返回类型为可选String类型
    if value {
        return "返回类型是可选类型值" // 如果为真，返回Int类型的值1
    } else {
        return nil // 如果为假，返回nil
    }
}

let possibleValue = returnPossibleValue(value: true) // 要用可选绑定判断再使用，因为possibleValue为String？可选类型
if let value = possibleValue {
    print(value)
} else {
    print("none value")
}

B:返回值为可选类型的类(如URL?、自定义Person?等)

class SomeClass {
    var someValue: Int
    init?(someValue: Int) { // 可失败构造器
        if someValue == 1 { return nil }
        self.someValue = someValue
    }
}

func returnPossibleClass(value: Bool) -> SomeClass? { // 返回的类实例可能为nil
    if value {
        return SomeClass(someValue: 1) // 返回的为nil
    } else {
        return SomeClass(someValue: 2) // 返回的SomeClass?实例，不为nil
    }
}

C:返回值为可选类型的闭包(如(()-> (void))? )

func returnOptionalFunc(value: Bool) -> (() -> (Void))? { // 返回类型为可选类型的闭包
    if value {
        return { () in
            print("返回类型是可选类型闭包")
        }
    } else {
        return nil
    }
}

let possibleFunc = returnOptionalFunc(value: true) // 要用可选绑定判断再使用，因为possibleFunc 为可选类型的闭包，类型为() -> (Void)
if let aFunc = possibleFunc {
    print(aFunc())  // 注意增加()调用闭包，因为没有参数则是空括号
} else {
    print("none func")
}

七、可选类型在类或结构体中的运用

A:可选类型在类中的运用

class PossibleClass {
    var someValue: Int
    var possibleValue: String? // 可选存储属性，默认值为nil
    init(someValue: Int) { // 构造方法中可以不对possibleValue属性初始化
        self.someValue = someValue
    }
}

let someClass = PossibleClass(someValue: 4) // 实例化对象时不需要对possibleValue初始化，someClass实例中：someValue为4，possibleValue为nil

注意：类中所有属性都需要有默认值。属性可以在申明时赋予初始值，也可以在构造方法中赋予初始值；子类继承父类时，必须先给自身属性先初始化后再继承父类构造方法初始化。一般的，出于安全的因素，子类的属性都赋予初始值或直接定义为可选类型。

B:可选类型在结构体中的运用

struct PossibleStruct {
    var someValue: Int
    var possibleValue: String? // 可选存储属性，默认值为nil
    // 结构体中可以自定义一个init构造器对属性初始化，也可以不自定义
}

let someStruct = PossibleStruct(someValue: 4, possibleValue: nil)

调用默认的逐一构造器

说明：从上图可看出实例化,PossibleStruct会调用默认逐一构造器，其中possibleValue可传String类型的值或nil

八、可选类型在构造器中的运用

概念：可失败构造器是 一个类、结构体或枚举类型的对象，在构造过程中有可能失败；这里所指的“失败”是指，如给构造器传入无效的参数值，或缺少某种所需的外部资源，又或是不满足某种必要的条件等。

A:结构体的可失败构造器

struct PossibleStructInit {
    let someValue: String
    init?(someValue: String) { // 可失败构造器
        if someValue.isEmpty { return nil } // 如果实例化为空串，则返回nil(即实例化失败)
        self.someValue = someValue
    }
}

let oneStruct = PossibleStructInit(someValue: "abc") // abc不是空串，oneStruct为PossibleStructInit？可选类型
if let one = oneStruct { // 使用if let可选绑定判断
    print(one.someValue)
} else {
    print("none value")
}
// 结果打印 abc

let twoStruct = PossibleStructInit(someValue: "") // 传参为空串
if let two = twoStruct {
    print(two.someValue)
} else {
    print("none value")
}
// 结果打印 none value

B:枚举的可失败构造器

enum PossibleEnmuInit {
    case East, West, South, North // 不带原始值，带原始值也可以使用可失败构造器
    init?(director: Character) {
        switch director {
        case "E":
            self = .East
        case "W":
            self = .West
        case "S":
            self = .South
        case "N":
            self = .North
        default:
            return nil // 如果实例化时不是E/W/S/N字符，则返回nil(即实例化失败)
        }
    }
}

let oneEnmu = PossibleEnmuInit(director: "E")  // 传值E，返回PossibleEnmuInit?可选类型
if let one = oneEnmu { // 使用可选绑定判断
    print(one)
} else {
    print("none value")
}
// 结果打印 East

let twoEnmu = PossibleEnmuInit(director: "A")  // 传值A，返回PossibleEnmuInit?可选类型
if let two = twoEnmu { // 使用可选绑定判断
    print(two)
} else {
    print("none value")
}
// 结果打印 none value

C:类的可失败构造器

class Product {
    let name: String
    init?(name: String) {   
        if name.isEmpty { return nil }
        self.name = name
    }
}

class CartItem: Product {
    let quantity: Int
    init?(name: String, quantity: Int) {
        if quantity < 1 { return nil } // 实例化时如果quantity小于1，则立即终止构造过程
        self.quantity = quantity
        super.init(name: name) // 如果name为空串，则立即终止构造过程
    }
}

if let twoSocks = CartItem(name: "sock", quantity: 2) {
    print("Item: \(twoSocks.name), quantity: \(twoSocks.quantity)")
}
// 打印 "Item: sock, quantity: 2”

if let zeroShirts = CartItem(name: "shirt", quantity: 0) {
    print("Item: \(zeroShirts.name), quantity: \(zeroShirts.quantity)")
} else {
    print("Unable to initialize zero shirts")
}
// 打印 "Unable to initialize zero shirts”

九、可选类型在可选链中的运用

概念：可选链为一种可以在当前值可能为nil的可选值上请求和调用属性、方法及下标的方法。如果可选值有值，那么调用就会成功；如果可选值是nil，那么调用将返回nil。多个调用可以连接在一起形成一个调用链，如果其中任何一个节点为nil，整个调用链都会失败，即返回nil。

class Person { 
    var name: String
    var room: Room? // 不是每个人都买房，定义为可选类型
    init(name: String) {
        self.name = name
    }
}

class Room {
    var roomAddr: String
    var roomArea: Int
    init(roomAddr: String, roomArea: Int) {
        self.roomAddr = roomAddr
        self.roomArea = roomArea
    }
}

let xiaoming = Person(name: "xiaoming") // 此时xiaoming实例中属性：name为"xiaoming",room为nil
if let address = xiaoming.room?.roomAddr, let area = xiaoming.room?.roomArea { // 使用?可选链式调用，如果含有值则返回该值(不需要手动强制解析),如果没有值则返回nil
    print("\(xiaoming.name)的房子地址在:\(address), 面积:\(area)")
} else {
    print("\(xiaoming.name)没有房子")
}
// 打印：xiaoming没有房子

xiaoming.room = Room(roomAddr: "南京雨花台区", roomArea: 95) // 定义xiaoming实例的room属性
// 再次调用以上可选绑定，打印 xiaoming的房子地址在:南京雨花台区, 面积:95

十、可选类型在错误处理中的运用

概念：错误处理即为响应错误一级从错误中恢复的过程

A:一般的错误处理写法（一般使用于需要对不同的返回结果较为清晰的捕捉并做相应的处理）

// 操作错误处理枚举
enum OperationError: Error {
    case ErrorOne
    case ErrorTwo(String) // 带关联值的枚举属性
    case ErrorOthers
}

// 错误处理抛出
func throwDriver(num: Int) throws {
    if num == 1 {
        throw OperationError.ErrorOne
    } else if num == 2 {
        throw OperationError.ErrorTwo("数据类型错误")
    } else {
        throw OperationError.ErrorOthers
    }
}

do {
    print("使用do-catch捕获错误")
    try throwDriver(num: 2) // 使用try尝试请求
    print("未捕获到错误")
} catch OperationError.ErrorOne { // catch去捕捉是否又throw出来的错误
    print("捕捉到错误：ErrorOne")
} catch OperationError.ErrorTwo(let message) { // 可以使用let 获取枚举关联值
    print("捕捉到错误：ErrorTwo" + message)
} catch OperationError.ErrorOthers {
    print("捕捉到错误：ErrorOthers")
}
// 打印结果如下：
// 使用do-catch捕获错误
// 捕捉到错误：ErrorTwo数据类型错误

B:错误处理(try!)（不建议使用，可能会导致App崩溃）

let photo = try! loadImage(atPath: "./Resources/John Appleseed.jpg")
// 上述语句中在执行loadImage方法时如果执行失败，使用try!来禁用错误传递，会有运行错误导致App崩溃

C:错误处理(try?)（一般使用于不需要对错误进行过多的处理）

func someThrowingFunction() throws -> Int {
    // ...
}

let x = try? someThrowingFunction() // x可能正常返回一个Int类型的值也有可能抛出一个错误异常，使用时对x用if let可选绑定判断

十一、可选类型在类型转换中的运用

类型转换在向上转型时一般不会出现失败，例如从子类向父类转型，直接用as即可
类型转换在向下转型时可能会出现失败，例如从父类向子类转型，要使用as?转型，使用时需要可选绑定后再用

使用as?类型转换

值得注意的是：从Any转成Int为向下转型，Swift从安全因素考虑，会直接返回nil，所以在日常项目中若遇到从父类向子类转型时，一定要使用可选绑定，如以下代码：

class SuperClass {
    // 这是一个父类
}

class SubClass: SuperClass {
    // 这是一个子类
}

let superClass = SuperClass()
if let someClass = superClass as? SubClass {
    // 如果转换成功，则用someClass使用即可
} else {
    // 转换失败
}

其他、调用公共库时注意API的返回值

返回值类型

var score: [String: Int] = ["语文": 87, "数学": 99, "英语": 61]
let removedValue = score.removeValue(forKey: "物理") // 返回nil

注意：从以上代码中可看出，removeValue方法会返回被删除key对应的Value值，发现不存在key为“物理”，即返回nil(removedValue常量值)