Swift当中的Optional类型，表明一个变量可能有确认的值，也可能不包含任何值。不包含任何值在Swift当中，就是一个nil。

Swift当中的变量或者常量，在使用之前必须得赋值，但是对于Optional类型来说，情形有点不一样。对于Optional变量来说，使用之前可以不用赋值：

var a: Int?
var b = a //正确
let c = a //正确

这是因为对于Optional变量来说，如果不赋任何值，编译器默认赋nil。

但是上述情况对于Optional常量不适用，如果Optional常量未显示赋值就是用，编译器报错：

let c: Int?
var a = c //报错

即使显示对Optional常量赋值nil，也是可以的：

let c: Int?
c = nil
var a = c //正确

Swift当中不能重复声明变量，即使变量名字相同，类型不同也不行，或者将同一个名字声明为变量的同时，还声明成常量也不行。在这里，将相同名字的变量声明成Optional类型也不行：

var a:Int
var a:Int? //报错

let a:Int
var a:Int? //报错

let a:Int
let a:Int? //报错

总结起来就是一句话，如果变量或者常量相同，那么就只能声明一次。

Swift中Optional的变量或者常量，不能直接复制给非Optional的变量或者常量，但是反过将非Optional的变量或者常量，赋值给Optional的变量或者常量是没问题的：

let a: Int? = 1
let b: Int = a //报错


var a: Int? = 1
var b: Int = a //报错

let a: Int = 1
let b: Int? = a //可以

var a: Int = 1
var b: Int? = a //可以

Forced Unwrapping

在使用Optional变量或者常量之前，一定要使用if语句测试，看他们是否是nil，如果确认不是nil，那就可以进行Forced Unwrapping，也就是在Optional变量或者常量豁免适用!，以此向编译器说明，你确定了该变量或者常量有值，可以放心使用：

var a: Int? = 1

if a != nil {
    print(a!) //这里如果不加!，输出Optional(1)，并且编译器会有警告
}

为什么对于Optional类型使用前要先监测呢？

因为如果不检测就是用!求值，如果求出来的值是nil，会发生运行时错误：

var a: Int?
print(a!) //发生运行时错误

Optional Binding

文字解释Optional Binding费劲，直接看代码：

var a: Int? = 1

if let b = a {  //if语句当中的let b = a这块就是Optional Biding
    print(b)
} else {
    print("nil")
}

上面if语句当中的let b = a就是Optional Binding，如果a有值，那么a的值会赋给b，否则，if语句不成立，将执行else语句。

这里进行Optional Binding的时候，适用var b = a也是没有问题的，但是由于编译器发现你对b没有改动，会出警告，提示你最好使用let。

另外一个需要注意的地方就是，这里声明的b，只能在if语句内部使用。

多个Optional Bindings可以一起使用，当中用逗号隔开就行，如果任何一个Optional Binding为nil，那么if语句就不会执行：

var a: Int? = 1
var b: Int? = nil
if let c = a, let d = b {  //if语句当中的let b = a这块就是Optional Biding 整个if语句输出nil
    print("non nil")
} else {
    print("nil")
}

对于Optional Binding来说，出了在if语句当中使用，还可以在while语句当中使用。

Implicitly Unwrapped Optionals

前面提到过对于Optional类型的变量或者常量来说，无法直接赋值给非Optional的变量或者常量。但是有些时候，对于程序里面的Optional类型，我们使用之前是可以肯定这个类型的变量或者常量是有值的，这时候如果进行Force Unwrapping就比较麻烦，这个时候就可以利用Implicitly Unwrapped Optionals了。一个变量或者常量声明成Implicitly Unwrapped Optionals和声明成Optional非常相似，只需要把?换成!:

var a: Int? //Optional
var b: Int! //Implicitly Unwrapped Optionals

编译器对于Implicitly Unwrapped Optionals的使用是这样的，首先把这个变量或者常量当成普通的Optional来对待，如果不行，那么编译器就自动进行Force-Unwrapping的操作:

var a: Int! = 2
var b = a //b类型是Optional的
var c: Int = a //无需对a显示进行Fource-Wrapping加!

对于mplicitly Unwrapped Optionals需要注意，使用的时候千万不能是nil的，否则会报运行时错误。