Swift 作为现代、高效、安全的编程语言，其背后有很多高级特性为之支撑。

『 Swift 最佳实践』系列对常用的语言特性逐个进行介绍，助力写出更简洁、更优雅的 Swift 代码，快速实现从 OC 到 Swift 的转变。

该系列内容主要包括：

Optional
Enum
Closure
Protocol
Generics
Property Wrapper
Error Handling
Advanced Collections
Pattern Matching
Metatypes(.self/.Type/.Protocol)
High Performance

ps. 本系列不是入门级语法教程，需要有一定的 Swift 基础

本文是系列文章的第九篇，主要介绍 Swift Pattern Matching，其功能强大，合理利用它们可以写出非常简洁、优雅的代码。

Overview

何为 Pattern？

A pattern represents the structure of a single value or a composite value.

— Swift Docs – Patterns

Pattern 表示一个或一组值的「结构」、「特征」。

说实话，Swift 官方的这个解释并不清晰易懂 ?。

直观讲，可以将 Pattern 类比为「正则表达式」。

所谓 Pattern Matching，就是一次 Pattern 与 Value 的「较量」，其目的有 2 个：

Destructure values，从 Value 中根据指定的 Pattern 提取值；
Matching，判断 Value 与 Pattern 是否匹配，主要用于 switch...case、if/guard、for...in 以及 do...catch，其亦是本文的主角。

在 Swift 中有 8 种类型的 Pattern：

Wildcard Pattern
Identifier Pattern
Value-Binding Pattern
Enumeration-Case Pattern
Optional Pattern
Type Casting Pattern
Expression Pattern
Tuple Pattern

其中：

Wildcard Pattern、Identifier Pattern 以及 Value-Binding Pattern 主要用于提取值 (Destructure values)；
Enumeration Case Pattern、Optional Pattern、Type Casting Pattern 以及 Expression Pattern 用于匹配 (Matching)；
Tuple Pattern 属于 Pattern 的组合，即将多个 Pattern 组合成一个元组。

下面就上述 8 种 Pattern 分别展开介绍。

Wildcard Pattern

Wildcard Pattern，通配符模式：

用下划线(underscore) _ 来表示
可以匹配任何值
通常用于不关心具体值的场景

如：

for _ in 1...10 {
  // do something，repeat 10 times
}





let points = [(0, 1), (1, 1), (0, 2)]
//          ?
for case (0, _) in points {
  // all points with an x-coordinate of 0
}

Identifier Pattern

Identifier Pattern，标识符模式：

可以匹配任何值
将匹配到的值绑定到一个变量 (var) 或常量 (let) 名上

如：

//     ?
let someValue = 1

var someValues = [1, 3, 5, 10, 7, 9]
//      ?
for someValue in someValues {
  // do something
}

Value-Binding Pattern

Value-Binding Pattern，值绑定模式，与 Identifier Pattern 非常相似，或者可以说 Identifier Pattern 是其子模式。如：

let point = (3, 2)
switch point {

// Bind x and y to the elements of point.
case let (x, y):
  print("The point is at ((x), (y)).")
}

Enumeration-Case Pattern

Enumeration-Case Pattern，enum-case 模式可以说是我们最熟悉的匹配模式了，没有之一。

对于有 Associated-Value 的 case，在 switch 时可以通过 Value-Binding Pattern 获取关联值，实际上是「 Enumeration-Case Pattern 」 + 「 Value-Binding Pattern 」的组合模式：

enum SomeEnum {
  case a(Int)
  case b(String)
}








let someEnum = SomeEnum.a(1)
switch someEnum {
case .a(let aValue):  // ?
  print(aValue)
case .b(let bValue):
  print(bValue)
}

对于 Optional 类型的枚举值也可以直接通过 switch...case 进行匹配，而无需先进行 Optional unwrapping：

//                   ?
let someEnum: SomeEnum? = SomeEnum.a(1)
switch someEnum {
case .a(let aValue):
  print(aValue)
case .b(let bValue):
  print(bValue)
case nil:        // ?
  print(""nil)
}

Optional Pattern

Optional Pattern，可选值模式：

由于 Optional value 本质上是个 enum，故 Optional Pattern 是 Enumeration-Case Pattern 的语法糖
其形式是：case let name?

