swift的？和 ！

var 定义变量时，不会给变量赋初值，所以就意味着，我们必须要在使用变量之前给变量赋初值，如果不赋初值将会报错。

var str :String

let hashValue = str.hashValue​

这时上面就报错了：variable 'str' used before being initialized​

就引出了swift的？，可选类型：Optional

可选类型是：要么有值，等于x；要么就什么都没有，就是nil；

定义可选类型只需要在可选类型之后加上？即可

var str:String?

那么optional 是什么呢？根据定义，optional其实是一个enum的类型，定义如下：

public enum Optional : _Reflectable, NilLiteralConvertible {

case None

case Some(Wrapped)

/// Construct a `nil` instance.

public init()

/// Construct a non-`nil` instance that stores `some`.

public init(_ some: Wrapped)

/// If `self == nil`, returns `nil`.  Otherwise, returns `f(self!)`.

@warn_unused_result

public func map(@noescape f: (Wrapped) throws -> U) rethrows -> U?

/// Returns `nil` if `self` is `nil`, `f(self!)` otherwise.

@warn_unused_result

public func flatMap(@noescape f: (Wrapped) throws -> U?) rethrows -> U?

/// Create an instance initialized with `nil`.

public init(nilLiteral: ())

}

可以看出，其实它有两种类型None和Some，其中optional.None​就是nil的，而非nil的就是optional.Some的​，通过Some(Wrapped)将原始值封装一下，这也就是为什么我们需要在使用optional的时候去解包。

var str:String?      <====>  var str:Optional​

上面的两句是等价的，但是在这里我们需要记住的是，我们声明的是一个Optional类型的变量，而不是一个String类型的变量，这里我们声明的Opitional类型的变量可能包含一个String类型的值，也可能不包含这个值。记住这里是一个Optional类型的变量。

​我们在定义了Optional的变量在没有显式的赋值时它默认的值是nil。

在使用Optional值的时候需要在具体的操作，比如调用方法、属性、下标索引等前面需要加上一个?，如果是nil值，也就是Optional.None，会跳过后面的操作不执行，如果有值，就是Optional.Some，可能就会拆包(unwrap)，然后对拆包后的值执行后面的操作，来保证执行这个操作的安全性，例如：

let hashValue = str?.hashValue

str是Optional类型的字符串，如果str是nil，则hashValue也为nil，如果str不为nil，hashValue就是strValue字符串的哈希值。

Optional定义的变量在使用的时候需要​解包：解包的方式分为显式和隐式。

显示的拆包：

Optional 类型不能被直接的使用，当需要用的时候需要显示拆包，已表明我知道这个Optional是一定有值的。我们已确定这个变量一定有值时可以用显示的拆包。

可以直接使用：let hashValue = str.hashValue

如果不确定，可以使用if语句来判断。

if let strValue = str{

let hashValue = strValue.hashValue

}​

如果str没有值是nil，此时的strValue是nil，自然不会执行下面的解包语句。

隐式的拆包：

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

var str:String!  = “Hello World”

这样做相当于告诉编译器，在我们使用Optional值前，这个Optional值就会被初始化，并且总是有值，所以相当于编译器帮我们做一次拆包。

隐式的拆包其实是在声明的时候就告诉编译器这个变量一定有值。

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"

}