Swift中的模式匹配

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的值。
当然这只是一个简单的写法，只是提供一点思路。具体怎么在项目里面用还是需要去实践。

这就是个人总结的一些模式匹配的用法，都是自己在工作过程和学习过程中总结的一些经验，有自己的使用总结，当然也有在网上看一些博客的总结，希望对能读到这篇文章的同学有所帮助。
如果文章中有什么使用不当和使用错误的，一定请指出来。谢谢！