如：

let someOptional: Int? = 42

// Match using an optional pattern.
if case let x? = someOptional {
  print(x)
}








// Equivalent to ==>

// Match using an enumeration case pattern.
if case .some(let x) = someOptional {
  print(x)
}

if case let x? = someOptional 这种写法简直是多此一举 ?？

下面这种写法不香吗：

if let someOptional {}

Optional Pattern 的主要应用场景在 for...in、switch...case：

如：

遍历 Optional-Values 的数组

let arrayOfOptionalInts: [Int?] = [nil, 2, 3, nil, 5]

// Match only non-nil values.

//
for case let number? in arrayOfOptionalInts {

  print("Found a (number)")

}





// Found a 2

// Found a 3

// Found a 5

switch…case 匹配 Optional-Value

let optionalValue: Int? = 0
switch optionalValue {
case 0?:    // ?
  print("Zero")
case 1?:    // ?
  print("One")
case 2?:    // ?
  print("Two")
case nil:
  print("None")
default:
  print("Other")
}

Type Casting Pattern

Type Casting Pattern，类型转换模式，其包含 is-pattern、as-pattern 2 个子类型：

is-pattern，判断 value 的运行时类型是否是指定的类型或其子类型，其格式：

is <#type#>

如：

switch someValue {

case is String:
  print("")

case is SomeClass:
  print("")

default:



  print("")


}

do {

  try test()

} catch is SomeError {
  // ...
} catch {}

as-pattern，除了将运算结果绑定到变量上，其他与 is-pattern 一样，其格式：

<#pattern#> as <#type#>

如：

switch someValue {

case let str as String:   // str's type is String
  print("")

case let someClass as SomeClass:  // someClass's type is SomeClass
  print("")

default:



  print("")


}

do {

  try test()

} catch let error as SomeError {
  // do something
} catch {
}

Expression Pattern

Expression Pattern，表达式模式，Pattern 是一个表达式，其功能非常强大：

匹配运算是通过 ~= 操作符完成的
```
func ~= (pattern: PatternType, value: ValueType) -> Bool
```
- PatternType 与 ValueType 相同时，~= 的默认实现用 == 进行判等操作
- 若 PatternType 与 ValueType 不相同，则需要显式地重载 ~= 操作符

正是因为有了 Expression Pattern，不仅可以对 enum 进行 switch...case 操作，任何类型的值都可以进行 switch...case 操作，如：

let someValue = 10
switch someValue {
case 0:    // ? 0 is an expression
  print("")

case 1:
  print("")


default:

  print("")

}

Tuple Pattern

Tuple Pattern，元组模式，将多个模式组合成一个元组，如：

let point = (1, 2)
switch point {

case (0, is Int):    // ? (Expression Pattern, Type Casting Pattern)
  print("")

case (1, let y):
  print("")


default:

  print("")

}

以上是关于 Swift Patterns 的基础介绍，下面介绍这些 Patterns 在开发中的应用。

典型用法

switch…case vs. if-case

switch...case 都可以转换成 if-case

switch...case 结构：

switch <#value#> {
case <#pattern1#>:
  // do something
case <#pattern2#>:
  // do something
...
}

if-case 结构：

if case <#pattern1#> = <#value#> {
    // do something
} else if <#pattern2#> = <#value#> {
    // do somethind
}

如：

switch someEnum {
case .a(let aValue) where aValue >= 1:
  print(aValue)
case .b(let bValue):
  print(bValue)
default:



  print("")


}

switch...case –> if-case：

if case .a(let aValue) = someEnum, aValue >= 1 {
  print(aValue)
} else if case .b(let bValue) = someEnum {
  print(bValue)
} else {
  print("")


}

当然，if-case 一般用于只关心其中一个 case 的情况，如有多个 case 需要处理，首选 switch...case。

Matching Custom Tuple

若有多个值有关联操作，通过「自定义元组 + Pattern Matching 」可以写出十分优雅的代码，如：

判断一个点是否是坐标原点：

老实巴交 ?：

func descPoint(_ point: (Double, Double, Double)) -> String {



  if point.0 == 0 && point.1 == 0 && point.2 == 0 {
    return "Origin Point"

  } else {
    return "Normal Point"
  }
}

小聪明 ?：

