前言

oc里面没有 optional value 和 guard 这两个概念，下面讲解一下swift里面的这两个很有用的东西。

1. Optional Binding

    var a :Int = 10
    a = nil   //这里会编译错误

在oc中，所有类型都不能接受nil的，所以swift给出了一种可选类型：

   var a Int? = 10 
   a = nil   //编译正确

？表示的就是 ，该变量可以有值也可以为nil.

    optional 值的声明：
    var str :String ! = "haha"
    var str :Optional<String>

拆包：
*显式拆包和隐式拆包
一个变量有可能有值有可能没有值的时候 就用 ？ 但是当用到这个变量的时候 说明一定是有值的，需要在后面加上 ！，即为显式拆包

    var n1 : int? = 10    print(n1)   //打印为 optional(10)

    var n1 : int? = 10   print(n1+10)  // 编译错误
    这里需要拆包
    *显示拆包
    var n1 : int? = 10        print(n1 ！+10) 
     *隐式拆包
    var n1 : int! =10  print(n1+10)

例子：

    *显式拆包
    var count :Int?
    count = 100
    if count != nil{
            "count is" + String(count !)   //count is 100
    } else{
            "nil"
    }
    *隐式拆包
    var count :Int?
    count = 100
    if let a = count{
            "count is" + String(a)   //count is 100
    } else{
            "nil"
    }

2. Optional Chaining

直接上例子

    class Person{
            var pet : Pet?
    }
    
    class Pet{
            var name:String
            var toy: Toy?
            init(name:String){
                    self.name = name
            }
    }

    class Toy{
            var name:String
            init(name:String){
                    self.name = name
            }
    }

如果用 optional binding 将每个optional值赋给临时变量，再做if判断：

    let jack = Person()
    jack.pet =Pet(name:"hehe")
    jack.pet?.toy = Toy(name:"haha")
    if let pet = jack.pet{
            if let toy = pet.toy{
                    toy.name
            }
    }

如果用optional chainng 用一个optional值去调用下一个optional值，只要其中有一个为nil，整条chaining就为nil:

    let jack = Person()
    jack.pet =Pet(name:"hehe")
    jack.pet?.toy = Toy(name:"haha")
    if let toy = jack.pet?.toy{
            toy.name
    }
    使用optional chaining能使我们的代码变得更加简洁，
    如果我们Pet类有一个玩玩具的play方法的话，可以这样判断：
    if let p:Void = jack.pet?.play(){
            "play is yes"
    }
    注意：Void也算一个类型：typealias Void = ()

3.Guard

一般的if判断是这样的：将不符合的条件全部排除，剩下的就是符合要求的：

    func text(a:Int?){
            if a ==nil || a<= 0{
                    return    //不符合值的要求
            }
            //符合值的要求
            a!.description
    }

上面这样的判断有可能导致有很多个判断条件，不简洁美观，而且在判断完后，即使符合值的要求，还需要进行拆包。

上面的代码可以优化成这样：

     func text(a:Int?){
            if let a = a where a> 0{
                    //符合值的要求
                    a!.description                        
            }
             //不符合值的要求...
    }

这次代码就是判断符合要求的值，并且能隐式拆包了。

而guard语句，可以完美结合上述两种，既能排除不符合条件的判断，又能做隐式拆包：

    func text(a:Int?){
            guard let a = a where a> 0 else{
                    return    //不符合值的要求                    
            }
             //符合值的要求
              a!.description
    } 

上市意思是：判断满不满足该条件，满足该条件之外的条件就是不满足的条件，就return.

以上是我对Optional Value 和 Guard的理解，说的不对的地方或者有更多见解的地方欢迎一起讨论