From e49e55db0080a6a231b8a8531c2290a1bcc4b993 Mon Sep 17 00:00:00 2001 From: ray16897188 Date: Sun, 28 Jun 2015 16:38:24 +0800 Subject: [PATCH 01/14] patterns updated test --- source/chapter3/07_Patterns.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md index 3448a392..49a3ff9b 100755 --- a/source/chapter3/07_Patterns.md +++ b/source/chapter3/07_Patterns.md @@ -16,6 +16,8 @@ 模式（pattern）代表了单个值或者复合值的结构。例如，元组`(1, 2)`的结构是逗号分隔的，包含两个元素的列表。因为模式代表一种值的结构，而不是特定的某个值，你可以把模式和各种同类型的值匹配起来。比如，`(x, y)`可以匹配元组`(1, 2)`，以及任何含两个元素的元组。除了将模式与一个值匹配外，你可以从合成值中提取出部分或全部，然后分别把各个部分和一个常量或变量绑定起来。 +swift中有2种模式的基本类型： + 在Swift中，模式出现在变量和常量的声明（在它们的左侧），`for-in`语句和`switch`语句（在它们的case标签）中。尽管任何模式都可以出现在`switch`语句的case标签中，但在其他情况下，只有通配符模式（wildcard pattern），标识符模式（identifier pattern）和包含这两种模式的模式才能出现。 你可以为通配符模式（wildcard pattern），标识符模式（identifier pattern）和元组模式（tuple pattern）指定类型注释，用来限制这种模式只匹配某种类型的值。 @@ -179,4 +181,4 @@ default: ``` > 表达式模式语法 -> *表达式模式* → [*表达式*](..\chapter3\04_Expressions.html#expression) \ No newline at end of file +> *表达式模式* → [*表达式*](..\chapter3\04_Expressions.html#expression) From 4a35d8c35bc50df741ebe2e03ed7b34c316d31cd Mon Sep 17 00:00:00 2001 From: ray16897188 Date: Sun, 28 Jun 2015 17:19:15 +0800 Subject: [PATCH 02/14] updated 17:18, 6/28/2015 --- source/chapter3/07_Patterns.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md index 49a3ff9b..b9fcb902 100755 --- a/source/chapter3/07_Patterns.md +++ b/source/chapter3/07_Patterns.md @@ -16,7 +16,11 @@ 模式（pattern）代表了单个值或者复合值的结构。例如，元组`(1, 2)`的结构是逗号分隔的，包含两个元素的列表。因为模式代表一种值的结构，而不是特定的某个值，你可以把模式和各种同类型的值匹配起来。比如，`(x, y)`可以匹配元组`(1, 2)`，以及任何含两个元素的元组。除了将模式与一个值匹配外，你可以从合成值中提取出部分或全部，然后分别把各个部分和一个常量或变量绑定起来。 -swift中有2种模式的基本类型： +swift中有2个基本的模式种类：一类能成功和任何值的类型相匹配，另一类在运行时（runtime）和某特定值匹配时可能会失败。 + +第一类模式用于析构简单变量，常量和可选绑定中的值。此类模式包括通配符模式，标识符模式，以及任何包含了它们的值绑定模式或者元祖模式。你可以为这些模式指定一个类型注释（type annotation）来限制它们只能匹配某种特定类型的值。 + +第二类模式用于全模式匹配，这种情况下你用来相比较的值在运行时可能还不存在。此类模式包括枚举用例模式，可选模式，表达式模式和类型转换模式。你在`switch`语句的case标签中，`do`语句的`catch`从句中，或者在`if, while, guard`和`for-in`语句的case条件句中使用这类模式。 在Swift中，模式出现在变量和常量的声明（在它们的左侧），`for-in`语句和`switch`语句（在它们的case标签）中。尽管任何模式都可以出现在`switch`语句的case标签中，但在其他情况下，只有通配符模式（wildcard pattern），标识符模式（identifier pattern）和包含这两种模式的模式才能出现。 From d849ef96b352481439d9a41e8cf1b30ee137553c Mon Sep 17 00:00:00 2001 From: ray16897188 Date: Sun, 28 Jun 2015 21:20:53 +0800 Subject: [PATCH 03/14] patterns_21:20_06/28/2015 --- source/chapter3/07_Patterns.md | 70 ++++++++++++++++++++++++++-------- 1 file changed, 54 insertions(+), 16 deletions(-) diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md index b9fcb902..28e2a23a 100755 --- a/source/chapter3/07_Patterns.md +++ b/source/chapter3/07_Patterns.md @@ -11,6 +11,7 @@ - [值绑定模式（Value-Binding Pattern）](#value-binding_pattern) - [元组模式（Tuple Pattern）](#tuple_pattern) - [枚举用例模式（Enumeration Case Pattern）](#enumeration_case_pattern) +- [可选模式（Optional Patterns）](#optional_patterns) - [类型转换模式（Type-Casting Patterns）](#type-casting_patterns) - [表达式模式（Expression Pattern）](#expression_pattern) @@ -18,20 +19,17 @@ swift中有2个基本的模式种类：一类能成功和任何值的类型相匹配，另一类在运行时（runtime）和某特定值匹配时可能会失败。 -第一类模式用于析构简单变量，常量和可选绑定中的值。此类模式包括通配符模式，标识符模式，以及任何包含了它们的值绑定模式或者元祖模式。你可以为这些模式指定一个类型注释（type annotation）来限制它们只能匹配某种特定类型的值。 +第一类模式用于解构简单变量，常量和可选绑定中的值。此类模式包括通配符模式（wildcard pattern），标识符模式（identifier pattern），以及任何包含了它们的值绑定模式（value binding pattern）或者元祖模式（tuple pattern）。你可以为这类模式指定一个类型注释（type annotation）来限制它们只能匹配某种特定类型的值。 第二类模式用于全模式匹配，这种情况下你用来相比较的值在运行时可能还不存在。此类模式包括枚举用例模式，可选模式，表达式模式和类型转换模式。你在`switch`语句的case标签中，`do`语句的`catch`从句中，或者在`if, while, guard`和`for-in`语句的case条件句中使用这类模式。 -在Swift中，模式出现在变量和常量的声明（在它们的左侧），`for-in`语句和`switch`语句（在它们的case标签）中。尽管任何模式都可以出现在`switch`语句的case标签中，但在其他情况下，只有通配符模式（wildcard pattern），标识符模式（identifier pattern）和包含这两种模式的模式才能出现。 - -你可以为通配符模式（wildcard pattern），标识符模式（identifier pattern）和元组模式（tuple pattern）指定类型注释，用来限制这种模式只匹配某种类型的值。 - > 模式(Patterns) 语法 > *模式* → [*通配符模式*](..\chapter3\07_Patterns.html#wildcard_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotation) _可选_ > *模式* → [*标识符模式*](..\chapter3\07_Patterns.html#identifier_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotati(Value Binding)on) _可选_ > *模式* → [*值绑定模式*](..\chapter3\07_Patterns.html#value_binding_pattern) > *模式* → [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotation) _可选_ > *模式* → [*enum-case-pattern*](..\chapter3\07_Patterns.html#enum_case_pattern) +> *模式* → [*可选模式*](..\chapter3\07_Patterns.html#optional_pattern) [*类型注解*](..\chapter3\03_Types.html#optional_type) _可选_ > *模式* → [*type-casting-pattern*](..\chapter3\07_Patterns.html#type_casting_pattern) > *模式* → [*表达式模式*](..\chapter3\07_Patterns.html#expression_pattern) @@ -42,7 +40,7 @@ swift中有2个基本的模式种类：一类能成功和任何值的类型相 ```swift for _ in 1...3 { - // Do something three times. +// Do something three times. } ``` @@ -75,9 +73,9 @@ let someValue = 42 ```swift let point = (3, 2) switch point { - // Bind x and y to the elements of point. +// Bind x and y to the elements of point. case let (x, y): - println("The point is at (\(x), \(y)).") +println("The point is at (\(x), \(y)).") } // prints "The point is at (3, 2).” ``` @@ -100,7 +98,7 @@ case let (x, y): let points = [(0, 0), (1, 0), (1, 1), (2, 0), (2, 1)] // This code isn't valid. for (x, 0) in points { - /* ... */ +/* ... */ } ``` @@ -127,6 +125,46 @@ let (a): Int = 2 // a: Int = 2 > 枚举用例模式语法 > *enum-case-pattern* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) _可选_ **.** [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) _可选_ + + + +## 可选模式（Optional Pattern） + +可选模式 封装在一个`Some(T)` + +可选模式由一个标识符模式和紧随其后的一个问号组成，在某种情况下表现为枚举用例模式。 + +由于可选模式是`optionan`和`ImplicitlyUnwrappedOptional`枚举用例模式的语法糖，下面的两种写法一样的： + +```swift +let someOptional: Int? = 42 +// Match using an enumeration case pattern +if case .Some(let x) = someOptional { + print(x) +} + +// Match using an optional pattern +if case let x? = someOptional { + print(x) +} +``` + +可选模式在`for-in`语句提供了在一个元素是可选类型的数组中迭代的简便的方式，只为数组中的非空元素执行循环。 + +```swift +let arrayOfOptionalInts: [Int?] = [nil, 2, 3, nil, 5] +// Match only non-nil values +for case let number? in arrayOfOptinalInts { + print("Found a \(number)") +} +//Found a 2 +//Found a 3 +//Found a 5 + +``` +> 可选模式语法 +> *optional-pattern* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) ? + ## 类型转换模式（Type-Casting Patterns） @@ -157,11 +195,11 @@ let (a): Int = 2 // a: Int = 2 let point = (1, 2) switch point { case (0, 0): - println("(0, 0) is at the origin.") +println("(0, 0) is at the origin.") case (-2...2, -2...2): - println("(\(point.0), \(point.1)) is near the origin.") +println("(\(point.0), \(point.1)) is near the origin.") default: - println("The point is at (\(point.0), \(point.1)).") +println("The point is at (\(point.0), \(point.1)).") } // prints "(1, 2) is near the origin.” ``` @@ -171,15 +209,15 @@ default: ```swift // Overload the ~= operator to match a string with an integer func ~=(pattern: String, value: Int) -> Bool { - return pattern == "\(value)" +return pattern == "\(value)" } switch point { case ("0", "0"): - println("(0, 0) is at the origin.") +println("(0, 0) is at the origin.") case ("-2...2", "-2...2"): - println("(\(point.0), \(point.1)) is near the origin.") +println("(\(point.0), \(point.1)) is near the origin.") default: - println("The point is at (\(point.0), \(point.1)).") +println("The point is at (\(point.0), \(point.1)).") } // prints "(1, 2) is near the origin.” ``` From ca44d06f29216c2bb9027a64cafb1f6c9d2939fa Mon Sep 17 00:00:00 2001 From: ray16897188 Date: Mon, 29 Jun 2015 12:57:36 +0800 Subject: [PATCH 04/14] patterns_12:57_06/29/2015_Preliminary --- source/chapter3/07_Patterns.md | 38 +++++++++++++++------------------- 1 file changed, 17 insertions(+), 21 deletions(-) diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md index 28e2a23a..0795f26f 100755 --- a/source/chapter3/07_Patterns.md +++ b/source/chapter3/07_Patterns.md @@ -11,15 +11,15 @@ - [值绑定模式（Value-Binding Pattern）](#value-binding_pattern) - [元组模式（Tuple Pattern）](#tuple_pattern) - [枚举用例模式（Enumeration Case Pattern）](#enumeration_case_pattern) -- [可选模式（Optional Patterns）](#optional_patterns) -- [类型转换模式（Type-Casting Patterns）](#type-casting_patterns) +- [可选模式（Optional Patterns）](#optional_pattern) +- [类型转换模式（Type-Casting Patterns）](#type-casting_pattern) - [表达式模式（Expression Pattern）](#expression_pattern) -模式（pattern）代表了单个值或者复合值的结构。例如，元组`(1, 2)`的结构是逗号分隔的，包含两个元素的列表。因为模式代表一种值的结构，而不是特定的某个值，你可以把模式和各种同类型的值匹配起来。比如，`(x, y)`可以匹配元组`(1, 2)`，以及任何含两个元素的元组。除了将模式与一个值匹配外，你可以从合成值中提取出部分或全部，然后分别把各个部分和一个常量或变量绑定起来。 +模式（pattern）代表了单个值或者复合值的结构。例如，元组`(1, 2)`的结构是逗号分隔的，包含两个元素的列表。因为模式代表一种值的结构，而不是特定的某个值，你可以把模式和各种同类型的值匹配起来。比如，`(x, y)`可以匹配元组`(1, 2)`，以及任何含两个元素的元组。除了将模式与一个值匹配外，你可以从复合值中提取出部分或全部，然后分别把各个部分和一个常量或变量绑定起来。 -swift中有2个基本的模式种类：一类能成功和任何值的类型相匹配，另一类在运行时（runtime）和某特定值匹配时可能会失败。 +swift语言中模式有2个基本的分类：一类能成功和任何值的类型相匹配，另一类在运行时（runtime）和某特定值匹配时可能会失败。 -第一类模式用于解构简单变量，常量和可选绑定中的值。此类模式包括通配符模式（wildcard pattern），标识符模式（identifier pattern），以及任何包含了它们的值绑定模式（value binding pattern）或者元祖模式（tuple pattern）。你可以为这类模式指定一个类型注释（type annotation）来限制它们只能匹配某种特定类型的值。 +第一类模式用于解构简单变量，常量和可选绑定中的值。此类模式包括通配符模式（wildcard pattern），标识符模式（identifier pattern），以及任何包含了它们的值绑定模式（value binding pattern）或者元祖模式（tuple pattern）。你可以为这类模式指定一个类型注释（type annotation）从而限制它们只能匹配某种特定类型的值。 第二类模式用于全模式匹配，这种情况下你用来相比较的值在运行时可能还不存在。此类模式包括枚举用例模式，可选模式，表达式模式和类型转换模式。你在`switch`语句的case标签中，`do`语句的`catch`从句中，或者在`if, while, guard`和`for-in`语句的case条件句中使用这类模式。 @@ -28,9 +28,9 @@ swift中有2个基本的模式种类：一类能成功和任何值的类型相 > *模式* → [*标识符模式*](..\chapter3\07_Patterns.html#identifier_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotati(Value Binding)on) _可选_ > *模式* → [*值绑定模式*](..\chapter3\07_Patterns.html#value_binding_pattern) > *模式* → [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotation) _可选_ -> *模式* → [*enum-case-pattern*](..\chapter3\07_Patterns.html#enum_case_pattern) +> *模式* → [*枚举用例模式*](..\chapter3\07_Patterns.html#enum_case_pattern) > *模式* → [*可选模式*](..\chapter3\07_Patterns.html#optional_pattern) [*类型注解*](..\chapter3\03_Types.html#optional_type) _可选_ -> *模式* → [*type-casting-pattern*](..\chapter3\07_Patterns.html#type_casting_pattern) +> *模式* → [*类型转换模式*](..\chapter3\07_Patterns.html#type_casting_pattern) > *模式* → [*表达式模式*](..\chapter3\07_Patterns.html#expression_pattern) @@ -75,7 +75,7 @@ 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)).") +print("The point is at (\(x), \(y)).") } // prints "The point is at (3, 2).” ``` @@ -125,16 +125,12 @@ let (a): Int = 2 // a: Int = 2 > 枚举用例模式语法 > *enum-case-pattern* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) _可选_ **.** [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) _可选_ - - ## 可选模式（Optional Pattern） -可选模式 封装在一个`Some(T)` +可选模式与封装在一个`Optional(T)`或者一个`ExplicitlyUnwrappedOptional(T)`枚举中的`Some(T)`成员值相匹配。可选模式由一个标识符模式和紧随其后的一个问号组成，在某些情况下表现为枚举用例模式。 -可选模式由一个标识符模式和紧随其后的一个问号组成，在某种情况下表现为枚举用例模式。 - -由于可选模式是`optionan`和`ImplicitlyUnwrappedOptional`枚举用例模式的语法糖，下面的两种写法一样的： +由于可选模式是`optional`和`ImplicitlyUnwrappedOptional`枚举用例模式的语法糖（syntactic sugar），下面的两种写法一样的： ```swift let someOptional: Int? = 42 @@ -149,7 +145,7 @@ if case let x? = someOptional { } ``` -可选模式在`for-in`语句提供了在一个元素是可选类型的数组中迭代的简便的方式，只为数组中的非空元素执行循环。 +可选模式在`for-in`语句提供了在一个元素是可选类型的数组中迭代的简便方式，只为数组中的非空`non-nil`元素执行循环。 ```swift let arrayOfOptionalInts: [Int?] = [nil, 2, 3, nil, 5] @@ -195,11 +191,11 @@ for case let number? in arrayOfOptinalInts { let point = (1, 2) switch point { case (0, 0): -println("(0, 0) is at the origin.") +print("(0, 0) is at the origin.") case (-2...2, -2...2): -println("(\(point.0), \(point.1)) is near the origin.") +print("(\(point.0), \(point.1)) is near the origin.") default: -println("The point is at (\(point.0), \(point.1)).") +print("The point is at (\(point.0), \(point.1)).") } // prints "(1, 2) is near the origin.” ``` @@ -213,11 +209,11 @@ return pattern == "\(value)" } switch point { case ("0", "0"): -println("(0, 0) is at the origin.") +print("(0, 0) is at the origin.") case ("-2...2", "-2...2"): -println("(\(point.0), \(point.1)) is near the origin.") +print("(\(point.0), \(point.1)) is near the origin.") default: -println("The point is at (\(point.0), \(point.1)).") +print("The point is at (\(point.0), \(point.1)).") } // prints "(1, 2) is near the origin.” ``` From 8f6eb4e2f6df46c44fdb69e7fe35716c395b5359 Mon Sep 17 00:00:00 2001 From: ray16897188 Date: Mon, 29 Jun 2015 13:05:40 +0800 Subject: [PATCH 05/14] patterns_13:05_06/29/2015_Preliminary --- source/chapter3/07_Patterns.md | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md index 0795f26f..0b4f0bf5 100755 --- a/source/chapter3/07_Patterns.md +++ b/source/chapter3/07_Patterns.md @@ -1,4 +1,4 @@ -> 翻译：[honghaoz](https://github.com/honghaoz) +> 翻译：[honghaoz](https://github.com/honghaoz), [ray16897188](https://github.com/ray16897188) > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai) # 模式（Patterns） @@ -144,8 +144,7 @@ if case let x? = someOptional { print(x) } ``` - -可选模式在`for-in`语句提供了在一个元素是可选类型的数组中迭代的简便方式，只为数组中的非空`non-nil`元素执行循环。 +如果一个数组的元素是可选类型，可选模式为`for-in`语句提供了在该数组中迭代的简便方式，只为数组中的非空`non-nil`元素执行循环。 ```swift let arrayOfOptionalInts: [Int?] = [nil, 2, 3, nil, 5] From 84a31ca36b8a3679346d8f28a50078e6c24798b8 Mon Sep 17 00:00:00 2001 From: ray16897188 Date: Mon, 29 Jun 2015 13:21:25 +0800 Subject: [PATCH 06/14] patterns_13:21_06/29/2015_Preliminary --- source/chapter3/07_Patterns.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md index 0b4f0bf5..4e9e8660 100755 --- a/source/chapter3/07_Patterns.md +++ b/source/chapter3/07_Patterns.md @@ -158,7 +158,7 @@ for case let number? in arrayOfOptinalInts { ``` > 可选模式语法 -> *optional-pattern* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) ? +> *可选模式* → [*标识符模式*](..\chapter3\03_Types.html#type_identifier) ? ## 类型转换模式（Type-Casting Patterns） From 74cff1433f7989959cc8b1421ac8fb26812d77a4 Mon Sep 17 00:00:00 2001 From: ray16897188 Date: Mon, 29 Jun 2015 19:38:02 +0800 Subject: [PATCH 07/14] patterns_19:37_06/29/2015 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 修改了print函数的缩进格式 --- source/chapter3/07_Patterns.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md index 4e9e8660..6fd48bf8 100755 --- a/source/chapter3/07_Patterns.md +++ b/source/chapter3/07_Patterns.md @@ -75,7 +75,7 @@ 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)).") + print("The point is at (\(x), \(y)).") } // prints "The point is at (3, 2).” ``` @@ -190,11 +190,11 @@ for case let number? in arrayOfOptinalInts { let point = (1, 2) switch point { case (0, 0): -print("(0, 0) is at the origin.") + print("(0, 0) is at the origin.") case (-2...2, -2...2): -print("(\(point.0), \(point.1)) is near the origin.") + print("(\(point.0), \(point.1)) is near the origin.") default: -print("The point is at (\(point.0), \(point.1)).") + print("The point is at (\(point.0), \(point.1)).") } // prints "(1, 2) is near the origin.” ``` @@ -208,11 +208,11 @@ return pattern == "\(value)" } switch point { case ("0", "0"): -print("(0, 0) is at the origin.") + print("(0, 0) is at the origin.") case ("-2...2", "-2...2"): -print("(\(point.0), \(point.1)) is near the origin.") + print("(\(point.0), \(point.1)) is near the origin.") default: -print("The point is at (\(point.0), \(point.1)).") + print("The point is at (\(point.0), \(point.1)).") } // prints "(1, 2) is near the origin.” ``` From c34a6381a44cf131db0ab9fb0cdd212a9cf25908 Mon Sep 17 00:00:00 2001 From: ray16897188 Date: Mon, 29 Jun 2015 22:52:22 +0800 Subject: [PATCH 08/14] patterns_22:52_06/29/2015_Preliminary --- source/chapter3/07_Patterns.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md index 6fd48bf8..54cf38d5 100755 --- a/source/chapter3/07_Patterns.md +++ b/source/chapter3/07_Patterns.md @@ -73,7 +73,7 @@ let someValue = 42 ```swift let point = (3, 2) switch point { -// Bind x and y to the elements of point. + // Bind x and y to the elements of point. case let (x, y): print("The point is at (\(x), \(y)).") } @@ -92,7 +92,7 @@ case let (x, y): 你可以使用类型注释来限制一个元组模式来匹配某种元组类型。例如，在常量申明`let (x, y): (Int, Int) = (1, 2)`中的元组模式`(x, y): (Int, Int)`，只匹配两个元素都是`Int`这种类型的元组。如果仅需要限制一个元组模式中的某几个元素，只需要直接对这几个元素提供类型注释即可。例如，在`let (x: String, y)`中的元组模式，只要某个元组类型是包含两个元素，且第一个元素类型是`String`，则被匹配。 -当元组模式被用在`for-in`语句或者变量或常量申明时，它可以包含通配符模式，标识符模式或者其他包含这两种模式的模式。例如，下面这段代码是不正确的，因为`(x, 0)`中的元素`0`是一个表达式模式： +当元组模式被用在`for-in`语句或者变量或常量申明时，它可以包含通配符模式，标识符模式，可选模式或者其他包含这些模式的元祖模式。例如，下面这段代码是不正确的，因为`(x, 0)`中的元素`0`是一个表达式模式： ```swift let points = [(0, 0), (1, 0), (1, 1), (2, 0), (2, 1)] @@ -204,7 +204,7 @@ default: ```swift // Overload the ~= operator to match a string with an integer func ~=(pattern: String, value: Int) -> Bool { -return pattern == "\(value)" + return pattern == "\(value)" } switch point { case ("0", "0"): From 50aa657d1b754a9d3690a24a1920509a344590ae Mon Sep 17 00:00:00 2001 From: ray16897188 Date: Mon, 29 Jun 2015 22:54:16 +0800 Subject: [PATCH 09/14] patterns_22:54_06/29/2015_Preliminary --- source/chapter3/07_Patterns.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md index 54cf38d5..c639a508 100755 --- a/source/chapter3/07_Patterns.md +++ b/source/chapter3/07_Patterns.md @@ -98,7 +98,7 @@ case let (x, y): let points = [(0, 0), (1, 0), (1, 1), (2, 0), (2, 1)] // This code isn't valid. for (x, 0) in points { -/* ... */ + /* ... */ } ``` From 989e827affcb5191750ac530c50cf7c5084b9d11 Mon Sep 17 00:00:00 2001 From: ray16897188 Date: Mon, 29 Jun 2015 23:00:18 +0800 Subject: [PATCH 10/14] patterns_23:00_06/29/2015_Preliminary --- source/chapter3/07_Patterns.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md index c639a508..06c6f3dd 100755 --- a/source/chapter3/07_Patterns.md +++ b/source/chapter3/07_Patterns.md @@ -19,7 +19,7 @@ swift语言中模式有2个基本的分类：一类能成功和任何值的类型相匹配，另一类在运行时（runtime）和某特定值匹配时可能会失败。 -第一类模式用于解构简单变量，常量和可选绑定中的值。此类模式包括通配符模式（wildcard pattern），标识符模式（identifier pattern），以及任何包含了它们的值绑定模式（value binding pattern）或者元祖模式（tuple pattern）。你可以为这类模式指定一个类型注释（type annotation）从而限制它们只能匹配某种特定类型的值。 +第一类模式用于解构简单变量，常量和可选绑定中的值。此类模式包括通配符模式（wildcard patterns），标识符模式（identifier patterns），以及任何包含了它们的值绑定模式（value binding patterns）或者元祖模式（tuple patterns）。你可以为这类模式指定一个类型注释（type annotation）从而限制它们只能匹配某种特定类型的值。 第二类模式用于全模式匹配，这种情况下你用来相比较的值在运行时可能还不存在。此类模式包括枚举用例模式，可选模式，表达式模式和类型转换模式。你在`switch`语句的case标签中，`do`语句的`catch`从句中，或者在`if, while, guard`和`for-in`语句的case条件句中使用这类模式。 From 47fee2b7d510ae38c827f884f9b875e97349c630 Mon Sep 17 00:00:00 2001 From: ray16897188 Date: Mon, 29 Jun 2015 23:29:12 +0800 Subject: [PATCH 11/14] patterns_23:29_06/29/2015_Preliminary --- source/chapter3/07_Patterns.md | 24 +++++++++++------------- 1 file changed, 11 insertions(+), 13 deletions(-) diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md index 06c6f3dd..9ee36996 100755 --- a/source/chapter3/07_Patterns.md +++ b/source/chapter3/07_Patterns.md @@ -11,25 +11,25 @@ - [值绑定模式（Value-Binding Pattern）](#value-binding_pattern) - [元组模式（Tuple Pattern）](#tuple_pattern) - [枚举用例模式（Enumeration Case Pattern）](#enumeration_case_pattern) -- [可选模式（Optional Patterns）](#optional_pattern) -- [类型转换模式（Type-Casting Patterns）](#type-casting_pattern) +- [可选模式（Optional Pattern）](#optional_pattern) +- [类型转换模式（Type-Casting Pattern）](#type-casting_pattern) - [表达式模式（Expression Pattern）](#expression_pattern) 模式（pattern）代表了单个值或者复合值的结构。例如，元组`(1, 2)`的结构是逗号分隔的，包含两个元素的列表。因为模式代表一种值的结构，而不是特定的某个值，你可以把模式和各种同类型的值匹配起来。比如，`(x, y)`可以匹配元组`(1, 2)`，以及任何含两个元素的元组。除了将模式与一个值匹配外，你可以从复合值中提取出部分或全部，然后分别把各个部分和一个常量或变量绑定起来。 swift语言中模式有2个基本的分类：一类能成功和任何值的类型相匹配，另一类在运行时（runtime）和某特定值匹配时可能会失败。 -第一类模式用于解构简单变量，常量和可选绑定中的值。此类模式包括通配符模式（wildcard patterns），标识符模式（identifier patterns），以及任何包含了它们的值绑定模式（value binding patterns）或者元祖模式（tuple patterns）。你可以为这类模式指定一个类型注释（type annotation）从而限制它们只能匹配某种特定类型的值。 +第一类模式用于解构简单变量，常量和可选绑定中的值。此类模式包括通配符模式（wildcard patterns），标识符模式（identifier patterns），以及任何包含了它们的值绑定模式（value binding patterns）或者元祖模式（tuple patterns）。你可以为这类模式指定一个类型标注（type annotation）从而限制它们只能匹配某种特定类型的值。 -第二类模式用于全模式匹配，这种情况下你用来相比较的值在运行时可能还不存在。此类模式包括枚举用例模式，可选模式，表达式模式和类型转换模式。你在`switch`语句的case标签中，`do`语句的`catch`从句中，或者在`if, while, guard`和`for-in`语句的case条件句中使用这类模式。 +第二类模式用于全模式匹配，这种情况下你用来相比较的值在运行时可能还不存在。此类模式包括枚举用例模式（enumeration case patterns），可选模式（optional patterns），表达式模式（expression patterns）和类型转换模式（type-casting patterns）。你在`switch`语句的case标签中，`do`语句的`catch`从句中，或者在`if, while, guard`和`for-in`语句的case条件句中使用这类模式。 > 模式(Patterns) 语法 -> *模式* → [*通配符模式*](..\chapter3\07_Patterns.html#wildcard_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotation) _可选_ -> *模式* → [*标识符模式*](..\chapter3\07_Patterns.html#identifier_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotati(Value Binding)on) _可选_ +> *模式* → [*通配符模式*](..\chapter3\07_Patterns.html#wildcard_pattern) [*类型标注*](..\chapter3\03_Types.html#type_annotation) _可选_ +> *模式* → [*标识符模式*](..\chapter3\07_Patterns.html#identifier_pattern) [*类型标注*](..\chapter3\03_Types.html#type_annotati(Value Binding)on) _可选_ > *模式* → [*值绑定模式*](..\chapter3\07_Patterns.html#value_binding_pattern) -> *模式* → [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotation) _可选_ +> *模式* → [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) [*类型标注*](..\chapter3\03_Types.html#type_annotation) _可选_ > *模式* → [*枚举用例模式*](..\chapter3\07_Patterns.html#enum_case_pattern) -> *模式* → [*可选模式*](..\chapter3\07_Patterns.html#optional_pattern) [*类型注解*](..\chapter3\03_Types.html#optional_type) _可选_ +> *模式* → [*可选模式*](..\chapter3\07_Patterns.html#optional_pattern) > *模式* → [*类型转换模式*](..\chapter3\07_Patterns.html#type_casting_pattern) > *模式* → [*表达式模式*](..\chapter3\07_Patterns.html#expression_pattern) @@ -40,7 +40,7 @@ swift语言中模式有2个基本的分类：一类能成功和任何值的类 ```swift for _ in 1...3 { -// Do something three times. + // Do something three times. } ``` @@ -90,7 +90,7 @@ case let (x, y): 元组模式是逗号分隔的列表，包含一个或多个模式，并包含在一对圆括号中。元组模式匹配相应元组类型的值。 -你可以使用类型注释来限制一个元组模式来匹配某种元组类型。例如，在常量申明`let (x, y): (Int, Int) = (1, 2)`中的元组模式`(x, y): (Int, Int)`，只匹配两个元素都是`Int`这种类型的元组。如果仅需要限制一个元组模式中的某几个元素，只需要直接对这几个元素提供类型注释即可。例如，在`let (x: String, y)`中的元组模式，只要某个元组类型是包含两个元素，且第一个元素类型是`String`，则被匹配。 +你可以使用类型标注来限制一个元组模式来匹配某种元组类型。例如，在常量申明`let (x, y): (Int, Int) = (1, 2)`中的元组模式`(x, y): (Int, Int)`，只匹配两个元素都是`Int`这种类型的元组。如果仅需要限制一个元组模式中的某几个元素，只需要直接对这几个元素提供类型标注即可。例如，在`let (x: String, y)`中的元组模式，只要某个元组类型是包含两个元素，且第一个元素类型是`String`，则被匹配。 当元组模式被用在`for-in`语句或者变量或常量申明时，它可以包含通配符模式，标识符模式，可选模式或者其他包含这些模式的元祖模式。例如，下面这段代码是不正确的，因为`(x, 0)`中的元素`0`是一个表达式模式： @@ -199,7 +199,7 @@ default: // prints "(1, 2) is near the origin.” ``` -你可以重载`~=`操作符来提供自定义的表达式行为。例如，你可以重写上面的例子，以实现用字符串表达的点来比较`point`表达式。 +你可以重载`~=`操作符来提供自定义的表达式匹配行为。比如你可以重写上面的例子，拿`point`表达式去比较字符串形式的点。 ```swift // Overload the ~= operator to match a string with an integer @@ -209,8 +209,6 @@ func ~=(pattern: String, value: Int) -> Bool { switch point { case ("0", "0"): print("(0, 0) is at the origin.") -case ("-2...2", "-2...2"): - print("(\(point.0), \(point.1)) is near the origin.") default: print("The point is at (\(point.0), \(point.1)).") } From 84cae57c8b0870c99e8f9763e3ce9ca4a6f52346 Mon Sep 17 00:00:00 2001 From: ray16897188 Date: Mon, 29 Jun 2015 23:33:12 +0800 Subject: [PATCH 12/14] patterns_23:33_06/29/2015_Preliminary --- source/chapter3/07_Patterns.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md index 9ee36996..d7c3313d 100755 --- a/source/chapter3/07_Patterns.md +++ b/source/chapter3/07_Patterns.md @@ -29,7 +29,7 @@ swift语言中模式有2个基本的分类：一类能成功和任何值的类 > *模式* → [*值绑定模式*](..\chapter3\07_Patterns.html#value_binding_pattern) > *模式* → [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) [*类型标注*](..\chapter3\03_Types.html#type_annotation) _可选_ > *模式* → [*枚举用例模式*](..\chapter3\07_Patterns.html#enum_case_pattern) -> *模式* → [*可选模式*](..\chapter3\07_Patterns.html#optional_pattern) +> *模式* → [*可选模式*](..\chapter3\07_Patterns.html#optional_pattern) > *模式* → [*类型转换模式*](..\chapter3\07_Patterns.html#type_casting_pattern) > *模式* → [*表达式模式*](..\chapter3\07_Patterns.html#expression_pattern) From 4f4622ea41afe0b477950ac5f4f1837d93a921e6 Mon Sep 17 00:00:00 2001 From: ray16897188 Date: Tue, 30 Jun 2015 01:43:13 +0800 Subject: [PATCH 13/14] patterns_01:42_06/30/2015_Preliminary --- source/chapter3/07_Patterns.md | 38 +++++++++++++++++----------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md index d7c3313d..f56513a8 100755 --- a/source/chapter3/07_Patterns.md +++ b/source/chapter3/07_Patterns.md @@ -36,7 +36,7 @@ swift语言中模式有2个基本的分类：一类能成功和任何值的类 ## 通配符模式（Wildcard Pattern） -通配符模式匹配并忽略任何值，包含一个下划线（_）。当你不关心被匹配的值时，可以使用此模式。例如，下面这段代码进行了`1...3`的循环，并忽略了每次循环的值： +通配符模式由一个下划线（_）构成，且匹配并忽略任何值。当你不在乎被匹配的值时可以使用该模式。例如，下面这段代码在闭区间`1...3`中循环，每次循环时忽略该区间内的当前值： ```swift for _ in 1...3 { @@ -50,7 +50,7 @@ for _ in 1...3 { ## 标识符模式（Identifier Pattern） -标识符模式匹配任何值，并将匹配的值和一个变量或常量绑定起来。例如，在下面的常量申明中，`someValue`是一个标识符模式，匹配了类型是`Int`的`42`。 +标识符模式匹配任何值，并将匹配的值和一个变量或常量绑定起来。例如，在下面的常量声明中，`someValue`是一个标识符模式，匹配了类型是`Int`的`42`。 ```swift let someValue = 42 @@ -58,7 +58,7 @@ let someValue = 42 当匹配成功时，`42`被绑定（赋值）给常量`someValue`。 -当一个变量或常量申明的左边是标识符模式时，此时，标识符模式是隐式的值绑定模式（value-binding pattern）。 +如果一个变量或常量声明的左边的模式是一个标识符模式，那么这个标识符模式是一个隐式的值绑定模式（value-binding pattern）。 > 标识符模式语法 > *标识符模式* → [*标识符*](LexicalStructure.html#identifier) @@ -66,9 +66,9 @@ let someValue = 42 ## 值绑定模式（Value-Binding Pattern） -值绑定模式绑定匹配的值到一个变量或常量。当绑定匹配值给常量时，用关键字`let`,绑定给变量时，用关键字`var`。 +值绑定模式把匹配到的值绑定给一个变量或常量名。把绑定匹配到的值绑定给常量时，用关键字`let`,绑定给变量时，用关键字`var`。 -标识符模式包含在值绑定模式中，绑定新的变量或常量到匹配的值。例如，你可以分解一个元组的元素，并把每个元素绑定到相应的标识符模式中。 +在值绑定模式中的标识符模式会把新命名的变量或常量与匹配值做绑定。例如，你可以拆开一个元组的元素，然后把每个元素绑定到其相应一个的标识符模式中。 ```swift let point = (3, 2) @@ -80,7 +80,7 @@ case let (x, y): // prints "The point is at (3, 2).” ``` -在上面这个例子中，`let`将元组模式`(x, y)`分配到各个标识符模式。因为这种行为，`switch`语句中`case let (x, y):`和`case (let x, let y):`匹配的值是一样的。 +在上面这个例子中，`let`将元组模式`(x, y)`分配到各个标识符模式。正是由于这么做，`switch`语句中`case let (x, y):`和`case (let x, let y):`匹配到的值是一样的。 > 值绑定(Value Binding)模式语法 > *值绑定模式* → **var** [*模式*](..\chapter3\07_Patterns.html#pattern) | **let** [*模式*](..\chapter3\07_Patterns.html#pattern) @@ -88,11 +88,11 @@ case let (x, y): ## 元组模式（Tuple Pattern） -元组模式是逗号分隔的列表，包含一个或多个模式，并包含在一对圆括号中。元组模式匹配相应元组类型的值。 +元组模式是逗号分隔的，有零个或多个模式的列表，并被一对圆括号括起来。元组模式匹配相应元组类型的值。 -你可以使用类型标注来限制一个元组模式来匹配某种元组类型。例如，在常量申明`let (x, y): (Int, Int) = (1, 2)`中的元组模式`(x, y): (Int, Int)`，只匹配两个元素都是`Int`这种类型的元组。如果仅需要限制一个元组模式中的某几个元素，只需要直接对这几个元素提供类型标注即可。例如，在`let (x: String, y)`中的元组模式，只要某个元组类型是包含两个元素，且第一个元素类型是`String`，则被匹配。 +你可以使用类型标注来限制一个元组模式来匹配某些种元组类型。例如，在常量声明`let (x, y): (Int, Int) = (1, 2)`中的元组模式`(x, y): (Int, Int)`只匹配两个元素都是`Int`这种类型的元组。如果仅需要限制一个元组模式中的某几个元素，只需要直接对这几个元素提供类型标注即可。例如，在`let (x: String, y)`中的元组模式可以和任何有两个元素，且第一个元素类型是`String`的元组类型匹配。 -当元组模式被用在`for-in`语句或者变量或常量申明时，它可以包含通配符模式，标识符模式，可选模式或者其他包含这些模式的元祖模式。例如，下面这段代码是不正确的，因为`(x, 0)`中的元素`0`是一个表达式模式： +当元组模式被用在`for-in`语句或者变量或常量声明时，它仅可以包含通配符模式，标识符模式，可选模式或者其他包含这些模式的元祖模式。比如下面这段代码就不正确，因为`(x, 0)`中的元素`0`是一个表达式模式： ```swift let points = [(0, 0), (1, 0), (1, 1), (2, 0), (2, 1)] @@ -102,7 +102,7 @@ for (x, 0) in points { } ``` -对于只包含一个元素的元组，括号是不起作用的。模式匹配那个单个元素的类型。例如，下面是等效的： +对于只包含一个元素的元组，括号是不起作用的。模式只匹配这个单个元素的类型。举例来说，下面3条语句是等效的： ```swift let a = 2 // a: Int = 2 @@ -118,7 +118,7 @@ let (a): Int = 2 // a: Int = 2 ## 枚举用例模式（Enumeration Case Pattern） -枚举用例模式匹配现有的枚举类型的某种用例。枚举用例模式仅在`switch`语句中的`case`标签中出现。 +一个枚举用例模式匹配现有的某个枚举类型的某个用例（case）。枚举用例模式出现在`switch`语句中的case标签中，以及`if`，`while`，`guard`和`for-in`语句的case条件中。 如果你准备匹配的枚举用例有任何关联的值，则相应的枚举用例模式必须指定一个包含每个关联值元素的元组模式。关于使用`switch`语句来匹配包含关联值枚举用例的例子，请参阅`Associated Values`. @@ -128,9 +128,9 @@ let (a): Int = 2 // a: Int = 2 ## 可选模式（Optional Pattern） -可选模式与封装在一个`Optional(T)`或者一个`ExplicitlyUnwrappedOptional(T)`枚举中的`Some(T)`成员值相匹配。可选模式由一个标识符模式和紧随其后的一个问号组成，在某些情况下表现为枚举用例模式。 +可选模式与封装在一个`Optional(T)`或者一个`ExplicitlyUnwrappedOptional(T)`枚举中的`Some(T)`用例相匹配。可选模式由一个标识符模式和紧随其后的一个问号组成，在某些情况下表现为枚举用例模式。 -由于可选模式是`optional`和`ImplicitlyUnwrappedOptional`枚举用例模式的语法糖（syntactic sugar），下面的两种写法一样的： +由于可选模式是`optional`和`ImplicitlyUnwrappedOptional`枚举用例模式的语法糖（syntactic sugar），下面的2种写法是一样的： ```swift let someOptional: Int? = 42 @@ -144,7 +144,7 @@ if case let x? = someOptional { print(x) } ``` -如果一个数组的元素是可选类型，可选模式为`for-in`语句提供了在该数组中迭代的简便方式，只为数组中的非空`non-nil`元素执行循环。 +如果一个数组的元素是可选类型，可选模式为`for-in`语句提供了一种在该数组中迭代的简便方式，只为数组中的非空`non-nil`元素执行循环体。 ```swift let arrayOfOptionalInts: [Int?] = [nil, 2, 3, nil, 5] @@ -163,14 +163,14 @@ for case let number? in arrayOfOptinalInts { ## 类型转换模式（Type-Casting Patterns） -有两种类型转换模式，`is`模式和`as`模式。这两种模式均只出现在`switch`语句中的`case`标签中。`is`模式和`as`模式有以下形式： +有两种类型转换模式，`is`模式和`as`模式。这两种模式只出现在`switch`语句中的case标签中。`is`模式和`as`模式有以下形式： > is `type` > `pattern` as `type` -`is`模式匹配一个值，如果这个值的类型在运行时（runtime）和`is`模式右边的指定类型（或者那个类型的子类）是一致的。`is`模式和`is`操作符一样，它们都进行类型转换，但是抛弃了返回的类型。 +`is`模式仅当一个值的类型在运行时（runtime）和`is`模式右边的指定类型一致 - 或者是该类型的子类 - 的情况下，才会匹配这个值。`is`模式和`is`操作符有相似表现，它们都进行类型转换，却舍弃返回的类型。 -`as`模式匹配一个值，如果这个值的类型在运行时（runtime）和`as`模式右边的指定类型（或者那个类型的子类）是一致的。一旦匹配成功，匹配的值的类型被转换成`as`模式左边指定的模式。 +`as`模式仅当一个值的类型在运行时（runtime）和`as`模式右边的指定类型一致 - 或者是该类型的子类 - 的情况下，才会匹配这个值。如果匹配成功，被匹配的值的类型被转换成`as`模式左边指定的模式。 关于使用`switch`语句来匹配`is`模式和`as`模式值的例子，请参阅`Type Casting for Any and AnyObject`。 @@ -182,9 +182,9 @@ for case let number? in arrayOfOptinalInts { ## 表达式模式（Expression Pattern） -表达式模式代表了一个表达式的值。这个模式只出现在`switch`语句中的`case`标签中。 +一个表达式模式代表了一个表达式的值。表达式模式只出现在`switch`语句中的`case`标签中。 -由表达式模式所代表的表达式用Swift标准库中的`~=`操作符与输入表达式的值进行比较。如果`~=`操作符返回`true`，则匹配成功。默认情况下，`~=`操作符使用`==`操作符来比较两个相同类型的值。它也可以匹配一个整数值与一个`Range`对象中的整数范围，正如下面这个例子所示： +由表达式模式所代表的表达式与使用了Swift标准库中`~=`操作符的输入表达式的值进行比较。如果`~=`操作符返回`true`，则匹配成功。默认情况下，`~=`操作符使用`==`操作符来比较两个相同类型的值。它也可以将一个整型数值与一个`Range`对象中的一段整数区间做匹配，正如下面这个例子所示： ```swift let point = (1, 2) From 93186d21113d21e6a1d89410c96e02d61e8e7633 Mon Sep 17 00:00:00 2001 From: ray16897188 Date: Tue, 30 Jun 2015 01:46:46 +0800 Subject: [PATCH 14/14] patterns_01:46_06/30/2015_Preliminary --- source/chapter3/07_Patterns.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md index f56513a8..fb93956d 100755 --- a/source/chapter3/07_Patterns.md +++ b/source/chapter3/07_Patterns.md @@ -90,7 +90,7 @@ case let (x, y): 元组模式是逗号分隔的，有零个或多个模式的列表，并被一对圆括号括起来。元组模式匹配相应元组类型的值。 -你可以使用类型标注来限制一个元组模式来匹配某些种元组类型。例如，在常量声明`let (x, y): (Int, Int) = (1, 2)`中的元组模式`(x, y): (Int, Int)`只匹配两个元素都是`Int`这种类型的元组。如果仅需要限制一个元组模式中的某几个元素，只需要直接对这几个元素提供类型标注即可。例如，在`let (x: String, y)`中的元组模式可以和任何有两个元素，且第一个元素类型是`String`的元组类型匹配。 +你可以使用类型标注去限制一个元组模式能匹配哪些种元组类型。例如，在常量声明`let (x, y): (Int, Int) = (1, 2)`中的元组模式`(x, y): (Int, Int)`只匹配两个元素都是`Int`这种类型的元组。如果仅需要限制一个元组模式中的某几个元素，只需要直接对这几个元素提供类型标注即可。例如，在`let (x: String, y)`中的元组模式可以和任何有两个元素，且第一个元素类型是`String`的元组类型匹配。 当元组模式被用在`for-in`语句或者变量或常量声明时，它仅可以包含通配符模式，标识符模式，可选模式或者其他包含这些模式的元祖模式。比如下面这段代码就不正确，因为`(x, 0)`中的元素`0`是一个表达式模式：