swift 模式

原文：http://www.cocoachina.com/newbie/basic/2014/0612/8800.html

模式（pattern）代表了单个值或者复合值的结构。比如，元组(1, 2)的结构是逗号分隔的，包括两个元素的列表。由于模式代表一种值的结构，而不是特定的某个值，你能够把模式和各种同类型的值匹配起来。比方，(x, y)能够匹配元组(1, 2)，以及不论什么含两个元素的元组。除了将模式与一个值匹配外，你能够从合成值中提取出部分或所有，然后分别把各个部分和一个常量或变量绑定起来。

在Swift中，模式出如今变量和常量的声明（在它们的左側），for-in语句和switch语句（在他们的case标签）中。虽然不论什么模式都能够出如今switch语句的case标签中，但在其它情况下，仅仅有通配符模式（wildcard pattern），标识符模式（identifier
pattern）和包括这两种模式的模式才干出现。

你能够为通配符模式（wildcard pattern），标识符模式（identifier pattern）和元组模式（tuple pattern）指定类型凝视，用来限制这样的模式仅仅匹配某种类型的值。

模式的语法：

pattern → wildcard-patterntype-annotationopt

pattern → identifier-patterntype-annotationopt

pattern → value-binding-pattern

pattern → tuple-patterntype-annotationopt

pattern → enum-case-pattern

pattern → type-casting-pattern

pattern → expression-pattern

通配符模式（Wildcard Pattern）

通配符模式匹配并忽略不论什么值，包括一个下划线（_）。当你不关心被匹配的值时，能够使用此模式。比如，以下这段代码进行了1...3的循环，并忽略了每次循环的值：

for _ in 1...3 {            // Do something three times.        } 

通配符模式的语法：wildcard-pattern → _

标识符模式（Identifier Pattern）

标识符模式匹配不论什么值，并将匹配的值和一个变量或常量绑定起来。比如，在以下的常量申明中，someValue是一个标识符模式，匹配了类型是Int的42。

let someValue = 42 

当匹配成功时，42被绑定（赋值）给常量someValue。

当一个变量或常量申明的左边是标识符模式时，此时，标识符模式是隐式的值绑定模式（value-binding pattern）。

标识符模式的语法：identifier-pattern → identifier

值绑定模式（Value-Binding Pattern）

值绑定模式绑定匹配的值到一个变量或常量。当绑定匹配值给常量时，用keywordlet,绑定给变量时，用关键之var。

标识符模式包括在值绑定模式中，绑定新的变量或常量到匹配的值。比如，你能够分解一个元组的元素，并把每一个元素绑定到对应的标识符模式中。

let point = (3, 2) switch point {    // Bind x and y to the elements of point. case let (x, y):      println("The point is at (\(x), \(y)).") } // prints "The point is at (3, 2).” 

在上面这个样例中，let将元组模式(x, y)分配到各个标识符模式。由于这样的行为，switch语句中case let (x, y):和case (let x, let y):匹配的值是一样的。

值绑定模式的语法：value-binding-pattern → var pattern | let pattern

元组模式（Tuple Pattern）

元组模式是逗号分隔的列表，包括一个或多个模式，并包括在一对圆括号里。元组模式匹配对应元组类型的值。

你能够使用类型凝视来限制一个元组模式来匹配某种元组类型。比如，在常量申明let (x, y): (Int, Int) = (1, 2)中的元组模式(x, y): (Int, Int)，仅仅匹配两个元素都是Int这样的类型的元组。假设仅须要限制一个元组模式中的某几个元素，仅仅须要直接对这几个元素提供类型凝视就可以。比如，在let
(x: String, y)中的元组模式，仅仅要某个元组类型是包括两个元素，且第一个元素类型是String，则被匹配。

当元组模式被用在for-in语句或者变量或常量申明时，它能够包括通配符模式，标识符模式或者其它包括这两种模式的模式。比如，以下这段代码是不对的，由于(x, 0)中的元素0是一个表达式模式：

let points = [(0, 0), (1, 0), (1, 1), (2, 0), (2, 1)]         // This code isn't valid.         for (x, 0) in points {             /* ... */         } 

对于仅仅包括一个元素的元组，括号是不起作用的。模式匹配那个单个元素的类型。比如，以下是等效的：

let a = 2        // a: Int = 2 let (a) = 2      // a: Int = 2 let (a): Int = 2 // a: Int = 2 

元组模式的语法：

tuple-pattern → (tuple-pattern-element-list opt)

tuple-pattern-element-list → tuple-pattern-element | tuple-pattern-element, tuple-pattern-element-list

tuple-pattern-element → pattern

枚举案例模式（Enumeration Case Pattern）

枚举案例模式匹配现有的枚举类型的某种案例。枚举案例模式仅在switch语句中的case标签中出现。

假设你准备匹配的枚举案例有不论什么关联的值，则对应的枚举案例模式必须指定一个包括每一个关联值元素的元组模式。关于使用switch语句来匹配包括关联值枚举案例的样例，请參阅Associated Values.

枚举案例模式的语法：

enum-case-pattern → type-identifier opt . enum-case-name tuple-pattern opt

类型转换模式（Type-Casting Patterns）

有两种类型转换模式，is模式和as模式。这两种模式均仅仅出如今switch语句中的case标签中。is模式和as模式有下面形式：

is type pattern as type 

is模式匹配一个值，假设这个值的类型在执行时（runtime）和is模式右边的指定类型（或者那个类型的子类）是一致的。is模式和is操作符一样，他们都进行类型转换，可是抛弃了返回的类型。

as模式匹配一个值，假设这个值的类型在执行时（runtime）和as模式右边的指定类型（或者那个类型的子类）是一致的。一旦匹配成功，匹配的值的类型被转换成as模式左边指定的模式。

关于使用switch语句来匹配is模式和as模式值的样例，请參阅Type Casting for Any and AnyObject。

类型转换模式的语法：

type-casting-pattern → is-pattern as-pattern

is-pattern → istype

as-pattern → patternastype

表达式模式（Expression Pattern）

表达式模式代表了一个表达式的值。这个模式仅仅出如今switch语句中的case标签中。

由表达式模式所代表的表达式用Swift标准库中的~=操作符与输入表达式的值进行比較。假设~=操作符返回true，则匹配成功。默认情况下，~=操作符使用==操作符来比較两个同样类型的值。它也能够匹配一个整数值与一个Range对象中的整数范围，正如以下这个样例所看到的：

let point = (1, 2) switch point { case (0, 0):     println("(0, 0) is at the origin.") case (-2...2, -2...2):     println("(\(point.0), \(point.1)) is near the origin.") default:     println("The point is at (\(point.0), \(point.1)).") } // prints "(1, 2) is near the origin.” 

你能够重载~=操作符来提供自己定义的表达式行为。比如，你能够重写上面的样例，以实现用字符串表达的点来比較point表达式。

// Overload the ~= operator to match a string with an integer func ~=(pattern: String, value: Int) -> Bool {     return pattern == "\(value)" } switch point { case ("0", "0"):     println("(0, 0) is at the origin.") case ("-2...2", "-2...2"):     println("(\(point.0), \(point.1)) is near the origin.") default:     println("The point is at (\(point.0), \(point.1)).") } // prints "(1, 2) is near the origin.” 

表达式模式的语法：expression-pattern → expression

​