func descPoint(_ point: (Double, Double, Double)) -> String {



  if case (0, 0, 0) = point {    // ?
    return "Origin Point"

  }






  return "Normal Point"
}

还可以通过 Wildcard Pattern(_) 实现部分匹配 (Partial matches)：

func descPoint(_ point: (Double, Double, Double)) -> String {



  switch point {

  case (0, 0, 0):

    return "Origin Point"

  case (_, 0, 0):    // ?
    return "On the x-axis"
  case (0, _, 0):    // ?
    return "On the y-axis"
  case (0, 0, _):    // ?
    return "On the Z-axis"
  default:
    return "Normal Point"
  }

}

也可以通过 Value-Binding Pattern 实现部分匹配，并提取对应的值：

func descPoint(_ point: (Double, Double, Double)) -> String {



  switch point {

  case (0, 0, 0):

    return "Origin Point"

  case (let x, 0, 0):    // ? x
    return "On the x-axis, x = (x)"
  case (0, let y, 0):
    return "On the y-axis, y = (y)"
  case (0, 0, let z):
    return "On the Z-axis, z = (z)"
  case (let x, let y, let z):
    return "Normal Point, x = (x), y = (y), z = (z)"
  }

}

借助 Optional Pattern 实现多个 Optional Values 的关联操作 ?：

func authenticate(name: String?, password: String?) {
  switch (name, password) {
  case let (name?, password?):
    print("User: (name) Password: (password) ?")
  case let (name?, nil):
    print("Password is missing ?. User: (name)")
  case let (nil, password?):
    print("Username is missing ?. Password: (password)")
  case (nil, nil):
    print("Both username and password are missing ??")
  }


}

Swift 标准库中 Optional.== 的实现 swift/Optional.swift：

extension Optional : Equatable where Wrapped : Equatable {
  public static func == (lhs: Wrapped?, rhs: Wrapped?) -> Bool {
    switch (lhs, rhs) {
    case let (l?, r?):
      return l == r
    case (nil, nil):
      return true
    default:
      return false
    }
  }


}

Calculated Tuples，tuple 除了静态定义，如：

let point = (x: 0, y: 0)

还可以运行时动态生成，如：

let numbers = (number + 1, number + 2)

实现 Fizz buzz test: func fizzbuzzTest(number: Int) -> String 方法：

老实巴交 ? ：

func fizzbuzzTest(number: Int) -> String {

  if number % 3 == 0, number % 5 == 0 {
    return "FizzBuzz"
  } else if number % 3 == 0 {
    return "Fizz"
  } else if number % 5 == 0 {
    return "Buzz"
  } else {
    return String(number)
  }

}

小聪明 ?：

func fizzbuzzTest(number: Int) -> String {

  switch (number % 3 == 0, number % 5 == 0) {
  case (true, true):
    return "FizzBuzz"
  case (true, false):
    return "Fizz"
  case (false, true):
    return "Buzz"
  default:
    return String(number)
  }


}

在 Alamofire 中判断 Request.State 是否可以从一个状态转换成另一个状态时也有类似的操作：

public enum State {
  case initialized
  case resumed
  case suspended
  case cancelled
  case finished



  /// Determines whether `self` can be transitioned to the provided `State`.
  func canTransitionTo(_ state: State) -> Bool {
    switch (self, state) {  // ?
    case (.initialized, _):
      return true
    case (_, .initialized), (.cancelled, _), (.finished, _):
      return false
    case (.resumed, .cancelled), (.suspended, .cancelled), (.resumed, .suspended), (.suspended, .resumed):
      return true
    case (.suspended, .suspended), (.resumed, .resumed):
      return false
    case (_, .finished):
      return true
    }
  }
}

for-case

通过 for-case 以 Pattern Matching 的形式遍历集合：

处理集合中特定的值，如：

let ages = [10, 18, 20, 12, 18, 9]
for case 18 in ages {
  print("18!")  // repeat 2 times
}

处理 Custom Tuple 集合，如：

let tom = (name: "Tom", password: "goi09ko")
let antony = (name: "Antony", password: "po09un")
let edward = (name: "Edward", password: "okh8yd")
let francis = (name: "Francis", password: "y7ub5g")
let users = [tom, antony, edward, francis]


