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从句写出更加优雅的代码哦。
关于大于或者小于的匹配
//传统用法
if x>=6 && x < 12 {
}
//模式匹配用法
if case 6..<12 = x {
}
复杂一点，如果x是Optional对象，这里可以采用嵌套的模式匹配
//传统用法
if let x = x, x>=6 && x < 12 {
}
//模式匹配用法
if case .some(6..<12) = x {
}
pattern有很多种，看一下官方文档
GRAMMAR OF A PATTERN
pattern → wildcard-pattern
pattern → identifier-pattern
pattern → value-binding-pattern
pattern → tuple-pattern
pattern → enum-case-pattern
pattern → optional-pattern
pattern → type-casting-pattern
pattern → expression-pattern
这里不详细介绍这些pattern，更多的应该switch里面去学习，也就是说switch里面可以使用的在if里面都可以使用
这里举一些例子
1. type-casting-pattern
var t : Any = 10
if case is Int = t {
print("bingo")
}
if t is Int {
}
上面两种用法结果是一样的，一种是模式匹配，另外一种是常用的is operator
2. tuple-pattern
if case (1..<10, 1..<20) = (7, 8) {
}
在这里(1..<10, 1..<20)是一个pattern，而不是普通的tuple，这里会对左右两边的tuple的元素一一进行patteren match
如果把前面换成一个tuple就会出错里，试试看下面的代码
let pattern = (1..<10, 1..<20)
if case pattern = (7,8) {
}
3. optional-pattern
var t : Any? = 10
// 判断t是不是nil，和判断 t ！= nil 等效
if case _? = t {
}
//判断t是不是nil，如果有值则绑定到x
if case let x? = t {
}
4. expression-pattern
前面提到的case 6..<12 = x实际上就是这一种pattern，实际上这里调用了一个函数，也是一个操作符~=
func ~= (pattern: String, value: Int) -> Bool {
return pattern == "\(value)"
}
if case "123" = 123 {
}
通过重载~=操作符，我们可以实现很多自定义的模式匹配，结合起来可以有很多有趣的用法
上面通过一些例子介绍了if中的模式匹配用法，在代码中也有常常遇到这种用法，这种用法可以看成是switch case的一种简易写法，这样理解起来就比较容易了
if case expression1 = expression2 {
statements
}
//等价于
switch expression2 {
case expression1:
statements
default:
break
}
available用法
这是一种特殊的if用法，用来判断运行环境
if #available(platform name version, ..., *) {
statements to execute if the APIs are available
} else {
fallback statements to execute if the APIs are unavailable
}
这个比较简单，不再介绍
混合使用
上面四种if的使用方法可以混合使用，在一个if语句中可以有多个condition，通过,分开，这些condition会依序执行
var t : Any? = 10
if case let xs? = t, xs is Int {
print("bingo")
}
这里会首先将t进行optional-pattern的匹配和绑定，然后判断xs是否是Int
condition之前常用&&操作符进行的判断也可以换成使用逗号分割，效果是一样的
最后看一下官方文档对if和condition list的描述
可选类型的模式匹配
swift之模式(Pattern)
模式简介
模式代表单个值或者复合值的结构。比如
(10,20)和("Tom","Mary")在结构上并无本质差别，都是包含两个值的元组。swift中的模式分为两类，一类能成功匹配任何类型的值，另一类在运行时匹配某个特定值时可能会失败。
第一类用于解构简单变量、常量和可选绑定中的值。包括通配符模式 和标识符模式以及包含这两种模式的值绑定模式和元组模式。可以为这类模式制定一个类型标注，从而限定他们只匹配某种特定类型的值。
第二类用于全模式匹配。，这种情况下你视图匹配的值在运行时可能不存在。包括枚举用例模式、可选模式、表达式模式和类型转换模式。
具体实例
- 通配符模式（Wildcard Pattern):不关注匹配的值
for _ in 1...3 {
// Do something three times
}
标识符模式(Identifier Pattern):匹配任何值并且把匹配到的值绑定给变量或者常量。
值绑定模式(Value-Binding pattern):把匹配到的值绑定给一个变量或者常量，绑定给常量时用
let,绑定给变量时用var。
let point = (1,2)
switch point {
case let (x,y):
print("The point is at (\(x), \(y))") //The point is at (1, 2)
}
- 元组模式
- 逗号分隔的具有一个或者多个模式的列表
- 可以使用类型标注去限定一个元组模式可以匹配那些元组类型。
- 元组模式被用于
for-in语句或者变量火证常量声明时，金可以包含通配符模式、标识符模式、可选模式或者其他包含这些模式的元组模式。
let points = [(0,0),(1,0),(2,0),(0,3),(1,1),(2,1)]
for (x,y) in points where y == 0 || x == 0 {
print("Point(\(x), \(y)) is on axis!")
}
for point in points {
switch point {
case (_,0), (0,_):
print("Point(\(point.0), \(point.1)) is on axis!")
default:
break
}
}
- 枚举用例模式(Enumeration Case Pattern)
enum SomuEnum {
case left,right
}
let direction: SomuEnum? = .left
switch direction {
case .left:
print("Turn left!")
case .right:
print("Turn right!")
case nil:
print("Keep going straiht!")
}
var someOptional: Optional = 43
//枚举用例模式匹配
switch someOptional {
case .some(let x):
print(x) // 43
case .none:
print("nil")
}
if case .some(let x) = someOptional {
print(x) // 43
}
可选项模式(Optional Pattern)
可选项模式匹配
Optional枚举在some(Wrapped)中包装的值。
var someOptional: Optional = 43
if case let x? = someOptional {
print(x) // 43
}
let arrayOfOptionalInts: [Int?] = [nil,2,3,5,nil]
for case let number? in arrayOfOptionalInts {
print("Found a \(number) !")
}
类型转换模式(Type-Casting Pattern)
is模式：只出现在switch语句的case标签中，当一个值的类型在运行时与模式右边指定类型一致或者是其子类的情况下才会匹配。as模式:当一个值的类型在运行时和右边指定类型一致或者是其子类的情况下，才会匹配。如果匹配成功，被匹配值的类型被撞换成as模式右边指定的类型。
class MediaItem {
var name: String
init(name: String) {
self.name = name
}
}
class Movie: MediaItem {
var director: String
init(name: String, director: String) {
self.director = director
super.init(name: name)
}
}
class Song: MediaItem {
var artist: String
init( name: String, artist: String) {
self.artist = artist
super.init(name: name)
}
}
let library: [MediaItem] = [
Movie(name: "Casablanca", director: "Michael Curtiz"),
Song(name: "Blue Suede Shoes", artist: "Elvis Presley"),
Movie(name: "Citizen Kane", director: "Orson Welles"),
Song(name: "The One And Only", artist: "Chesney Hawkes"),
Song(name: "Never Gonna Give You Up", artist: "Rick Astley")
]
for mediaItem in library {
switch mediaItem {
case is Song :
print("Song: \(mediaItem.name)")
case let movie as Movie:
print("Movie: \(movie.name) director: \(movie.director)")
default:
break
}
}
-
表达式模式(Expression Pattern)
只出现在
switch的case标签中。表达式模式代表的表达式会使用Swift的标准库中的
~=运算符与输入表达式的值进行比较，如果~=预算内算符返回true,则匹配成功。因此自定义类型要使用表达式模式匹配，需要重载~=运算符。
let point = (0,0)
func ~= (pattern: String, value: Int) -> Bool {
return pattern == "\(value)"
}
switch point {
case ("0","0"):
print("(0,0) is at the origin.")
default:
print("The point is at (\(point.0), \(point.1))")
}