Swift 可选类型

对于使用Objective-C开发iOS的程序员来说，对象是否为nil在编写程序的过程中程序员不太关心，直接使用就可以，在一些需要判断的地方在判断，当转为Swift开发时，首先头疼的问题就是可选类型，到底何时使用？，何时使用！总是拿不太准，下面就详细的讲解一下

一、什么是可选类型

可选类型伴随着Swift诞生，在原有的Objective-C语言中不存在，究其原因，是因为Swift是类型安全的语言，而OC则是弱类型语言，OC中 str字符串既可以是nil，也可以是字符串，而Swift中，这两种状态是不能同时存在的。
OC和Swift对于nil的解释也是不太一样的

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

在Swift中Optional(可选类型)是一个含有两种情况的枚举，None 和 Some(T)，用来表示可能有或可能没有值。任何类型都可以明确声明为（或者隐式转换）可选类型。当声明一个可选类型的时候，要确保用括号给 ? 操作符一个合适的范围。

1.1可选类型的声明

var optionalStr: String? = "swift语言可选类型"//声明可选类型字符串，并赋初值
var opStu:Student? //声明可选opStu对象，赋初值nil

注意:在类型和 ?之间没有空格

1.2 强制解析(拆包)

当你确定自定义的可选类型一定有值时，可以使用操作符(!)进行强制解析，拿到数据，叹号表示"我知道一定有值，请使用它",但是当你判断错误，可选值为nil时使用(!)进行强制解析，会有运行错误。

var myStr:String? = nil
myStr="强制解析，一定有值"
if myStr != nil {
    print(myStr!)//使用！进行强制解析
}else{
    print("字符串为nil")
}

运行结果

强制解析，一定有值

1.3 自动解析

在最初的声明时使用？修饰，当你希望它自动解析是可以用！代替？来修饰，这样在变量使用时就不需要加！来强制拆包，它会自动解析。

var myStr:String! //使用！修饰
myStr="自动解析"
if myStr != nil {
    print(myStr)
}else{
    print("字符串为nil")
}

运行结果

自动解析

1.4 可选绑定

A.使用可选绑定，摆脱了频繁的判断是否为nil在赋值，但是使用可选绑定（optional binding）来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在if和while语句中来对可选类型的值进行判断并把值赋给一个常量或者变量。
格式：

if let tempStr = someOptional{
    tempStr//如果someOptiona有值的话，就会赋值给tempStr，然后使用
}

var myStr:String?
myStr="可选绑定"
if  let tempStr = myStr {
    print(tempStr)
}else{
    print("字符串为nil")
}

运行结果

可选绑定

B.在可选类型判断中还有guard let的用法，guard名为守卫的意思。guard let和if let刚好相反，guard let守护一定有值。如果没有，直接返回

let name: String? = "张三"
let age: Int? = 10

guard let nameNew = name,
      let ageNew = age
else {
        print("姓名 或 年龄 为nil")
        return
}

print("姓名 或 年龄 为\(name),\(age)")//运行到这里是一定有值的

1.5 as! 与 as? 的类型转换

在写Swift代码时总是拿不准到底使用哪个，有时会根据编辑器的提示去Fix，但是这样不能很好的解决问题。
1.as!使用场合

向下转型（Downcasting）时使用。由于是强制类型转换，如果转换失败会报 runtime 运行错误。就是说强制从父类转换成子类

class Animal {}
class Cat: Animal {}
let animal :Animal  = Cat()
let cat = animal as! Cat

2.as?使用场合

as? 和 as! 操作符的转换规则完全一样。但 as? 如果转换不成功的时候便会返回一个 nil 对象。成功的话返回可选类型值（optional），需要我们拆包使用。由于 as? 在转换失败的时候也不会出现错误，所以对于如果能确保100%会成功的转换则可使用 as!，否则使用 as?

let animal:Animal = Cat()

if let cat = animal as? Cat{
    print("cat is not nil")
} else {
    print("cat is nil")
}

二、可选类型的使用场景

2.1 函数或方法的返回类型为可选类型

在方法中返回值如Int?、String?、(Int, String)?、[Int]?、[Int: String]?等

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

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

运行结果

返回类型是可选类型值

返回类型为闭包可选

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

运行结果

返回类型是可选类型闭包

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

可选类型在类中的使用

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

let someClass = PossibleClass(someValue: 4)

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

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

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

2.3 可选类型在构造器中使用

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

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

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

2.4 可选类型在错误处理中使用（try!与try?）

1.try?会将错误转换为可选值，当调用try?＋函数或方法语句时候，如果函数或方法抛出错误，程序不会发崩溃，而返回一个nil，如果没有抛出错误则返回可选值。
2.使用try!可以打破错误传播链条。错误抛出后传播给它的调用者，这样就形成了一个传播链条，但有的时候确实不想让错误传播下去，可以使用try!语句

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

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

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