个人总结Swift 中可选值(Optional)

Optional的定义

　　Optional是 OC 中没有的数据类型,是苹果在 Swift 中引入的全新类型,它的特点就是可有值,也可以没有值,当它没有值的时候就是 nil. 并且 Swift 中的nil 和 OC 中 nil 也不一样,在 OC 中只有对象才能为 nil, 而在 Swift 中,当基础类型(整型,浮点,布尔等)没有值的时候,也是 nil, 而不是一个初始值,没有初始值的值是不能使用的,所以就产生了 Optional 类型.定义一个 Optional 的值很容易,只需要在类型后面加上问号(?)就行了,例如:

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

注意:

　　Int?和 Int 不相同, Int? 代表可选的 Int 类型,可以赋值为 nil, 而 Int 不可以赋值为 nil

　　一个 Optional 值和非 Optional 值的区别就在于: Optional 值未经初始化虽然为 nil, 但普通变量未经初始化连 nil 都没有

//未被初始化，但是是一个Optional类型，为nil
var str: String?
str //输出nil
//未被初始化，也不是Optional类型
var str2: String
str2    //使用时出错

Optional 的拆包

<
bd12
h2 id="显式拆包">显式拆包

　　Optional 类型的值不能被直接使用,当需要用时要显示拆包,以表明我知道这个 Optional 是一定有值的:

var str: String? = "Hello World!"
str! //Hello World!

　　对比拆包前后, str 的输出

var str: String? = "Hello World!"
str     //{Some "Hello World!"}
str!    //Hello World!

　　之所以要拆包使用,是因为 Optional 类型其实是一个枚举:

enum Optional<T> : Reflectable, NilLiteralConvertible {
case None
case Some(T)
init()
init(_ some: T)

/// Haskell's fmap, which was mis-named
func map<U>(f: (T) -> U) -> U?
func getMirror() -> MirrorType
static func convertFromNilLiteral() -> T?
}

　　当 Optional 没有值的时候,返回的 nil 其实就是 Optional.None, 没有值.除了 None 之外,还有一个 some, 当有值的时候就是被 Some包装的真正的值,所以我们拆包的动作其实就是将 Some 里面的值取出来

注意:

　　1.在拆包的时候,如果是网络请求的参数中有可选值的时候,一定都要拆包,不然的话只要有一个Optional 类型的参数没有进行解包,所有的参数都会变成 Optional 类型的

　　2.使用”!”强制解包获取可选类型的值的时候容易造成程序崩溃(不建议直接使用)

var defaultAddress: String? = "上海"
if defaultAddress != nil { // !=或==可以用来判断是否为nil
print("您的地址是\(defaultAddress!)") // 使用!强制解析
} else {
print("对不起，您不存在地址信息")
}
var student: Person?
print("学生为\(student!)") // XCode会提示运行错误，因为student初始值为nil，强制解析不行

隐式拆包

　　除了显示拆包之外, Optional 还提供了隐式拆包,通过在声明时的数据类型后面加一个感叹号(!)来实现

var str: String! = "Hello World!"
str //Hello World!

　　可以看到没有使用(?)进行显式的折包也得到了Some中的值，这个语法相当于告诉编译器：在我们使用Optional值前，这个Optional值就会被初始化，并且总是会有值，所以当我们使用时，编译器就帮我做了一次拆包。如果你确信你的变量能保证被正确初始化，那就可以这么做，否则还是不要尝试为好。

　　另外：在上面可以看到，Optional其实就是一个枚举，然后给它指定一个类型就行了，所以下面这两种方法都能声明一个Optional值：

var str: String! = "Hello World!"
var str2: Optional<String>

空运算符

　　可以用来判断变量或常量是否为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!
}
}

Optional Binding

　　在说Optional Binding之前，我想先说下Xcode6 Beta5在这一版中的一个小变化：在Xcode6 Beta5之前，如果是一个Optional值，可以直接放到条件判断语句中，如：

