在上一篇文章Swift中一些常见的关键字一(inout,defer,throw等)简单的介绍了几个关键字。本文续写。
guard
guard关键字和常见的if关键字是一对兄弟般的关系。两者的目的是同样的 -- 进行条件判别；只是在使用上有所不同。
我们很熟悉if-else，它表示条件成立则执行if中的内容，不然执行else语句中的内容。而guard-else则表示，如果guard成立则继续往下执行，不然在else中return。
对比一段代码加深了解：
// if - else
let a = 100
if a % 20 == 0{
if a % 5 == 0{
print(a / 5)
}
}
return
/// 这是一个双重判断语句，需要在两个`if`条件都通过的情况下，才能执行到我们真正的逻辑代码。
很显然，这种嵌套写法很不友好，可读性也很差，可以进行改进：
let a = 100
if a % 20 == 0 && a % 5 == 0{
print(a / 5)
}
return
尽管这样这样已经很简洁了，但是当我们的条件越来越多的时候， if 判断的代码将变的更长更复杂，这种方式的可读性其实也不好。不仅如此，多条件的综合判断将使得代码更加混乱，可读性也随之降低，这并不十分可取。
那继续改进一下：
let a = 100
if a % 20 != 0 { return }
if a % 5 != 0{ return }
print(a / 5)
这里我们思维转换了一下，取他们的相反的逻辑进行处理。理解起来的话，不再是如果......就......,而是除非......那么。
显然这种方式的可读性是最好的，我个人推荐这种方式。 但是，这种方式并非完美，因为使用if实现除非语法，我们总要谨记在括号内带上return字段，如果漏掉，代码逻辑就会出现问题，而编译器却不会报错 --- 这增加了代码bug的概率。Swift提供了一种安全的方式，书写除非......语句 --- guard-else。
同样，上面的代码使用guard-else来实现如下:
let a = 100
guard a % 20 == 0 else{ return }
guard a % 5 == 0 else{ return }
print(a / 5)
Swift规定，guard - else必须同时出现，而且，else中，必须进行return。
这就保证了我们不会漏掉return，同时，guard条件本身也是正相关：如果条件成立则执行下一步。这符合我们的思维习惯，相比之下， if ！ 则需要我们对条件进行一个非转换，和我们的思维习惯不合。这里体现了guard - else的优势。
当然，guard - else不能取代if - else。如果是两个选择判断语句中，我们还是使用if -- else语法更为合理。比如：
//这种不存在结束的条件判断，并不适合使用guard关键字。
let a = 100
if a > 80{
print(a-80)
}esle{
print(80-a)
}
总结，
guard - else在除非 - 则.. - 不然 - 结束的语法中，使用最为合适。
if let
if let 关键字是一个组合关键字。我们主要使用它解决Optional对象解包时产生空对象的处理。
Swift中，有着严格类型安全要求，如果一个对象可能为nil的时候，我们需要对这个对象用?进行修饰,就像下面这个属性：
var prop: String? = nil //初始化为一个空对象
如果我们需要使用这个prop的时候，由于这是一个封包（Optional）对象，也叫可选对象，如果直接调用，需要带上！修饰符号，就像这样：
self.prop！ = "test"
prop后的!会被强制携带，不然会报错。这是因为，赋值操作是一个确定类型的动作，所以需要使用 ! 对 ？修饰的可选对象进行解包。这种写法其实欠妥的，因为，当prop是一个nil的时候，上面这个语句将会报错，原因：为nil赋值是不允许的。
当然，我们可以对这个对象进行判断，如果不为空才执行赋值操作。如：
if self.prop != nil{ self.prop！ = "test" }
或者
guard self.prop != nil else{ return }
self.prop! = "test"
而实际上，在Swift中，提供一种专门的方式用于解包时的操作，那就是if let 关键字。依然是上面的例子，使用if let 书写的话如下：
if let aProp = self.prop{
aProp = "test"
...其他更多的操作
}
这个例子是对显式的封包属性进行操作，除此之外，if let 还可以用于强制的类型转换。
正常情况下，我们在Swift 中是不能进行类型转换的，如果强转，导致Crash的概率很高 ---- 就算是开发者，也同样不能保证自己的对象类型是不是真的是要转化的类型。if let 用于可像下面这样安全的进行强制转换：
if let typeAObj = typeBObj as? typeA{
// 如果能够转换成功，那么typeAObj就是强转后的对象
....
}else {
// 转化失败，这里一般不会做处理
}
if case
在学习 if case之前，我们先想想，那些地方使用到了case 这个关键字，毫无疑问，绝大多数使用case的时候，是在 switch语法中。
Swift中的if case主要用于模式匹配。跟switch很类似，但它本身有特别的使用场景，区别switch在于，switch用于对所有的对象可能值进行判断，而if case之需要对关注的可能值进行判断。老规矩，还是代码上看看。
假设我有一个枚举变量CarBrand,汽车品牌。它的结构如下：
enum CarBrand{
case BMW
case AUDI
case BENZ
}
如果使用switch进变量匹配，并按照不同的车的品牌输出对应的中文名字（这种需求当然可以通过添加属性值的方式更简便的解决，但这里我们只讨论if case的使用，暂时不关注其他的方式。）。我们可能是这样做的：
let myBrand = CarBrand.BMW
switch myBrand{
case .BMW: do{ print("宝马") }
case .AUDI: do{ print("奥迪") }
case .BENZ: do{ print("奔驰") }
}
实际上，我们可能仅仅是想找出BMW的品牌而已，但是我却需要写一部分跟这个品牌无关的代码。我们可以进行一点简化：
switch myBrand{
case .BMW: do{ print("宝马") }
default: () // do nothing
}
可能觉得这个方式还是过于繁琐，有什么办法可以像if那样对枚举值判断吗？
if case应该能帮到你：
let myBrand = CarBrand.BMW
if case .BMW = myBrand{
print("宝马")
}
这样不就舒服多了，不仅没有冗余的代码，还有具备了更好的可读性。
if case let
if case let它实际上不是一个完整的关键字，它 if case和let的组合。我们同样会在对枚举类型进行模式匹配的时候用到它，不过这个情况稍微复杂一点。
假设我的CarBrand枚举想要集合更多的东西，比如它的中文名字和生产地。我们可以这样定义这个枚举：
enum CarBrand{
case BMW(name:String,Production:String)
case AUDI(name:String,Production:String)
case BENZ(name:String,Production:String)
}
现在我定一个枚举变量：
let myCar = CarBrand.BMW(name: "宝马",Production: "德国")
如果我想输出myCar的关联属性，直接使用点语法什么的都显然是不行的。我们可在枚举中自定义一些输出关联属性的方法，但是这个做法比较繁琐，并且破坏了枚举结构。
比较简单的是可以使用switch：
switch myCar {
case let CarBrand.BMW(name,Production):
print("This car named \(name)，from\(Production)")
default: () // 不做任何处理
}
这样确实可以的。同样我们觉得这样还是过于繁琐了。
使用if case let：
let myBrand = CarBrand.BMW(name: "宝马",Production: "德国")
if case let CarBrand.BMW(name, Production) = myBrand{
print("\(name),\(Production)")
}
是不是更加简洁呢。当然,if case let 还可一配合where从句写出更加优雅的代码哦。