for case let (name, password) in users {  // Value-Binding Pattern
  // do something
}





for case let (name, "okh8yd") in users {  // Value-Binding Pattern + Expression Pattern
  // do something
}



for case ("Francis", "y7ub5g") in users {  // Expression Pattern
  // do something
}

处理集合中特定类型的值，如：

let views: [UIView] = [...]
//                ?
for case let view as UILabel in views {
  print("UILable")
}

常见老实巴交的写法 ? ❌：

for view in views {
  guard let label = view as? UILabel else {
    return
  }






  print("UILable")
}

处理 Optional-Value 集合：

let arrayOfOptionalInts: [Int?] = [nil, 2, 3, nil, 5]

// Match only non-nil values.

//                ?
for case let number? in arrayOfOptionalInts {

  print("Found a (number)")

}





// Found a 2

// Found a 3

// Found a 5

Matching ranges

如 Swift 最佳实践之 Advanced Collections 所述，Range 也可以用于 Pattern Matching，如：

switch score {

case 0..<60:
  print("Failed.")

case 60..<85:
  print("OK.")
default:



  print("Good!")
}

还可用于组合模式中，如：

let student = (name: "Audrey", score: 90)
switch student {
case let (name, 0..<60):
  print("(name) failed.")
case let (name, 60..<85):
  print("(name) OK.")
case let (name, _):
  print("(name) good.")
}

overload `~=`

如上，score 与 Range 类型并不相同，但还是可以对它们进行 Expression Pattern Matching，其原因是 RangeExpression 重写了 ~=：

extension RangeExpression {
  //                 ?
  public static func ~= (pattern: Self, value: Bound) -> Bool {
    return pattern.contains(value)
  }  
}

switch score {

case 0..<60:    // equivalent to：  0..<60 ~= score    ?
  print("Failed.")

...
}

我们也可以根据需要重写 ~=，如下 User 重写了 ~= ，故可以将其与 ClosedRange 进行 Pattern Matching：

struct User {
  let name: String
  let age: Int
}








extension User {
  //          ?
  static func ~= (range: ClosedRange<Int>, user: User) -> Bool {
    return range.contains(user.age)
  }

}


let user = User(name: "Edward", age: 28)
//      ?
switch user {
case 0...18:
  print("youngster!")
case 19...65:
  print("middle-aged!")
default:
  print("elderly!")
}

?⚠️ 重写 ~= 对于代码的可读性可能会造成一定的影响，需要谨慎使用！

where

Pattern Matching 可以通过 where 子句添加相关的约束，一般用于 switch...case、for-in 以及 do...catch。

for-in-where：

for number in numbers where number % 2 == 0 {
  print(number)
}

for view in views where view is UILabel {
  print("UILable")
}





// 需要注意的是，上述 view 的类型还是 UIView，而非 UILabel
// 下面这种写法?，view 的类型才是 UILabel 



for case let view as UILbael in views {
  print("UILable")
}

多个条件可以通过 && 连接：

for name in names where name.hasPrefix("Tom") && name.count == 10 {
  print(name)
}

do...catch：

enum SomeError: Error {
  case bar(Int)
  case baz(Int)
}








do {
  try doSomething()
} catch SomeError.bar(let code) where code > 0 {
  // do something
} catch let error as SomeError where error.localizedDescription == "hhh" {
  // do something      
} catch is SomeError {
  // do something
} catch {}

switch...case：

enum TaskStatus {
  case notStarted
  case inProgress(Double)
  case completed
}





let taskStatus = TaskStatus.inProgress(percent: 0.9)
switch taskStatus {
case .inProgress(let percent) where percent >= 0.9:
  print("Almost completed!")
case .inProgress(let percent) where percent >= 0.5:
  print("More than half!")
case .inProgress(let percent):
  print("Just begun, percent = (percent)!")
case .notStarted:
  print("Oh, has not started!")
case .completed:
  print("Good, completed!")
}

除了 enum 关联值可以用 where 约束，普通的 Expression Pattern 也可以用 where 约束，如计算 Fibonacci：

func fibonacci(position: Int) -> Int {
  switch position {
  case let n where n <= 1:
    return 0
  case 2:
    return 1
  case let n:
    return fibonacci(position: n - 1) + fibonacci(position: n - 2)
  }
}