Swift里的switch比OC里面强大很多，switch的主要特性就是模式匹配。
下面先举个非常简单的例子。
let people = (age: 27, name: "karl")
switch people {
case (_, let name):
print(name)
default:
break
}
输出 karl
看完上面的代码，如果看不懂没关系，下面将对模式匹配经行详解。
普通模式
这是最常用的写法，用法与OC基本相同。
switch 1 {
case 1:
print("1")
}
绑定变量
enum School {
case Student(name: String, age: Int, address: String?)
case Teacher(name: String, age: Int, address: String?)
}
let karl = School.Student(name: "karl", age: 27, address: "AH")
switch student {
case .Student(let name, let age, let address):
print("\(name) -- \(age) -- \(address)")
default:
break
}
我们创建karl这个常量时给其设置了name,age,address，我们就可以在switch里面通过值绑定的形式将其取出来。
在上面的case .Student(let name, let age, let address):用了三个let显得有些繁琐，可以这样写case let .Student(name, age, address):
通配符
使用通配符表示忽略这个值，这个值不重要，我不需要使用到它，但是这个也分为两种情况。
let student = School.Student(name: "karl", age: 27, address: nil)
let teacher = School.Teacher(name: "wang", age: 50, address: "AH")
- _ :这个值完全不重要，可有可无，是什么我都不关心。
switch student {
case let .Teacher(name, _, _):
print("name: \(name)")
default: break
}
这里第二个参数和第三个参数就是使用了通配符表示，不关心它是什么值，只要前面参数能匹配成功就可以，就算成立。
- _? :这个值我虽然不用，但是它必须有值。
switch student {
case let .Student(name, age, _?):
print("name: \(name)")
default: break
}
这里第三个参数我使用了_?,表示这个值我不用，但是不能为nil
使用于元祖
就是我最上面举的那个例子。
let people = (age: 27, name: "karl")
switch people {
case (_, let name):
print(name)
default:
break
}
我并不关心age这个值，我只想取出name。
在条件中使用where语句
switch student {
case let .Student(_, age, _) where age > 30:
print("\(age)")
default:
break
}
当case匹配成功，并且绑定的值要符合where的条件才算真的成立。
匹配Range
let number = 10
switch number {
case 0 ... 7:
print("0 ... 7")
case 10 ..< 20:
print("10 ..< 20")
default:
break
}
输出： 10 ..< 20
可以通过区间的形式来匹配
类型推断和类型转换
protocol Animal { }
struct Dog: Animal { }
struct Cat: Animal { }
var animalArray = [Animal]()
let dog = Dog()
let cat = Cat()
animalArray.append(dog)
animalArray.append(cat)
for item in animalArray {
switch item {
case is Dog:
print("dog")
case let cat as Cat:
print("cat")
default:
break
}
}
可以通过is判断这个值是否是某个类型。是的话，表示匹配成功。
通过 as可以将这个值尝试转换为某个类型，如果成功，则表示匹配成功。
模式匹配操作符
struct Size {
var width: CGFloat
var height: CGFloat
}
let size = Size(width: 20, height: 20)
func ~=(lhs: CGFloat, rhs: Size) -> Bool {
return lhs == rhs.height * rhs.width
}
switch size {
case 400:
print("👍")
default:
print("!!!")
}
我们可以重载~=这个操作符，让我们自定义switch匹配规则
看上面的代码，我们重载了~=操作符，操作符有两个参数，返回一个Bool值。
- 参数1：switch中case后的值
- 参数2：switch中传入的值
- 返回值：是否匹配成功
我的这个~=方法定义的是size的width * height 等于 case的值就表示匹配成功。
这里只是一个简单的实验。具体用途需要看实际情况。
关于Optionals
let count: Int? = 5
switch count {
case 1?:
print("1")
case 3?:
print("3")
case 5?:
print("5")
case _:
print("nil")
default:
break
}
匹配一个可选值，要使用?的形式，要不然会报类型不匹配的错。
这个时候count其实相当于Optional.some(5)
而下面的各个case相当于
case Optional.some(1):
print("1")
case Optional.some(3):
print("3")
case Optional.some(5):
print("5")
使用?的形式写，算是一个语法糖
if case let
if case let a = b {
}
表示b是否能匹配上a。
这就相当于
switch b {
case let a:
break
}
当只有一个条件的时候，用switch会显得冗余，直接用if case let会使代码读起来更便捷。
直接拿上面的绑定变量那一节的内容来说，如果直接这么写的话，会显得更易读，而且也会少点代码。
if case let .Student(name, age, _?) = student {
print(name)
}
当然，这里也是可以用where语句的，但是在swift3以后，有些场景的where被逗号给代替了，如果给上面的if case let加上where条件的话，就是这样：
if case let .Student(name, age, _?) = student, age > 20 {
print(name)
}
一行代码就可以写出一个很强的表达式。
guard case let
guard case let的用法和if case let是一样的，区别也仅仅是if和guard的用法区别，就不多啰嗦。
for case let
一个数组里存放的是Any类型的可选值,我想输出这个数组里面大于10的数字。
let array: [Any?] = [1,2,nil,4,54,65,76, ""]
在不知道 for case let之前，写法是这样的。
先遍历出所有的元素，在尝试元素转成Int,在判断是否大于10。
for item in array {
if let element = item as? Int, element > 10 {
}
}
在看看下面这种写法。
先将遍历出来的元素绑定到x上，并且x不能为nil，然后在用where增加一个要是>10的条件。
是不是感觉清爽很多，又是一行代码写出一个强有力的表达式。
for case let x? as Int? in array where x > 10 {
print(x)
}
在举个例子，还用一下之前定义的enum School
let xiaoming = School.Student(name: "xiaoming", age: 10, address: nil)
let wang = School.Teacher(name: "wang", age: 50, address: "AH")
let li = School.Teacher(name: "li", age: 50, address: "ZJ")
let xiaoqiang = School.Student(name: "xiaoming", age: 14, address: "BJ")
let xiaohao = School.Student(name: "xiaohao", age: 17, address: "SH")
这里有5个School类型的常量，有2个Teacher，3个Student。
把他们都加到一个数组里，
let schoolArray = [xiaoming, wang, xiaoqiang, li, xiaohao]
我现在想获取到数组里的Student，并且address不能为空，并且age要小于15的。
看看我们使用for case let怎么解决。
for case let .Student(name, age, _?) in schoolArray where age < 15 {
print(name)
}
还是一行代码，帅！
很多时候，我们在网上看到一些新的语法，看着介绍很牛逼，也都能看明白，但是一让自己放到项目里就懵逼，因为没用过，所有压根不知道这种形式改怎么用到项目里。
这个举个最常见的的简单的例子，网络请求。
enum Result {
case success(Data)
case error(Error)
}
func loadNetworkData(_ urlString: String, completion: @escaping (Result) -> ()) {
guard let url = URL(string: urlString) else {
fatalError("url 错误")
}
let task = URLSession.shared.dataTask(with: url) { (data, _, error) in
var result: Result!
if let e = error {
result = Result.error(e)
completion(result)
return
}
if let d = data {
result = Result.success(d)
completion(result)
}
}
task.resume()
}
loadNetworkData("") { (result) in
switch result {
case let .success(data):
print("scrress: \(data)")
case let .error(error):
print("error: \(error)")
}
}
定义了一个enum Result，里面有两个case，分别表示网络请求成功和失败，成功则给一个Data，失败则给一个Error。
然后有一个加载网络数组的方法func loadNetworkData，方法就是最普通的网络请求，在请求回调里，判断error是否有值，如果有值则创建一个error类型的Result，如果data有值，则创建一个success类型的Result。
在发起网络请求的方法回调里，就可以通过模式匹配的方法判断回调回来的Result到底是什么类型，然后通过值绑定的形式，取出success的data或者是error的值。
当然这只是一个简单的写法，只是提供一点思路。具体怎么在项目里面用还是需要去实践。
这就是个人总结的一些模式匹配的用法，都是自己在工作过程和学习过程中总结的一些经验，有自己的使用总结，当然也有在网上看一些博客的总结，希望对能读到这篇文章的同学有所帮助。
如果文章中有什么使用不当和使用错误的，一定请指出来。谢谢！
