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