var str: String? = "Hello World!"
if str {
"not nil"
} else {
"nil"
}

　　如果不是nil，则右边的Playground会显示“not nil”；反之则显示“nil”，但是至Xcode6 Beta5开始，这样就不能通过编译器了，你需要用下面这种方式来代替：

var str: String? = "Hello World!"
if str != nil {
"not nil"
} else {
"nil"
}

　　看似合理，但是在某种情况下会非常不爽

，比如你在str != nil条件成真后接着在上下文中使用str，会被要求进行拆包，我们以一个Int类型的Optional来做示例：

var count: Int?
count = 100
if count != nil {
"count is " + String(count!)    //count is 100
} else {
"nil"
}

　　我在把count强转成String的时候被要求拆包了，这是因为count本身是一个Optional的类型，为了避免在条件判断语句后执行一次或更多次的拆包，Swift引进了Optional Binding，我们就可以这样做：

var count: Int?
count = 100
if let validCount = count {
"count is " + String(validCount)    //count is 100
} else {
"nil"
}

　　通过在条件判断语句中（如if、while等）把Optional值直接给一个临时常量，Swift会自动检测Optional是否包含值，如果包含值，会隐式的拆包并给那个临时常量，在接下来的上下文中就能直接使用这个临时常量了，这样是不是就觉得很爽呢

Optional Chaining

　　Optional Chaining对Swift来说是很基本但又必不可少的东西，相对于简单类型(Int、String等)来说，Optional更主要的应用场景是在复杂对象上，当一个对象包含另一个对象，同时这两个对象都有可能为nil的情况下才是Optional派上用场的地方，在Objective-C里，向nil发消息得到的就是一个nil，但是Swift不能在nil上直接调用方法或属性，同时为了方便我们使用，从而引入了Optional类型，可是这还不够，我们做一个简单的例子：

class Person {
var pet: Pet?
}

class Pet {
var name: String
var favoriteToy: Toy?

init (name: String) {
self.name = name
}
}

class Toy {
var name: String

init (name: String) {
self.name = name
}
}

　　一个Person对象代表一个人，这个人可能有一个宠物，宠物会有它自己的名字，而且宠物可能会有自己喜爱的玩具，按照前面提到的知识，我们要首先判断这个人有没有宠物，然后再判断他的宠物有没有喜爱的玩具，然后才能得到这个玩具的名称，利用Optional Binding，我们写出来的可能就像这样：

let jackon = Person()
jackon.pet = Pet(name: "Max")
jackon.pet?.favoriteToy = Toy(name: "Ball")
if let pet = jackon.pet {
if let toy = pet.favoriteToy {
toy.name
}
}

　　这里用到了两个if，因为pet和toy对象都可能为nil，我们需要预防每一个可能为nil的对象，如果这个对象再复杂一点，那if也就更多了，而使用Optional Chaining的话，写出来的就像这样：

let jackon = Person()
jackon.pet = Pet(name: "Max")
jackon.pet?.favoriteToy = Toy(name: "Ball")
if let toy = jackon.pet?.favoriteToy {
toy.name
}

　　当一个Optional值调用它的另一个Optional值的时候，Optional Chaining就形成了，基本上，Optional Chaining就是总是返回一个Optional的值，只要这个Chaining中有一个值为nil，整条Chaining就为nil，和Objective-C的向nil发消息类似。

　　有一点很有趣，就是Optional Chaining除了能将属性返回的类型变为Optional外，连方法的返回值都能强制变为Optional，哪怕这个方法没有返回值，但是别忘了，Void也算是一个类型：

typealias Void = ()

　　如果我们的Pet类有一个玩玩具的play方法的话，就可以这样来判断是否会调用成功：

if let p: Void = jackon.pet?.play() {
"play is called"
}

　　使用Optional Chaining，能使我们的代码变得更加可读，同时更加简洁。

　　在我总结 Swift 的时候发现一篇简书写的也不错简书