andre/the-swift-programming-language-in-chinese
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

correct a mistake, fix header ref

Browse Source
This commit is contained in:
stanzhai
2014-06-15 12:24:57 +08:00
parent fca29b22b1
commit 78604738b6
37 changed files with 13547 additions and 13547 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
source/chapter1/01_swift.md
View File

@ -1,17 +1,17 @@
> 翻译：[numbbbbb](https://github.com/numbbbbb) > 翻译：[numbbbbb](https://github.com/numbbbbb)
> 校对：[yeahdongcn](https://github.com/yeahdongcn) > 校对：[yeahdongcn](https://github.com/yeahdongcn)
# 关于 Swift # 关于 Swift
----------------- -----------------
Swift 是一种新的编程语言，用于编写 iOS 和 OS X 应用。Swift 结合了 C 和 Objective-C 的优点并且不受 C 兼容性的限制。Swift 采用安全的编程模式并添加了很多新特性，这将使编程更简单，更灵活，也更有趣。Swift 是基于成熟而且倍受喜爱的 Cocoa 和 Cocoa Touch 框架，它的降临将重新定义软件开发。 Swift 是一种新的编程语言，用于编写 iOS 和 OS X 应用。Swift 结合了 C 和 Objective-C 的优点并且不受 C 兼容性的限制。Swift 采用安全的编程模式并添加了很多新特性，这将使编程更简单，更灵活，也更有趣。Swift 是基于成熟而且倍受喜爱的 Cocoa 和 Cocoa Touch 框架，它的降临将重新定义软件开发。
Swift 的开发从很久之前就开始了。为了给 Swift 打好基础，苹果公司改进了编译器，调试器和框架结构。我们使用自动引用计数（Automatic Reference Counting, ARC）来简化内存管理。我们在 Foundation 和 Cocoa 的基础上构建框架栈并将其标准化。Objective-C 本身支持块、集合语法和模块，所以框架可以轻松支持现代编程语言技术。正是得益于这些基础工作，我们现在才能发布这样一个用于未来苹果软件开发的新语言。 Swift 的开发从很久之前就开始了。为了给 Swift 打好基础，苹果公司改进了编译器，调试器和框架结构。我们使用自动引用计数（Automatic Reference Counting, ARC）来简化内存管理。我们在 Foundation 和 Cocoa 的基础上构建框架栈并将其标准化。Objective-C 本身支持块、集合语法和模块，所以框架可以轻松支持现代编程语言技术。正是得益于这些基础工作，我们现在才能发布这样一个用于未来苹果软件开发的新语言。
Objective-C 开发者对 Swift 并不会感到陌生。它采用了 Objective-C 的命名参数以及动态对象模型，可以无缝对接到现有的 Cocoa 框架，并且可以兼容 Objective-C 代码。在此基础之上，Swift 还有许多新特性并且支持过程式编程和面向对象编程。 Objective-C 开发者对 Swift 并不会感到陌生。它采用了 Objective-C 的命名参数以及动态对象模型，可以无缝对接到现有的 Cocoa 框架，并且可以兼容 Objective-C 代码。在此基础之上，Swift 还有许多新特性并且支持过程式编程和面向对象编程。
Swift 对于初学者来说也很友好。它是第一个既满足工业标准又像脚本语言一样充满表现力和趣味的编程语言。它支持代码预览，这个革命性的特性可以允许程序员在不编译和运行应用程序的前提下运行 Swift 代码并实时查看结果。 Swift 对于初学者来说也很友好。它是第一个既满足工业标准又像脚本语言一样充满表现力和趣味的编程语言。它支持代码预览，这个革命性的特性可以允许程序员在不编译和运行应用程序的前提下运行 Swift 代码并实时查看结果。
Swift 将现代编程语言的精华和苹果工程师文化的智慧结合了起来。编译器对性能进行了优化，编程语言对开发进行了优化，两者互不干扰，鱼与熊掌兼得。Swift 既可以用于开发 “hello, world” 这样的小程序，也可以用于开发一套完整的操作系统。所有的这些特性让 Swift 对于开发者和苹果来说都是一项值得的投资。 Swift 将现代编程语言的精华和苹果工程师文化的智慧结合了起来。编译器对性能进行了优化，编程语言对开发进行了优化，两者互不干扰，鱼与熊掌兼得。Swift 既可以用于开发 “hello, world” 这样的小程序，也可以用于开发一套完整的操作系统。所有的这些特性让 Swift 对于开发者和苹果来说都是一项值得的投资。
Swift 是编写 iOS 和 OS X 应用的极佳手段，并将伴随着新的特性和功能持续演进。我们对 Swift 充满信心，你还在等什么！ Swift 是编写 iOS 和 OS X 应用的极佳手段，并将伴随着新的特性和功能持续演进。我们对 Swift 充满信心，你还在等什么！

1454
source/chapter1/02_a_swift_tour.md
View File

File diff suppressed because it is too large Load Diff

8
source/chapter1/chapter1.md
View File

@ -1,4 +1,4 @@
# 欢迎使用 Swift # 欢迎使用 Swift
在本章中您将了解 Swift 的特性和开发历史，并对 Swift 有一个初步的了解。 在本章中您将了解 Swift 的特性和开发历史，并对 Swift 有一个初步的了解。

1402
source/chapter2/01_The_Basics.md
View File

File diff suppressed because it is too large Load Diff

914
source/chapter2/02_Basic_Operators.md
View File

@ -1,457 +1,457 @@
> 翻译：[xielingwang](https://github.com/xielingwang) > 翻译：[xielingwang](https://github.com/xielingwang)
> 校对：[Evilcome](https://github.com/Evilcome) > 校对：[Evilcome](https://github.com/Evilcome)
# 基本运算符 # 基本运算符
----------------- -----------------
本页包含内容： 本页包含内容：
- [术语](#terminology) - [术语](#terminology)
- [赋值运算符](#assignment_operator) - [赋值运算符](#assignment_operator)
- [数值运算符](#arithmetic_operators) - [数值运算符](#arithmetic_operators)
- [组合赋值运算符（Compound Assignment Operators）](#compound_assignment_operators) - [组合赋值运算符（Compound Assignment Operators）](#compound_assignment_operators)
- [比较运算符](#comparison_operators) - [比较运算符](#comparison_operators)
- [三元条件运算符（Ternary Conditional Operator）](#ternary_conditional_operator) - [三元条件运算符（Ternary Conditional Operator）](#ternary_conditional_operator)
- [区间运算符](#range_operators) - [区间运算符](#range_operators)
- [逻辑运算符](#logical_operators) - [逻辑运算符](#logical_operators)
运算符是检查，改变，合并值的特殊符号或短语。例如，加号`+`将两个数相加（如`let i = 1 + 2`）。复杂些的运行算例如逻辑与运算符`&&`（如`if enteredDoorCode && passedRetinaScan`），又或让 i 值加1的便捷运算符自增运算符`++i`等。 运算符是检查，改变，合并值的特殊符号或短语。例如，加号`+`将两个数相加（如`let i = 1 + 2`）。复杂些的运行算例如逻辑与运算符`&&`（如`if enteredDoorCode && passedRetinaScan`），又或让 i 值加1的便捷运算符自增运算符`++i`等。
Swift 支持大部分标准 C 语言的运算符，且改进许多特性来减少常规编码错误。如，赋值符（`=`）不返回值，以防止把想要判断相等运算符（`==`）的地方写成赋值符导致的错误。数值运算符（`+`，`-`，`*`，`/`，`%`等）会检测并不允许值溢出，以此来避免保存变量时由于变量大于或小于其类型所能承载的范围时导致的异常结果。当然允许你使用 Swift 的溢出运算符来实现溢出。详情参见[溢出运算符](23_Advanced_Operators.html#overflow_operators)。 Swift 支持大部分标准 C 语言的运算符，且改进许多特性来减少常规编码错误。如，赋值符（`=`）不返回值，以防止把想要判断相等运算符（`==`）的地方写成赋值符导致的错误。数值运算符（`+`，`-`，`*`，`/`，`%`等）会检测并不允许值溢出，以此来避免保存变量时由于变量大于或小于其类型所能承载的范围时导致的异常结果。当然允许你使用 Swift 的溢出运算符来实现溢出。详情参见[溢出运算符](23_Advanced_Operators.html#overflow_operators)。
区别于 C 语言，在 Swift 中你可以对浮点数进行取余运算（`%`），Swift 还提供了 C 语言没有的表达两数之间的值的区间运算符，（`a..b`和`a...b`），这方便我们表达一个区间内的数值。 区别于 C 语言，在 Swift 中你可以对浮点数进行取余运算（`%`），Swift 还提供了 C 语言没有的表达两数之间的值的区间运算符，（`a..b`和`a...b`），这方便我们表达一个区间内的数值。
本章节只描述了 Swift 中的基本运算符，[高级运算符](23_Advanced_Operators.html)包含了高级运算符，及如何自定义运算符，及如何进行自定义类型的运算符重载。 本章节只描述了 Swift 中的基本运算符，[高级运算符](23_Advanced_Operators.html)包含了高级运算符，及如何自定义运算符，及如何进行自定义类型的运算符重载。
<a name="terminology"></a> <a name="terminology"></a>
## 术语 ## 术语
运算符有一元，二元和三元运算符。 运算符有一元，二元和三元运算符。
- 一元运算符对单一操作对象操作（如`-a`）。一元运算符分前置符和后置运算符，前置运算符需紧排操作对象之前（如`!b`），后置运算符需紧跟操作对象之后（如`i++`）。 - 一元运算符对单一操作对象操作（如`-a`）。一元运算符分前置符和后置运算符，前置运算符需紧排操作对象之前（如`!b`），后置运算符需紧跟操作对象之后（如`i++`）。
- 二元运算符操作两个操作对象（如`2 + 3`），是中置的，因为它们出现在两个操作对象之间。 - 二元运算符操作两个操作对象（如`2 + 3`），是中置的，因为它们出现在两个操作对象之间。
- 三元运算符操作三个操作对象，和 C 语言一样，Swift 只有一个三元运算符，就是三元条件运算符（`a ? b : c`）。 - 三元运算符操作三个操作对象，和 C 语言一样，Swift 只有一个三元运算符，就是三元条件运算符（`a ? b : c`）。
受运算符影响的值叫操作数，在表达式`1 + 2`中，加号`+`是二元运算符，它的两个操作数是值`1`和`2`。 受运算符影响的值叫操作数，在表达式`1 + 2`中，加号`+`是二元运算符，它的两个操作数是值`1`和`2`。
<a name="assignment_operator"></a> <a name="assignment_operator"></a>
## 赋值运算符 ## 赋值运算符
赋值运算（`a = b`），表示用`b`的值来初始化或更新`a`的值： 赋值运算（`a = b`），表示用`b`的值来初始化或更新`a`的值：
```swift ```swift
let b = 10 let b = 10
var a = 5 var a = 5
a = b a = b
// a 现在等于 10 // a 现在等于 10
``` ```
如果赋值的右边是一个多元组，它的元素可以马上被分解多个变量或变量： 如果赋值的右边是一个多元组，它的元素可以马上被分解多个变量或变量：
```swiflt ```swiflt
let (x, y) = (1, 2) let (x, y) = (1, 2)
// 现在 x 等于 1, y 等于 2 // 现在 x 等于 1, y 等于 2
``` ```
与 C 语言和 Objective-C 不同，Swift 的赋值操作并不返回任何值。所以以下代码是错误的： 与 C 语言和 Objective-C 不同，Swift 的赋值操作并不返回任何值。所以以下代码是错误的：
```swift ```swift
if x = y { if x = y {
// 此句错误, 因为 x = y 并不返回任何值 // 此句错误, 因为 x = y 并不返回任何值
} }
``` ```
这个特性使得你无法把（`==`）错写成（`=`）了，由于`if x = y`是错误代码，Swift 从底层帮你避免了这些代码错误。 这个特性使得你无法把（`==`）错写成（`=`）了，由于`if x = y`是错误代码，Swift 从底层帮你避免了这些代码错误。
<a name="arithmetic_operators"></a> <a name="arithmetic_operators"></a>
## 数值运算 ## 数值运算
Swift 让所有数值类型都支持了基本的四则运算： Swift 让所有数值类型都支持了基本的四则运算：
- 加法（`+`） - 加法（`+`）
- 减法（`-`） - 减法（`-`）
- 乘法（`*`） - 乘法（`*`）
- 除法（`/`） - 除法（`/`）
```swift ```swift
1 + 2 // 等于 3 1 + 2 // 等于 3
5 - 3 // 等于 2 5 - 3 // 等于 2
2 * 3 // 等于 6 2 * 3 // 等于 6
10.0 / 2.5 // 等于 4.0 10.0 / 2.5 // 等于 4.0
``` ```
与 C 语言和 Objective-C 不同的是，Swift 默认不允许在数值运算中出现溢出情况。但你可以使用 Swift 的溢出运算符来达到你有目的的溢出（如`a &+ b`）。详情参见[溢出运算符](23_Advanced_Operators.html#overflow_operators)。 与 C 语言和 Objective-C 不同的是，Swift 默认不允许在数值运算中出现溢出情况。但你可以使用 Swift 的溢出运算符来达到你有目的的溢出（如`a &+ b`）。详情参见[溢出运算符](23_Advanced_Operators.html#overflow_operators)。
加法运算符也用于`String`的拼接： 加法运算符也用于`String`的拼接：
```swift ```swift
"hello, " + "world" // 等于 "hello, world" "hello, " + "world" // 等于 "hello, world"
``` ```
两个`Character`值或一个`String`和一个`Character`值，相加会生成一个新的`String`值： 两个`Character`值或一个`String`和一个`Character`值，相加会生成一个新的`String`值：
```swift ```swift
let dog: Character = "d" let dog: Character = "d"
let cow: Character = "c" let cow: Character = "c"
let dogCow = dog + cow let dogCow = dog + cow
// 译者注: 原来的引号内是很可爱的小狗和小牛, 但win os下不支持表情字符, 所以改成了普通字符 // 译者注: 原来的引号内是很可爱的小狗和小牛, 但win os下不支持表情字符, 所以改成了普通字符
// dogCow 现在是 "dc" // dogCow 现在是 "dc"
``` ```
详情参见[字符，字符串的拼接](03_Strings_and_Characters.html#concatenating_strings_and_characters)。 详情参见[字符，字符串的拼接](03_Strings_and_Characters.html#concatenating_strings_and_characters)。
### 求余运算 ### 求余运算
求余运算（`a % b`）是计算`b`的多少倍刚刚好可以容入`a`，返回多出来的那部分（余数）。 求余运算（`a % b`）是计算`b`的多少倍刚刚好可以容入`a`，返回多出来的那部分（余数）。
>注意： >注意：
求余运算（`%`）在其他语言也叫取模运算。然而严格说来，我们看该运算符对负数的操作结果，"求余"比"取模"更合适些。 求余运算（`%`）在其他语言也叫取模运算。然而严格说来，我们看该运算符对负数的操作结果，"求余"比"取模"更合适些。
我们来谈谈取余是怎么回事，计算`9 % 4`，你先计算出`4`的多少倍会刚好可以容入`9`中： 我们来谈谈取余是怎么回事，计算`9 % 4`，你先计算出`4`的多少倍会刚好可以容入`9`中：
![Art/remainderInteger_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/remainderInteger_2x.png "Art/remainderInteger_2x.png") ![Art/remainderInteger_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/remainderInteger_2x.png "Art/remainderInteger_2x.png")
2倍，非常好，那余数是1（用橙色标出） 2倍，非常好，那余数是1（用橙色标出）
在 Swift 中这么来表达： 在 Swift 中这么来表达：
```swift ```swift
9 % 4 // 等于 1 9 % 4 // 等于 1
``` ```
为了得到`a % b`的结果，`%`计算了以下等式，并输出`余数`作为结果： 为了得到`a % b`的结果，`%`计算了以下等式，并输出`余数`作为结果：
*a = (b × 倍数) + 余数* *a = (b × 倍数) + 余数*
当`倍数`取最大值的时候，就会刚好可以容入`a`中。 当`倍数`取最大值的时候，就会刚好可以容入`a`中。
把`9`和`4`代入等式中，我们得`1`： 把`9`和`4`代入等式中，我们得`1`：
```swift ```swift
9 = (4 × 2) + 1 9 = (4 × 2) + 1
``` ```
同样的方法，我来们计算 `-9 % 4`： 同样的方法，我来们计算 `-9 % 4`：
```swift ```swift
-9 % 4 // 等于 -1 -9 % 4 // 等于 -1
``` ```
把`-9`和`4`代入等式，`-2`是取到的最大整数： 把`-9`和`4`代入等式，`-2`是取到的最大整数：
```swift ```swift
-9 = (4 × -2) + -1 -9 = (4 × -2) + -1
``` ```
余数是`-1`。 余数是`-1`。
在对负数`b`求余时，`b`的符号会被忽略。这意味着 `a % b` 和 `a % -b`的结果是相同的。 在对负数`b`求余时，`b`的符号会被忽略。这意味着 `a % b` 和 `a % -b`的结果是相同的。
### 浮点数求余计算 ### 浮点数求余计算
不同于 C 语言和 Objective-C，Swift 中是可以对浮点数进行求余的。 不同于 C 语言和 Objective-C，Swift 中是可以对浮点数进行求余的。
```swift ```swift
8 % 2.5 // 等于 0.5 8 % 2.5 // 等于 0.5
``` ```
这个例子中，`8`除于`2.5`等于`3`余`0.5`，所以结果是一个`Double`值`0.5`。 这个例子中，`8`除于`2.5`等于`3`余`0.5`，所以结果是一个`Double`值`0.5`。
![Art/remainderFloat_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/remainderFloat_2x.png "Art/remainderFloat_2x.png") ![Art/remainderFloat_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/remainderFloat_2x.png "Art/remainderFloat_2x.png")
### 自增和自增运算 ### 自增和自增运算
和 C 语言一样，Swift 也提供了方便对变量本身加1或减1的自增（`++`）和自减（`--`）的运算符。其操作对象可以是整形和浮点型。 和 C 语言一样，Swift 也提供了方便对变量本身加1或减1的自增（`++`）和自减（`--`）的运算符。其操作对象可以是整形和浮点型。
‌ ‌
```swift ```swift
var i = 0 var i = 0
++i // 现在 i = 1 ++i // 现在 i = 1
``` ```
每调用一次`++i`，`i`的值就会加1。实际上，`++i`是`i = i + 1`的简写，而`--i`是`i = i - 1`的简写。 每调用一次`++i`，`i`的值就会加1。实际上，`++i`是`i = i + 1`的简写，而`--i`是`i = i - 1`的简写。
`++`和`--`既是前置又是后置运算。`++i`，`i++`，`--i`和`i--`都是有效的写法。 `++`和`--`既是前置又是后置运算。`++i`，`i++`，`--i`和`i--`都是有效的写法。
我们需要注意的是这些运算符修改了`i`后有一个返回值。如果你只想修改`i`的值，那你就可以忽略这个返回值。但如果你想使用返回值，你就需要留意前置和后置操作的返回值是不同的。 我们需要注意的是这些运算符修改了`i`后有一个返回值。如果你只想修改`i`的值，那你就可以忽略这个返回值。但如果你想使用返回值，你就需要留意前置和后置操作的返回值是不同的。
- 当`++`前置的时候，先自増再返回。 - 当`++`前置的时候，先自増再返回。
- 当`++`后置的时候，先返回再自增。 - 当`++`后置的时候，先返回再自增。
例如： 例如：
```swift ```swift
var a = 0 var a = 0
let b = ++a // a 和 b 现在都是 1 let b = ++a // a 和 b 现在都是 1
let c = a++ // a 现在 2, 但 c 是 a 自增前的值 1 let c = a++ // a 现在 2, 但 c 是 a 自增前的值 1
``` ```
上述例子，`let b = ++a`先把`a`加1了再返回`a`的值。所以`a`和`b`都是新值`1`。 上述例子，`let b = ++a`先把`a`加1了再返回`a`的值。所以`a`和`b`都是新值`1`。
而`let c = a++`，是先返回了`a`的值，然后`a`才加1。所以`c`得到了`a`的旧值1，而`a`加1后变成2。 而`let c = a++`，是先返回了`a`的值，然后`a`才加1。所以`c`得到了`a`的旧值1，而`a`加1后变成2。
除非你需要使用`i++`的特性，不然推荐你使用`++i`和`--i`，因为先修改后返回这样的行为更符合我们的逻辑。 除非你需要使用`i++`的特性，不然推荐你使用`++i`和`--i`，因为先修改后返回这样的行为更符合我们的逻辑。
### 一元负号 ### 一元负号
数值的正负号可以使用前缀`-`（即一元负号）来切换： 数值的正负号可以使用前缀`-`（即一元负号）来切换：
```swift ```swift
let three = 3 let three = 3
let minusThree = -three // minusThree 等于 -3 let minusThree = -three // minusThree 等于 -3
let plusThree = -minusThree // plusThree 等于 3, 或 "负负3" let plusThree = -minusThree // plusThree 等于 3, 或 "负负3"
``` ```
一元负号（`-`）写在操作数之前，中间没有空格。 一元负号（`-`）写在操作数之前，中间没有空格。
### 一元正号 ### 一元正号
一元正号（`+`）不做任何改变地返回操作数的值。 一元正号（`+`）不做任何改变地返回操作数的值。
```swift ```swift
let minusSix = -6 let minusSix = -6
let alsoMinusSix = +minusSix // alsoMinusSix 等于 -6 let alsoMinusSix = +minusSix // alsoMinusSix 等于 -6
``` ```
虽然一元`+`做无用功，但当你在使用一元负号来表达负数时，你可以使用一元正号来表达正数，如此你的代码会具有对称美。 虽然一元`+`做无用功，但当你在使用一元负号来表达负数时，你可以使用一元正号来表达正数，如此你的代码会具有对称美。
<a name="compound_assignment_operators"></a> <a name="compound_assignment_operators"></a>
## 复合赋值（Compound Assignment Operators） ## 复合赋值（Compound Assignment Operators）
如同强大的 C 语言，Swift 也提供把其他运算符和赋值运算（`=`）组合的复合赋值运算符，加赋运算（`+=`）是其中一个例子： 如同强大的 C 语言，Swift 也提供把其他运算符和赋值运算（`=`）组合的复合赋值运算符，加赋运算（`+=`）是其中一个例子：
```swift ```swift
var a = 1 var a = 1
a += 2 // a 现在是 3 a += 2 // a 现在是 3
``` ```
表达式`a += 2`是`a = a + 2`的简写，一个加赋运算就把加法和赋值两件事完成了。 表达式`a += 2`是`a = a + 2`的简写，一个加赋运算就把加法和赋值两件事完成了。
>注意： >注意：
复合赋值运算没有返回值，`let b = a += 2`这类代码是错误。这不同于上面提到的自增和自减运算符。 复合赋值运算没有返回值，`let b = a += 2`这类代码是错误。这不同于上面提到的自增和自减运算符。
在[表达式](../chapter3/04_Expressions.html)章节里有复合运算符的完整列表。 在[表达式](../chapter3/04_Expressions.html)章节里有复合运算符的完整列表。
‌ ‌
<a name="comparison_operators"></a> <a name="comparison_operators"></a>
## 比较运算 ## 比较运算
所有标准 C 语言中的比较运算都可以在 Swift 中使用。 所有标准 C 语言中的比较运算都可以在 Swift 中使用。
- 等于（`a == b`） - 等于（`a == b`）
- 不等于（`a != b`） - 不等于（`a != b`）
- 大于（`a > b`） - 大于（`a > b`）
- 小于（`a < b`） - 小于（`a < b`）
- 大于等于（`a >= b`） - 大于等于（`a >= b`）
- 小于等于（`a <= b`） - 小于等于（`a <= b`）
> 注意： > 注意：
Swift 也提供恒等`===`和不恒等`!==`这两个比较符来判断两个对象是否引用同一个对象实例。更多细节在[类与结构](09_Classes_and_Structures.html)。 Swift 也提供恒等`===`和不恒等`!==`这两个比较符来判断两个对象是否引用同一个对象实例。更多细节在[类与结构](09_Classes_and_Structures.html)。
每个比较运算都返回了一个标识表达式是否成立的布尔值： 每个比较运算都返回了一个标识表达式是否成立的布尔值：
```swift ```swift
1 == 1 // true, 因为 1 等于 1 1 == 1 // true, 因为 1 等于 1
2 != 1 // true, 因为 2 不等于 1 2 != 1 // true, 因为 2 不等于 1
2 > 1 // true, 因为 2 大于 1 2 > 1 // true, 因为 2 大于 1
1 < 2 // true, 因为 1 小于2 1 < 2 // true, 因为 1 小于2
1 >= 1 // true, 因为 1 大于等于 1 1 >= 1 // true, 因为 1 大于等于 1
2 <= 1 // false, 因为 2 并不小于等于 1 2 <= 1 // false, 因为 2 并不小于等于 1
``` ```
比较运算多用于条件语句，如`if`条件： 比较运算多用于条件语句，如`if`条件：
```swift ```swift
let name = "world" let name = "world"
if name == "world" { if name == "world" {
println("hello, world") println("hello, world")
} else { } else {
println("I'm sorry \(name), but I don't recognize you") println("I'm sorry \(name), but I don't recognize you")
} }
// 输出 "hello, world", 因为 `name` 就是等于 "world" // 输出 "hello, world", 因为 `name` 就是等于 "world"
``` ```
关于`if`语句，请看[控制流](05_Control_Flow.html)。 关于`if`语句，请看[控制流](05_Control_Flow.html)。
<a name="ternary_conditional_operator"></a> <a name="ternary_conditional_operator"></a>
## 三元条件运算(Ternary Conditional Operator) ## 三元条件运算(Ternary Conditional Operator)
三元条件运算的特殊在于它是有三个操作数的运算符，它的原型是 `问题 ? 答案1 : 答案2`。它简洁地表达根据`问题`成立与否作出二选一的操作。如果`问题`成立，返回`答案1`的结果; 如果不成立，返回`答案2`的结果。 三元条件运算的特殊在于它是有三个操作数的运算符，它的原型是 `问题 ? 答案1 : 答案2`。它简洁地表达根据`问题`成立与否作出二选一的操作。如果`问题`成立，返回`答案1`的结果; 如果不成立，返回`答案2`的结果。
使用三元条件运算简化了以下代码： 使用三元条件运算简化了以下代码：
```swift ```swift
if question: { if question: {
answer1 answer1
} else { } else {
answer2 answer2
} }
``` ```
这里有个计算表格行高的例子。如果有表头，那行高应比内容高度要高出50像素; 如果没有表头，只需高出20像素。 这里有个计算表格行高的例子。如果有表头，那行高应比内容高度要高出50像素; 如果没有表头，只需高出20像素。
```swift ```swift
let contentHeight = 40 let contentHeight = 40
let hasHeader = true let hasHeader = true
let rowHeight = contentHeight + (hasHeader ? 50 : 20) let rowHeight = contentHeight + (hasHeader ? 50 : 20)
// rowHeight 现在是 90 // rowHeight 现在是 90
``` ```
这样写会比下面的代码简洁： 这样写会比下面的代码简洁：
```swift ```swift
let contentHeight = 40 let contentHeight = 40
let hasHeader = true let hasHeader = true
var rowHeight = contentHeight var rowHeight = contentHeight
if hasHeader { if hasHeader {
rowHeight = rowHeight + 50 rowHeight = rowHeight + 50
} else { } else {
rowHeight = rowHeight + 20 rowHeight = rowHeight + 20
} }
// rowHeight 现在是 90 // rowHeight 现在是 90
``` ```
第一段代码例子使用了三元条件运算，所以一行代码就能让我们得到正确答案。这比第二段代码简洁得多，无需将`rowHeight`定义成变量，因为它的值无需在`if`语句中改变。 第一段代码例子使用了三元条件运算，所以一行代码就能让我们得到正确答案。这比第二段代码简洁得多，无需将`rowHeight`定义成变量，因为它的值无需在`if`语句中改变。
三元条件运算提供有效率且便捷的方式来表达二选一的选择。需要注意的事，过度使用三元条件运算就会由简洁的代码变成难懂的代码。我们应避免在一个组合语句使用多个三元条件运算符。 三元条件运算提供有效率且便捷的方式来表达二选一的选择。需要注意的事，过度使用三元条件运算就会由简洁的代码变成难懂的代码。我们应避免在一个组合语句使用多个三元条件运算符。
<a name="range_operators"></a> <a name="range_operators"></a>
## 区间运算符 ## 区间运算符
Swift 提供了两个方便表达一个区间的值的运算符。 Swift 提供了两个方便表达一个区间的值的运算符。
### 闭区间运算符 ### 闭区间运算符
闭区间运算符（`a...b`）定义一个包含从`a`到`b`(包括`a`和`b`)的所有值的区间。 闭区间运算符（`a...b`）定义一个包含从`a`到`b`(包括`a`和`b`)的所有值的区间。
‌ ‌
闭区间运算符在迭代一个区间的所有值时是非常有用的，如在`for-in`循环中： 闭区间运算符在迭代一个区间的所有值时是非常有用的，如在`for-in`循环中：
```swift ```swift
for index in 1...5 { for index in 1...5 {
println("\(index) * 5 = \(index * 5)") println("\(index) * 5 = \(index * 5)")
} }
// 1 * 5 = 5 // 1 * 5 = 5
// 2 * 5 = 10 // 2 * 5 = 10
// 3 * 5 = 15 // 3 * 5 = 15
// 4 * 5 = 20 // 4 * 5 = 20
// 5 * 5 = 25 // 5 * 5 = 25
``` ```
关于`for-in`，请看[控制流](05_Control_Flow.html)。 关于`for-in`，请看[控制流](05_Control_Flow.html)。
### 半闭区间 ### 半闭区间
半闭区间（`a..b`）定义一个从`a`到`b`但不包括`b`的区间。 半闭区间（`a..b`）定义一个从`a`到`b`但不包括`b`的区间。
之所以称为半闭区间，是因为该区间包含第一个值而不包括最后的值。 之所以称为半闭区间，是因为该区间包含第一个值而不包括最后的值。
半闭区间的实用性在于当你使用一个0始的列表(如数组)时，非常方便地从0数到列表的长度。 半闭区间的实用性在于当你使用一个0始的列表(如数组)时，非常方便地从0数到列表的长度。
```swift ```swift
let names = ["Anna", "Alex", "Brian", "Jack"] let names = ["Anna", "Alex", "Brian", "Jack"]
let count = names.count let count = names.count
for i in 0..count { for i in 0..count {
println("第 \(i + 1) 个人叫 \(names[i])") println("第 \(i + 1) 个人叫 \(names[i])")
} }
// 第 1 个人叫 Anna // 第 1 个人叫 Anna
// 第 2 个人叫 Alex // 第 2 个人叫 Alex
// 第 3 个人叫 Brian // 第 3 个人叫 Brian
// 第 4 个人叫 Jack // 第 4 个人叫 Jack
``` ```
数组有4个元素，但`0..count`只数到3(最后一个元素的下标)，因为它是半闭区间。关于数组，请查阅[数组](04_Collection_Types.html#arrays)。 数组有4个元素，但`0..count`只数到3(最后一个元素的下标)，因为它是半闭区间。关于数组，请查阅[数组](04_Collection_Types.html#arrays)。
<a name="logical_operators"></a> <a name="logical_operators"></a>
## 逻辑运算 ## 逻辑运算
逻辑运算的操作对象是逻辑布尔值。Swift 支持基于 C 语言的三个标准逻辑运算。 逻辑运算的操作对象是逻辑布尔值。Swift 支持基于 C 语言的三个标准逻辑运算。
- 逻辑非（`!a`） - 逻辑非（`!a`）
- 逻辑与（`a && b`） - 逻辑与（`a && b`）
- 逻辑或（`a || b`） - 逻辑或（`a || b`）
### 逻辑非 ### 逻辑非
逻辑非运算（`!a`）对一个布尔值取反，使得`true`变`false`，`false`变`true`。 逻辑非运算（`!a`）对一个布尔值取反，使得`true`变`false`，`false`变`true`。
它是一个前置运算符，需出现在操作数之前，且不加空格。读作`非 a`，然后我们看以下例子： 它是一个前置运算符，需出现在操作数之前，且不加空格。读作`非 a`，然后我们看以下例子：
```swift ```swift
let allowedEntry = false let allowedEntry = false
if !allowedEntry { if !allowedEntry {
println("ACCESS DENIED") println("ACCESS DENIED")
} }
// 输出 "ACCESS DENIED" // 输出 "ACCESS DENIED"
``` ```
`if !allowedEntry`语句可以读作 "如果 非 alowed entry。"，接下一行代码只有在如果 "非 allow entry" 为`true`，即`allowEntry`为`false`时被执行。 `if !allowedEntry`语句可以读作 "如果 非 alowed entry。"，接下一行代码只有在如果 "非 allow entry" 为`true`，即`allowEntry`为`false`时被执行。
在示例代码中，小心地选择布尔常量或变量有助于代码的可读性，并且避免使用双重逻辑非运算，或混乱的逻辑语句。 在示例代码中，小心地选择布尔常量或变量有助于代码的可读性，并且避免使用双重逻辑非运算，或混乱的逻辑语句。
### 逻辑与 ### 逻辑与
逻辑与（`a && b`）表达了只有`a`和`b`的值都为`true`时，整个表达式的值才会是`true`。 逻辑与（`a && b`）表达了只有`a`和`b`的值都为`true`时，整个表达式的值才会是`true`。
只要任意一个值为`false`，整个表达式的值就为`false`。事实上，如果第一个值为`false`，那么是不去计算第二个值的，因为它已经不可能影响整个表达式的结果了。这被称做 "短路计算（short-circuit evaluation）"。 只要任意一个值为`false`，整个表达式的值就为`false`。事实上，如果第一个值为`false`，那么是不去计算第二个值的，因为它已经不可能影响整个表达式的结果了。这被称做 "短路计算（short-circuit evaluation）"。
以下例子，只有两个`Bool`值都为`true`值的时候才允许进入： 以下例子，只有两个`Bool`值都为`true`值的时候才允许进入：
```swift ```swift
let enteredDoorCode = true let enteredDoorCode = true
let passedRetinaScan = false let passedRetinaScan = false
if enteredDoorCode && passedRetinaScan { if enteredDoorCode && passedRetinaScan {
println("Welcome!") println("Welcome!")
} else { } else {
println("ACCESS DENIED") println("ACCESS DENIED")
} }
// 输出 "ACCESS DENIED" // 输出 "ACCESS DENIED"
``` ```
### 逻辑或 ### 逻辑或
逻辑或（`a || b`）是一个由两个连续的`|`组成的中置运算符。它表示了两个逻辑表达式的其中一个为`true`，整个表达式就为`true`。 逻辑或（`a || b`）是一个由两个连续的`|`组成的中置运算符。它表示了两个逻辑表达式的其中一个为`true`，整个表达式就为`true`。
同逻辑与运算类似，逻辑或也是"短路计算"的，当左端的表达式为`true`时，将不计算右边的表达式了，因为它不可能改变整个表达式的值了。 同逻辑与运算类似，逻辑或也是"短路计算"的，当左端的表达式为`true`时，将不计算右边的表达式了，因为它不可能改变整个表达式的值了。
以下示例代码中，第一个布尔值（`hasDoorKey`）为`false`，但第二个值（`knowsOverridePassword`）为`true`，所以整个表达是`true`，于是允许进入： 以下示例代码中，第一个布尔值（`hasDoorKey`）为`false`，但第二个值（`knowsOverridePassword`）为`true`，所以整个表达是`true`，于是允许进入：
```swift ```swift
let hasDoorKey = false let hasDoorKey = false
let knowsOverridePassword = true let knowsOverridePassword = true
if hasDoorKey || knowsOverridePassword { if hasDoorKey || knowsOverridePassword {
println("Welcome!") println("Welcome!")
} else { } else {
println("ACCESS DENIED") println("ACCESS DENIED")
} }
// 输出 "Welcome!" // 输出 "Welcome!"
``` ```
### 组合逻辑 ### 组合逻辑
我们可以组合多个逻辑运算来表达一个复合逻辑： 我们可以组合多个逻辑运算来表达一个复合逻辑：
```swift ```swift
if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword { if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
println("Welcome!") println("Welcome!")
} else { } else {
println("ACCESS DENIED") println("ACCESS DENIED")
} }
// 输出 "Welcome!" // 输出 "Welcome!"
``` ```
这个例子使用了含多个`&&`和`||`的复合逻辑。但无论怎样，`&&`和`||`始终只能操作两个值。所以这实际是三个简单逻辑连续操作的结果。我们来解读一下： 这个例子使用了含多个`&&`和`||`的复合逻辑。但无论怎样，`&&`和`||`始终只能操作两个值。所以这实际是三个简单逻辑连续操作的结果。我们来解读一下：
如果我们输入了正确的密码并通过了视网膜扫描; 或者我们有一把有效的钥匙; 又或者我们知道紧急情况下重置的密码，我们就能把门打开进入。 如果我们输入了正确的密码并通过了视网膜扫描; 或者我们有一把有效的钥匙; 又或者我们知道紧急情况下重置的密码，我们就能把门打开进入。
前两种情况，我们都不满足，所以前两个简单逻辑的结果是`false`，但是我们是知道紧急情况下重置的密码的，所以整个复杂表达式的值还是`true`。 前两种情况，我们都不满足，所以前两个简单逻辑的结果是`false`，但是我们是知道紧急情况下重置的密码的，所以整个复杂表达式的值还是`true`。
### 使用括号来明确优先级 ### 使用括号来明确优先级
为了一个复杂表达式更容易读懂，在合适的地方使用括号来明确优先级是很有效的，虽然它并非必要的。在上个关于门的权限的例子中，我们给第一个部分加个括号，使用它看起来逻辑更明确： 为了一个复杂表达式更容易读懂，在合适的地方使用括号来明确优先级是很有效的，虽然它并非必要的。在上个关于门的权限的例子中，我们给第一个部分加个括号，使用它看起来逻辑更明确：
```swift ```swift
if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword { if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
println("Welcome!") println("Welcome!")
} else { } else {
println("ACCESS DENIED") println("ACCESS DENIED")
} }
// 输出 "Welcome!" // 输出 "Welcome!"
``` ```
这括号使得前两个值被看成整个逻辑表达中独立的一个部分。虽然有括号和没括号的输出结果是一样的，但对于读代码的人来说有括号的代码更清晰。可读性比简洁性更重要，请在可以让你代码变清晰地地方加个括号吧！ 这括号使得前两个值被看成整个逻辑表达中独立的一个部分。虽然有括号和没括号的输出结果是一样的，但对于读代码的人来说有括号的代码更清晰。可读性比简洁性更重要，请在可以让你代码变清晰地地方加个括号吧！

822
source/chapter2/03_Strings_and_Characters.md
View File

@ -1,411 +1,411 @@
> 翻译：[wh1100717](https://github.com/wh1100717) > 翻译：[wh1100717](https://github.com/wh1100717)
> 校对：[Hawstein](https://github.com/Hawstein) > 校对：[Hawstein](https://github.com/Hawstein)
# 字符串和字符（Strings and Characters） # 字符串和字符（Strings and Characters）
----------------- -----------------
本页包含内容： 本页包含内容：
- [字符串字面量](#string_literals) - [字符串字面量](#string_literals)
- [初始化空字符串](#initializing_an_empty_string) - [初始化空字符串](#initializing_an_empty_string)
- [字符串可变性](#string_mutability) - [字符串可变性](#string_mutability)
- [字符串是值类型](#strings_are_value_types) - [字符串是值类型](#strings_are_value_types)
- [使用字符](#working_with_characters) - [使用字符](#working_with_characters)
- [计算字符数量](#counting_characters) - [计算字符数量](#counting_characters)
- [连接字符串和字符](#concatenating_strings_and_characters) - [连接字符串和字符](#concatenating_strings_and_characters)
- [字符串插值](#string_interpolation) - [字符串插值](#string_interpolation)
- [比较字符串](#comparing_strings) - [比较字符串](#comparing_strings)
- [字符串大小写](#uppercase_and_lowercase_strings) - [字符串大小写](#uppercase_and_lowercase_strings)
- [Unicode](#unicode) - [Unicode](#unicode)
`String`是例如“hello, world”，“海贼王” 这样的有序的`Character`（字符）类型的值的集合，通过`String`类型来表示。 `String`是例如“hello, world”，“海贼王” 这样的有序的`Character`（字符）类型的值的集合，通过`String`类型来表示。
Swift 的`String`和`Character`类型提供了一个快速的，兼容 Unicode 的方式来处理代码中的文本信息。 Swift 的`String`和`Character`类型提供了一个快速的，兼容 Unicode 的方式来处理代码中的文本信息。
创建和操作字符串的语法与 C 语言中字符串操作相似，轻量并且易读。 创建和操作字符串的语法与 C 语言中字符串操作相似，轻量并且易读。
字符串连接操作只需要简单地通过`+`号将两个字符串相连即可。 字符串连接操作只需要简单地通过`+`号将两个字符串相连即可。
与 Swift 中其他值一样，能否更改字符串的值，取决于其被定义为常量还是变量。 与 Swift 中其他值一样，能否更改字符串的值，取决于其被定义为常量还是变量。
尽管语法简易，但`String`类型是一种快速、现代化的字符串实现。 尽管语法简易，但`String`类型是一种快速、现代化的字符串实现。
每一个字符串都是由独立编码的 Unicode 字符组成，并提供了以不同 Unicode 表示（representations）来访问这些字符的支持。 每一个字符串都是由独立编码的 Unicode 字符组成，并提供了以不同 Unicode 表示（representations）来访问这些字符的支持。
Swift 可以在常量、变量、字面量和表达式中进行字符串插值操作，可以轻松创建用于展示、存储和打印的自定义字符串。 Swift 可以在常量、变量、字面量和表达式中进行字符串插值操作，可以轻松创建用于展示、存储和打印的自定义字符串。
> 注意： > 注意：
Swift 的`String`类型与 Foundation `NSString`类进行了无缝桥接。如果您利用 Cocoa 或 Cocoa Touch 中的 Foundation 框架进行工作。所有`NSString` API 都可以调用您创建的任意`String`类型的值。除此之外，还可以使用本章介绍的`String`特性。您也可以在任意要求传入`NSString`实例作为参数的 API 中使用`String`类型的值作为替代。 Swift 的`String`类型与 Foundation `NSString`类进行了无缝桥接。如果您利用 Cocoa 或 Cocoa Touch 中的 Foundation 框架进行工作。所有`NSString` API 都可以调用您创建的任意`String`类型的值。除此之外，还可以使用本章介绍的`String`特性。您也可以在任意要求传入`NSString`实例作为参数的 API 中使用`String`类型的值作为替代。
>更多关于在 Foundation 和 Cocoa 中使用`String`的信息请查看 [Using Swift with Cocoa and Objective-C](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216)。 >更多关于在 Foundation 和 Cocoa 中使用`String`的信息请查看 [Using Swift with Cocoa and Objective-C](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216)。
<a name="string_literals"></a> <a name="string_literals"></a>
## 字符串字面量（String Literals） ## 字符串字面量（String Literals）
您可以在您的代码中包含一段预定义的字符串值作为字符串字面量。 您可以在您的代码中包含一段预定义的字符串值作为字符串字面量。
字符串字面量是由双引号 ("") 包裹着的具有固定顺序的文本字符集。 字符串字面量是由双引号 ("") 包裹着的具有固定顺序的文本字符集。
字符串字面量可以用于为常量和变量提供初始值。 字符串字面量可以用于为常量和变量提供初始值。
```swift ```swift
let someString = "Some string literal value" let someString = "Some string literal value"
``` ```
> 注意： > 注意：
`someString`变量通过字符串字面量进行初始化，Swift 因此推断该变量为`String`类型。 `someString`变量通过字符串字面量进行初始化，Swift 因此推断该变量为`String`类型。
字符串字面量可以包含以下特殊字符： 字符串字面量可以包含以下特殊字符：
* 转义字符`\0`(空字符)、`\\`(反斜线)、`\t`(水平制表符)、`\n`(换行符)、`\r`(回车符)、`\"`(双引号)、`\'`(单引号)。 * 转义字符`\0`(空字符)、`\\`(反斜线)、`\t`(水平制表符)、`\n`(换行符)、`\r`(回车符)、`\"`(双引号)、`\'`(单引号)。
* 单字节 Unicode 标量，写成`\xnn`，其中`nn`为两位十六进制数。 * 单字节 Unicode 标量，写成`\xnn`，其中`nn`为两位十六进制数。
* 双字节 Unicode 标量，写成`\unnnn`，其中`nnnn`为四位十六进制数。 * 双字节 Unicode 标量，写成`\unnnn`，其中`nnnn`为四位十六进制数。
* 四字节 Unicode 标量，写成`\Unnnnnnnn`，其中`nnnnnnnn`为八位十六进制数。 * 四字节 Unicode 标量，写成`\Unnnnnnnn`，其中`nnnnnnnn`为八位十六进制数。
下面的代码为各种特殊字符的使用示例。 下面的代码为各种特殊字符的使用示例。
`wiseWords`常量包含了两个转移特殊字符 (双括号)； `wiseWords`常量包含了两个转移特殊字符 (双括号)；
`dollarSign`、`blackHeart`和`sparklingHeart`常量演示了三种不同格式的 Unicode 标量： `dollarSign`、`blackHeart`和`sparklingHeart`常量演示了三种不同格式的 Unicode 标量：
```swift ```swift
let wiseWords = "\"我是要成为海贼王的男人\" - 路飞" let wiseWords = "\"我是要成为海贼王的男人\" - 路飞"
// "我是要成为海贼王的男人" - 路飞 // "我是要成为海贼王的男人" - 路飞
let dollarSign = "\x24" // $, Unicode 标量 U+0024 let dollarSign = "\x24" // $, Unicode 标量 U+0024
let blackHeart = "\u2665" // ♥, Unicode 标量 U+2665 let blackHeart = "\u2665" // ♥, Unicode 标量 U+2665
let sparklingHeart = "\U0001F496" // 💖, Unicode 标量 U+1F496 let sparklingHeart = "\U0001F496" // 💖, Unicode 标量 U+1F496
``` ```
<a name="initializing_an_empty_string"></a> <a name="initializing_an_empty_string"></a>
## 初始化空字符串 (Initializing an Empty String) ## 初始化空字符串 (Initializing an Empty String)
为了构造一个很长的字符串，可以创建一个空字符串作为初始值。 为了构造一个很长的字符串，可以创建一个空字符串作为初始值。
可以将空的字符串字面量赋值给变量，也可以初始化一个新的`String`实例： 可以将空的字符串字面量赋值给变量，也可以初始化一个新的`String`实例：
```swift ```swift
var emptyString = "" // 空字符串字面量 var emptyString = "" // 空字符串字面量
var anotherEmptyString = String() // 初始化 String 实例 var anotherEmptyString = String() // 初始化 String 实例
// 两个字符串均为空并等价。 // 两个字符串均为空并等价。
``` ```
您可以通过检查其`Boolean`类型的`isEmpty`属性来判断该字符串是否为空： 您可以通过检查其`Boolean`类型的`isEmpty`属性来判断该字符串是否为空：
```swift ```swift
if emptyString.isEmpty { if emptyString.isEmpty {
println("什么都没有") println("什么都没有")
} }
// 打印输出："什么都没有" // 打印输出："什么都没有"
``` ```
<a name="string_mutability"></a> <a name="string_mutability"></a>
## 字符串可变性 (String Mutability) ## 字符串可变性 (String Mutability)
您可以通过将一个特定字符串分配给一个变量来对其进行修改，或者分配给一个常量来保证其不会被修改： 您可以通过将一个特定字符串分配给一个变量来对其进行修改，或者分配给一个常量来保证其不会被修改：
```swift ```swift
var variableString = "Horse" var variableString = "Horse"
variableString += " and carriage" variableString += " and carriage"
// variableString 现在为 "Horse and carriage" // variableString 现在为 "Horse and carriage"
let constantString = "Highlander" let constantString = "Highlander"
constantString += " and another Highlander" constantString += " and another Highlander"
// 这会报告一个编译错误 (compile-time error) - 常量不可以被修改。 // 这会报告一个编译错误 (compile-time error) - 常量不可以被修改。
``` ```
> 注意： > 注意：
在 Objective-C 和 Cocoa 中，您通过选择两个不同的类(`NSString`和`NSMutableString`)来指定该字符串是否可以被修改，Swift 中的字符串是否可以修改仅通过定义的是变量还是常量来决定，实现了多种类型可变性操作的统一。 在 Objective-C 和 Cocoa 中，您通过选择两个不同的类(`NSString`和`NSMutableString`)来指定该字符串是否可以被修改，Swift 中的字符串是否可以修改仅通过定义的是变量还是常量来决定，实现了多种类型可变性操作的统一。
<a name="strings_are_value_types"></a> <a name="strings_are_value_types"></a>
## 字符串是值类型（Strings Are Value Types） ## 字符串是值类型（Strings Are Value Types）
Swift 的`String`类型是值类型。 Swift 的`String`类型是值类型。
如果您创建了一个新的字符串，那么当其进行常量、变量赋值操作或在函数/方法中传递时，会进行值拷贝。 如果您创建了一个新的字符串，那么当其进行常量、变量赋值操作或在函数/方法中传递时，会进行值拷贝。
任何情况下，都会对已有字符串值创建新副本，并对该新副本进行传递或赋值操作。 任何情况下，都会对已有字符串值创建新副本，并对该新副本进行传递或赋值操作。
值类型在 [结构体和枚举是值类型](09_Classes_and_Structures.html#structures_and_enumerations_are_value_types) 中进行了说明。 值类型在 [结构体和枚举是值类型](09_Classes_and_Structures.html#structures_and_enumerations_are_value_types) 中进行了说明。
> 注意： > 注意：
与 Cocoa 中的`NSString`不同，当您在 Cocoa 中创建了一个`NSString`实例，并将其传递给一个函数/方法，或者赋值给一个变量，您传递或赋值的是该`NSString`实例的一个引用，除非您特别要求进行值拷贝，否则字符串不会生成新的副本来进行赋值操作。 与 Cocoa 中的`NSString`不同，当您在 Cocoa 中创建了一个`NSString`实例，并将其传递给一个函数/方法，或者赋值给一个变量，您传递或赋值的是该`NSString`实例的一个引用，除非您特别要求进行值拷贝，否则字符串不会生成新的副本来进行赋值操作。
Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字符串的值。 Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字符串的值。
很明显无论该值来自于哪里，都是您独自拥有的。 很明显无论该值来自于哪里，都是您独自拥有的。
您可以放心您传递的字符串本身不会被更改。 您可以放心您传递的字符串本身不会被更改。
在实际编译时，Swift 编译器会优化字符串的使用，使实际的复制只发生在绝对必要的情况下，这意味着您将字符串作为值类型的同时可以获得极高的性能。 在实际编译时，Swift 编译器会优化字符串的使用，使实际的复制只发生在绝对必要的情况下，这意味着您将字符串作为值类型的同时可以获得极高的性能。
<a name="working_with_characters"></a> <a name="working_with_characters"></a>
## 使用字符（Working with Characters） ## 使用字符（Working with Characters）
Swift 的`String`类型表示特定序列的`Character`（字符） 类型值的集合。 Swift 的`String`类型表示特定序列的`Character`（字符） 类型值的集合。
每一个字符值代表一个 Unicode 字符。 每一个字符值代表一个 Unicode 字符。
您可利用`for-in`循环来遍历字符串中的每一个字符： 您可利用`for-in`循环来遍历字符串中的每一个字符：
```swift ```swift
for character in "Dog!🐶" { for character in "Dog!🐶" {
println(character) println(character)
} }
// D // D
// o // o
// g // g
// ! // !
// 🐶 // 🐶
``` ```
for-in 循环在 [For Loops](05_Control_Flow.html#for_loops) 中进行了详细描述。 for-in 循环在 [For Loops](05_Control_Flow.html#for_loops) 中进行了详细描述。
另外，通过标明一个`Character`类型注解并通过字符字面量进行赋值，可以建立一个独立的字符常量或变量： 另外，通过标明一个`Character`类型注解并通过字符字面量进行赋值，可以建立一个独立的字符常量或变量：
```swift ```swift
let yenSign: Character = "¥" let yenSign: Character = "¥"
``` ```
<a name="counting_characters"></a> <a name="counting_characters"></a>
## 计算字符数量 (Counting Characters) ## 计算字符数量 (Counting Characters)
通过调用全局`countElements`函数，并将字符串作为参数进行传递，可以获取该字符串的字符数量。 通过调用全局`countElements`函数，并将字符串作为参数进行传递，可以获取该字符串的字符数量。
```swift ```swift
let unusualMenagerie = "Koala 🐨, Snail 🐌, Penguin 🐧, Dromedary 🐪" let unusualMenagerie = "Koala 🐨, Snail 🐌, Penguin 🐧, Dromedary 🐪"
println("unusualMenagerie has \(countElements(unusualMenagerie)) characters") println("unusualMenagerie has \(countElements(unusualMenagerie)) characters")
// 打印输出："unusualMenagerie has 40 characters" // 打印输出："unusualMenagerie has 40 characters"
``` ```
> 注意： > 注意：
不同的 Unicode 字符以及相同 Unicode 字符的不同表示方式可能需要不同数量的内存空间来存储。所以 Swift 中的字符在一个字符串中并不一定占用相同的内存空间。因此字符串的长度不得不通过迭代字符串中每一个字符的长度来进行计算。如果您正在处理一个长字符串，需要注意`countElements`函数必须遍历字符串中的字符以精准计算字符串的长度。 不同的 Unicode 字符以及相同 Unicode 字符的不同表示方式可能需要不同数量的内存空间来存储。所以 Swift 中的字符在一个字符串中并不一定占用相同的内存空间。因此字符串的长度不得不通过迭代字符串中每一个字符的长度来进行计算。如果您正在处理一个长字符串，需要注意`countElements`函数必须遍历字符串中的字符以精准计算字符串的长度。
> 另外需要注意的是通过`countElements`返回的字符数量并不总是与包含相同字符的`NSString`的`length`属性相同。`NSString`的`length`属性是基于利用 UTF-16 表示的十六位代码单元数字，而不是基于 Unicode 字符。为了解决这个问题，`NSString`的`length`属性在被 Swift 的`String`访问时会成为`utf16count`。 > 另外需要注意的是通过`countElements`返回的字符数量并不总是与包含相同字符的`NSString`的`length`属性相同。`NSString`的`length`属性是基于利用 UTF-16 表示的十六位代码单元数字，而不是基于 Unicode 字符。为了解决这个问题，`NSString`的`length`属性在被 Swift 的`String`访问时会成为`utf16count`。
<a name="concatenating_strings_and_characters"></a> <a name="concatenating_strings_and_characters"></a>
## 连接字符串和字符 (Concatenating Strings and Characters) ## 连接字符串和字符 (Concatenating Strings and Characters)
字符串和字符的值可以通过加法运算符（`+`）相加在一起并创建一个新的字符串值： 字符串和字符的值可以通过加法运算符（`+`）相加在一起并创建一个新的字符串值：
```swift ```swift
let string1 = "hello" let string1 = "hello"
let string2 = " there" let string2 = " there"
let character1: Character = "!" let character1: Character = "!"
let character2: Character = "?" let character2: Character = "?"
let stringPlusCharacter = string1 + character1 // 等于 "hello!" let stringPlusCharacter = string1 + character1 // 等于 "hello!"
let stringPlusString = string1 + string2 // 等于 "hello there" let stringPlusString = string1 + string2 // 等于 "hello there"
let characterPlusString = character1 + string1 // 等于 "!hello" let characterPlusString = character1 + string1 // 等于 "!hello"
let characterPlusCharacter = character1 + character2 // 等于 "!?" let characterPlusCharacter = character1 + character2 // 等于 "!?"
``` ```
您也可以通过加法赋值运算符 (`+=`) 将一个字符串或者字符添加到一个已经存在字符串变量上： 您也可以通过加法赋值运算符 (`+=`) 将一个字符串或者字符添加到一个已经存在字符串变量上：
```swift ```swift
var instruction = "look over" var instruction = "look over"
instruction += string2 instruction += string2
// instruction 现在等于 "look over there" // instruction 现在等于 "look over there"
var welcome = "good morning" var welcome = "good morning"
welcome += character1 welcome += character1
// welcome 现在等于 "good morning!" // welcome 现在等于 "good morning!"
``` ```
> 注意： > 注意：
您不能将一个字符串或者字符添加到一个已经存在的字符变量上，因为字符变量只能包含一个字符。 您不能将一个字符串或者字符添加到一个已经存在的字符变量上，因为字符变量只能包含一个字符。
<a name="string_interpolation"></a> <a name="string_interpolation"></a>
## 字符串插值 (String Interpolation) ## 字符串插值 (String Interpolation)
字符串插值是一种构建新字符串的方式，可以在其中包含常量、变量、字面量和表达式。 字符串插值是一种构建新字符串的方式，可以在其中包含常量、变量、字面量和表达式。
您插入的字符串字面量的每一项都被包裹在以反斜线为前缀的圆括号中： 您插入的字符串字面量的每一项都被包裹在以反斜线为前缀的圆括号中：
```swift ```swift
let multiplier = 3 let multiplier = 3
let message = "\(multiplier) 乘以 2.5 是 \(Double(multiplier) * 2.5)" let message = "\(multiplier) 乘以 2.5 是 \(Double(multiplier) * 2.5)"
// message 是 "3 乘以 2.5 是 7.5" // message 是 "3 乘以 2.5 是 7.5"
``` ```
在上面的例子中，`multiplier`作为`\(multiplier)`被插入到一个字符串字面量中。 在上面的例子中，`multiplier`作为`\(multiplier)`被插入到一个字符串字面量中。
当创建字符串执行插值计算时此占位符会被替换为`multiplier`实际的值。 当创建字符串执行插值计算时此占位符会被替换为`multiplier`实际的值。
`multiplier`的值也作为字符串中后面表达式的一部分。 `multiplier`的值也作为字符串中后面表达式的一部分。
该表达式计算`Double(multiplier) * 2.5`的值并将结果 (7.5) 插入到字符串中。 该表达式计算`Double(multiplier) * 2.5`的值并将结果 (7.5) 插入到字符串中。
在这个例子中，表达式写为`\(Double(multiplier) * 2.5)`并包含在字符串字面量中。 在这个例子中，表达式写为`\(Double(multiplier) * 2.5)`并包含在字符串字面量中。
> 注意： > 注意：
插值字符串中写在括号中的表达式不能包含非转义双引号 (`"`) 和反斜杠 (`\`)，并且不能包含回车或换行符。 插值字符串中写在括号中的表达式不能包含非转义双引号 (`"`) 和反斜杠 (`\`)，并且不能包含回车或换行符。
<a name="comparing_strings"></a> <a name="comparing_strings"></a>
## 比较字符串 (Comparing Strings) ## 比较字符串 (Comparing Strings)
Swift 提供了三种方式来比较字符串的值：字符串相等、前缀相等和后缀相等。 Swift 提供了三种方式来比较字符串的值：字符串相等、前缀相等和后缀相等。
<a name="string_equality"></a> <a name="string_equality"></a>
### 字符串相等 (String Equality) ### 字符串相等 (String Equality)
如果两个字符串以同一顺序包含完全相同的字符，则认为两者字符串相等： 如果两个字符串以同一顺序包含完全相同的字符，则认为两者字符串相等：
```swift ```swift
let quotation = "我们是一样一样滴." let quotation = "我们是一样一样滴."
let sameQuotation = "我们是一样一样滴." let sameQuotation = "我们是一样一样滴."
if quotation == sameQuotation { if quotation == sameQuotation {
println("这两个字符串被认为是相同的") println("这两个字符串被认为是相同的")
} }
// 打印输出："这两个字符串被认为是相同的" // 打印输出："这两个字符串被认为是相同的"
``` ```
<a name="prefix_and_suffix_equality"></a> <a name="prefix_and_suffix_equality"></a>
### 前缀/后缀相等 (Prefix and Suffix Equality) ### 前缀/后缀相等 (Prefix and Suffix Equality)
通过调用字符串的`hasPrefix`/`hasSuffix`方法来检查字符串是否拥有特定前缀/后缀。 通过调用字符串的`hasPrefix`/`hasSuffix`方法来检查字符串是否拥有特定前缀/后缀。
两个方法均需要以字符串作为参数传入并传出`Boolean`值。 两个方法均需要以字符串作为参数传入并传出`Boolean`值。
两个方法均执行基本字符串和前缀/后缀字符串之间逐个字符的比较操作。 两个方法均执行基本字符串和前缀/后缀字符串之间逐个字符的比较操作。
下面的例子以一个字符串数组表示莎士比亚话剧《罗密欧与朱丽叶》中前两场的场景位置： 下面的例子以一个字符串数组表示莎士比亚话剧《罗密欧与朱丽叶》中前两场的场景位置：
```swift ```swift
let romeoAndJuliet = [ let romeoAndJuliet = [
"Act 1 Scene 1: Verona, A public place", "Act 1 Scene 1: Verona, A public place",
"Act 1 Scene 2: Capulet's mansion", "Act 1 Scene 2: Capulet's mansion",
"Act 1 Scene 3: A room in Capulet's mansion", "Act 1 Scene 3: A room in Capulet's mansion",
"Act 1 Scene 4: A street outside Capulet's mansion", "Act 1 Scene 4: A street outside Capulet's mansion",
"Act 1 Scene 5: The Great Hall in Capulet's mansion", "Act 1 Scene 5: The Great Hall in Capulet's mansion",
"Act 2 Scene 1: Outside Capulet's mansion", "Act 2 Scene 1: Outside Capulet's mansion",
"Act 2 Scene 2: Capulet's orchard", "Act 2 Scene 2: Capulet's orchard",
"Act 2 Scene 3: Outside Friar Lawrence's cell", "Act 2 Scene 3: Outside Friar Lawrence's cell",
"Act 2 Scene 4: A street in Verona", "Act 2 Scene 4: A street in Verona",
"Act 2 Scene 5: Capulet's mansion", "Act 2 Scene 5: Capulet's mansion",
"Act 2 Scene 6: Friar Lawrence's cell" "Act 2 Scene 6: Friar Lawrence's cell"
] ]
``` ```
您可以利用`hasPrefix`方法来计算话剧中第一幕的场景数： 您可以利用`hasPrefix`方法来计算话剧中第一幕的场景数：
```swift ```swift
var act1SceneCount = 0 var act1SceneCount = 0
for scene in romeoAndJuliet { for scene in romeoAndJuliet {
if scene.hasPrefix("Act 1 ") { if scene.hasPrefix("Act 1 ") {
++act1SceneCount ++act1SceneCount
} }
} }
println("There are \(act1SceneCount) scenes in Act 1") println("There are \(act1SceneCount) scenes in Act 1")
// 打印输出："There are 5 scenes in Act 1" // 打印输出："There are 5 scenes in Act 1"
``` ```
相似地，您可以用`hasSuffix`方法来计算发生在不同地方的场景数： 相似地，您可以用`hasSuffix`方法来计算发生在不同地方的场景数：
```swift ```swift
var mansionCount = 0 var mansionCount = 0
var cellCount = 0 var cellCount = 0
for scene in romeoAndJuliet { for scene in romeoAndJuliet {
if scene.hasSuffix("Capulet's mansion") { if scene.hasSuffix("Capulet's mansion") {
++mansionCount ++mansionCount
} else if scene.hasSuffix("Friar Lawrence's cell") { } else if scene.hasSuffix("Friar Lawrence's cell") {
++cellCount ++cellCount
} }
} }
println("\(mansionCount) mansion scenes; \(cellCount) cell scenes") println("\(mansionCount) mansion scenes; \(cellCount) cell scenes")
// 打印输出："6 mansion scenes; 2 cell scenes” // 打印输出："6 mansion scenes; 2 cell scenes”
``` ```
<a name="uppercase_and_lowercase_strings"></a> <a name="uppercase_and_lowercase_strings"></a>
### 大写和小写字符串（Uppercase and Lowercase Strings） ### 大写和小写字符串（Uppercase and Lowercase Strings）
您可以通过字符串的`uppercaseString`和`lowercaseString`属性来访问大写/小写版本的字符串。 您可以通过字符串的`uppercaseString`和`lowercaseString`属性来访问大写/小写版本的字符串。
```swift ```swift
let normal = "Could you help me, please?" let normal = "Could you help me, please?"
let shouty = normal.uppercaseString let shouty = normal.uppercaseString
// shouty 值为 "COULD YOU HELP ME, PLEASE?" // shouty 值为 "COULD YOU HELP ME, PLEASE?"
let whispered = normal.lowercaseString let whispered = normal.lowercaseString
// whispered 值为 "could you help me, please?" // whispered 值为 "could you help me, please?"
``` ```
<a name="unicode"></a> <a name="unicode"></a>
## Unicode ## Unicode
Unicode 是一个国际标准，用于文本的编码和表示。 Unicode 是一个国际标准，用于文本的编码和表示。
它使您可以用标准格式表示来自任意语言几乎所有的字符，并能够对文本文件或网页这样的外部资源中的字符进行读写操作。 它使您可以用标准格式表示来自任意语言几乎所有的字符，并能够对文本文件或网页这样的外部资源中的字符进行读写操作。
Swift 的字符串和字符类型是完全兼容 Unicode 标准的，它支持如下所述的一系列不同的 Unicode 编码。 Swift 的字符串和字符类型是完全兼容 Unicode 标准的，它支持如下所述的一系列不同的 Unicode 编码。
<a name="unicode_terminology"></a> <a name="unicode_terminology"></a>
### Unicode 术语（Unicode Terminology） ### Unicode 术语（Unicode Terminology）
Unicode 中每一个字符都可以被解释为一个或多个 unicode 标量。 Unicode 中每一个字符都可以被解释为一个或多个 unicode 标量。
字符的 unicode 标量是一个唯一的21位数字(和名称)，例如`U+0061`表示小写的拉丁字母A ("a")，`U+1F425`表示小鸡表情 ("🐥") 字符的 unicode 标量是一个唯一的21位数字(和名称)，例如`U+0061`表示小写的拉丁字母A ("a")，`U+1F425`表示小鸡表情 ("🐥")
当 Unicode 字符串被写进文本文件或其他存储结构当中，这些 unicode 标量将会按照 Unicode 定义的集中格式之一进行编码。其包括`UTF-8`（以8位代码单元进行编码） 和`UTF-16`（以16位代码单元进行编码）。 当 Unicode 字符串被写进文本文件或其他存储结构当中，这些 unicode 标量将会按照 Unicode 定义的集中格式之一进行编码。其包括`UTF-8`（以8位代码单元进行编码） 和`UTF-16`（以16位代码单元进行编码）。
<a name="unicode_representations_of_strings"></a> <a name="unicode_representations_of_strings"></a>
### 字符串的 Unicode 表示（Unicode Representations of Strings） ### 字符串的 Unicode 表示（Unicode Representations of Strings）
Swift 提供了几种不同的方式来访问字符串的 Unicode 表示。 Swift 提供了几种不同的方式来访问字符串的 Unicode 表示。
您可以利用`for-in`来对字符串进行遍历，从而以 Unicode 字符的方式访问每一个字符值。 您可以利用`for-in`来对字符串进行遍历，从而以 Unicode 字符的方式访问每一个字符值。
该过程在 [使用字符](#working_with_characters) 中进行了描述。 该过程在 [使用字符](#working_with_characters) 中进行了描述。
另外，能够以其他三种 Unicode 兼容的方式访问字符串的值： 另外，能够以其他三种 Unicode 兼容的方式访问字符串的值：
* UTF-8 代码单元集合 (利用字符串的`utf8`属性进行访问) * UTF-8 代码单元集合 (利用字符串的`utf8`属性进行访问)
* UTF-16 代码单元集合 (利用字符串的`utf16`属性进行访问) * UTF-16 代码单元集合 (利用字符串的`utf16`属性进行访问)
* 21位的 Unicode 标量值集合 (利用字符串的`unicodeScalars`属性进行访问) * 21位的 Unicode 标量值集合 (利用字符串的`unicodeScalars`属性进行访问)
下面由`D``o``g``!`和`🐶`(`DOG FACE`，Unicode 标量为`U+1F436`)组成的字符串中的每一个字符代表着一种不同的表示： 下面由`D``o``g``!`和`🐶`(`DOG FACE`，Unicode 标量为`U+1F436`)组成的字符串中的每一个字符代表着一种不同的表示：
```swift ```swift
let dogString = "Dog!🐶" let dogString = "Dog!🐶"
``` ```
<a name="UTF-8"></a> <a name="UTF-8"></a>
### UTF-8 ### UTF-8
您可以通过遍历字符串的`utf8`属性来访问它的`UTF-8`表示。 您可以通过遍历字符串的`utf8`属性来访问它的`UTF-8`表示。
其为`UTF8View`类型的属性，`UTF8View`是无符号8位 (`UInt8`) 值的集合，每一个`UInt8`值都是一个字符的 UTF-8 表示： 其为`UTF8View`类型的属性，`UTF8View`是无符号8位 (`UInt8`) 值的集合，每一个`UInt8`值都是一个字符的 UTF-8 表示：
```swift ```swift
for codeUnit in dogString.utf8 { for codeUnit in dogString.utf8 {
print("\(codeUnit) ") print("\(codeUnit) ")
} }
print("\n") print("\n")
// 68 111 103 33 240 159 144 182 // 68 111 103 33 240 159 144 182
``` ```
上面的例子中，前四个10进制代码单元值 (68, 111, 103, 33) 代表了字符`D` `o` `g`和`!`，它们的 UTF-8 表示与 ASCII 表示相同。 上面的例子中，前四个10进制代码单元值 (68, 111, 103, 33) 代表了字符`D` `o` `g`和`!`，它们的 UTF-8 表示与 ASCII 表示相同。
后四个代码单元值 (240, 159, 144, 182) 是`DOG FACE`的4字节 UTF-8 表示。 后四个代码单元值 (240, 159, 144, 182) 是`DOG FACE`的4字节 UTF-8 表示。
<a name="UTF-16"></a> <a name="UTF-16"></a>
### UTF-16 ### UTF-16
您可以通过遍历字符串的`utf16`属性来访问它的`UTF-16`表示。 您可以通过遍历字符串的`utf16`属性来访问它的`UTF-16`表示。
其为`UTF16View`类型的属性，`UTF16View`是无符号16位 (`UInt16`) 值的集合，每一个`UInt16`都是一个字符的 UTF-16 表示： 其为`UTF16View`类型的属性，`UTF16View`是无符号16位 (`UInt16`) 值的集合，每一个`UInt16`都是一个字符的 UTF-16 表示：
```swift ```swift
for codeUnit in dogString.utf16 { for codeUnit in dogString.utf16 {
print("\(codeUnit) ") print("\(codeUnit) ")
} }
print("\n") print("\n")
// 68 111 103 33 55357 56374 // 68 111 103 33 55357 56374
``` ```
同样，前四个代码单元值 (68, 111, 103, 33) 代表了字符`D` `o` `g`和`!`，它们的 UTF-16 代码单元和 UTF-8 完全相同。 同样，前四个代码单元值 (68, 111, 103, 33) 代表了字符`D` `o` `g`和`!`，它们的 UTF-16 代码单元和 UTF-8 完全相同。
第五和第六个代码单元值 (55357 和 56374) 是`DOG FACE`字符的UTF-16 表示。 第五和第六个代码单元值 (55357 和 56374) 是`DOG FACE`字符的UTF-16 表示。
第一个值为`U+D83D`(十进制值为 55357)，第二个值为`U+DC36`(十进制值为 56374)。 第一个值为`U+D83D`(十进制值为 55357)，第二个值为`U+DC36`(十进制值为 56374)。
<a name="unicode_scalars"></a> <a name="unicode_scalars"></a>
### Unicode 标量 (Unicode Scalars) ### Unicode 标量 (Unicode Scalars)
您可以通过遍历字符串的`unicodeScalars`属性来访问它的 Unicode 标量表示。 您可以通过遍历字符串的`unicodeScalars`属性来访问它的 Unicode 标量表示。
其为`UnicodeScalarView`类型的属性， `UnicodeScalarView`是`UnicodeScalar`的集合。 其为`UnicodeScalarView`类型的属性， `UnicodeScalarView`是`UnicodeScalar`的集合。
`UnicodeScalar`是21位的 Unicode 代码点。 `UnicodeScalar`是21位的 Unicode 代码点。
每一个`UnicodeScalar`拥有一个值属性，可以返回对应的21位数值，用`UInt32`来表示。 每一个`UnicodeScalar`拥有一个值属性，可以返回对应的21位数值，用`UInt32`来表示。
```swift ```swift
for scalar in dogString.unicodeScalars { for scalar in dogString.unicodeScalars {
print("\(scalar.value) ") print("\(scalar.value) ")
} }
print("\n") print("\n")
// 68 111 103 33 128054 // 68 111 103 33 128054
``` ```
同样，前四个代码单元值 (68, 111, 103, 33) 代表了字符`D` `o` `g`和`!`。 同样，前四个代码单元值 (68, 111, 103, 33) 代表了字符`D` `o` `g`和`!`。
第五位数值，128054，是一个十六进制1F436的十进制表示。 第五位数值，128054，是一个十六进制1F436的十进制表示。
其等同于`DOG FACE`的Unicode 标量 U+1F436。 其等同于`DOG FACE`的Unicode 标量 U+1F436。
作为查询字符值属性的一种替代方法，每个`UnicodeScalar`值也可以用来构建一个新的字符串值，比如在字符串插值中使用： 作为查询字符值属性的一种替代方法，每个`UnicodeScalar`值也可以用来构建一个新的字符串值，比如在字符串插值中使用：
```swift ```swift
for scalar in dogString.unicodeScalars { for scalar in dogString.unicodeScalars {
println("\(scalar) ") println("\(scalar) ")
} }
// D // D
// o // o
// g // g
// ! // !
// 🐶 // 🐶
``` ```

854
source/chapter2/04_Collection_Types.md
View File

@ -1,428 +1,428 @@
> 翻译：[zqp](https://github.com/zqp) > 翻译：[zqp](https://github.com/zqp)
> 校对：[shinyzhu](https://github.com/shinyzhu), [stanzhai](https://github.com/stanzhai) > 校对：[shinyzhu](https://github.com/shinyzhu), [stanzhai](https://github.com/stanzhai)
# 集合类型 (Collection Types) # 集合类型 (Collection Types)
----------------- -----------------
本页包含内容： 本页包含内容：
- [数组（Arrays）](#arrays) - [数组（Arrays）](#arrays)
- [字典（Dictionaries）](#dictionaries) - [字典（Dictionaries）](#dictionaries)
- [集合的可变性（Mutability of Collections）](#mutability_of_collections) - [集合的可变性（Mutability of Collections）](#mutability_of_collections)
Swift 语言提供经典的数组和字典两种集合类型来存储集合数据。数组用来按顺序存储相同类型的数据。字典虽然无序存储相同类型数据值但是需要由独有的标识符引用和寻址（就是键值对）。 Swift 语言提供经典的数组和字典两种集合类型来存储集合数据。数组用来按顺序存储相同类型的数据。字典虽然无序存储相同类型数据值但是需要由独有的标识符引用和寻址（就是键值对）。
Swift 语言里的数组和字典中存储的数据值类型必须明确。 这意味着我们不能把不正确的数据类型插入其中。 同时这也说明我们完全可以对获取出的值类型非常自信。 Swift 对显式类型集合的使用确保了我们的代码对工作所需要的类型非常清楚，也让我们在开发中可以早早地找到任何的类型不匹配错误。 Swift 语言里的数组和字典中存储的数据值类型必须明确。 这意味着我们不能把不正确的数据类型插入其中。 同时这也说明我们完全可以对获取出的值类型非常自信。 Swift 对显式类型集合的使用确保了我们的代码对工作所需要的类型非常清楚，也让我们在开发中可以早早地找到任何的类型不匹配错误。
> 注意： > 注意：
Swift 的数组结构在被声明成常量和变量或者被传入函数与方法中时会相对于其他类型展现出不同的特性。 获取更多信息请参见[集合的可变性](#mutability_of_collections)与[集合在赋值和复制中的行为](09_Classes_and_Structures.html#assignment_and_copy_behavior_for_collection_types)章节。 Swift 的数组结构在被声明成常量和变量或者被传入函数与方法中时会相对于其他类型展现出不同的特性。 获取更多信息请参见[集合的可变性](#mutability_of_collections)与[集合在赋值和复制中的行为](09_Classes_and_Structures.html#assignment_and_copy_behavior_for_collection_types)章节。
<a name="arrays"></a> <a name="arrays"></a>
## 数组 ## 数组
数组使用有序列表存储同一类型的多个值。相同的值可以多次出现在一个数组的不同位置中。 数组使用有序列表存储同一类型的多个值。相同的值可以多次出现在一个数组的不同位置中。
Swift 数组特定于它所存储元素的类型。这与 Objective-C 的 NSArray 和 NSMutableArray 不同，这两个类可以存储任意类型的对象，并且不提供所返回对象的任何特别信息。在 Swift 中，数据值在被存储进入某个数组之前类型必须明确，方法是通过显式的类型标注或类型推断，而且不是必须是`class`类型。例如： 如果我们创建了一个`Int`值类型的数组，我们不能往其中插入任何不是`Int`类型的数据。 Swift 中的数组是类型安全的，并且它们中包含的类型必须明确。 Swift 数组特定于它所存储元素的类型。这与 Objective-C 的 NSArray 和 NSMutableArray 不同，这两个类可以存储任意类型的对象，并且不提供所返回对象的任何特别信息。在 Swift 中，数据值在被存储进入某个数组之前类型必须明确，方法是通过显式的类型标注或类型推断，而且不是必须是`class`类型。例如： 如果我们创建了一个`Int`值类型的数组，我们不能往其中插入任何不是`Int`类型的数据。 Swift 中的数组是类型安全的，并且它们中包含的类型必须明确。
<a name="array_type_shorthand_syntax"></a> <a name="array_type_shorthand_syntax"></a>
### 数组的简单语法 ### 数组的简单语法
写 Swift 数组应该遵循像`Array<SomeType>`这样的形式，其中`SomeType`是这个数组中唯一允许存在的数据类型。 我们也可以使用像`SomeType[]`这样的简单语法。 尽管两种形式在功能上是一样的，但是推荐较短的那种，而且在本文中都会使用这种形式来使用数组。 写 Swift 数组应该遵循像`Array<SomeType>`这样的形式，其中`SomeType`是这个数组中唯一允许存在的数据类型。 我们也可以使用像`SomeType[]`这样的简单语法。 尽管两种形式在功能上是一样的，但是推荐较短的那种，而且在本文中都会使用这种形式来使用数组。
<a name="array_literals"></a> <a name="array_literals"></a>
### 数组构造语句 ### 数组构造语句
我们可以使用字面量来进行数组构造，这是一种用一个或者多个数值构造数组的简单方法。字面量是一系列由逗号分割并由方括号包含的数值。 我们可以使用字面量来进行数组构造，这是一种用一个或者多个数值构造数组的简单方法。字面量是一系列由逗号分割并由方括号包含的数值。
`[value 1, value 2, value 3]`。 `[value 1, value 2, value 3]`。
下面这个例子创建了一个叫做`shoppingList`并且存储字符串的数组： 下面这个例子创建了一个叫做`shoppingList`并且存储字符串的数组：
```swift ```swift
var shoppingList: String[] = ["Eggs", "Milk"] var shoppingList: String[] = ["Eggs", "Milk"]
// shoppingList 已经被构造并且拥有两个初始项。 // shoppingList 已经被构造并且拥有两个初始项。
``` ```
`shoppingList`变量被声明为“字符串值类型的数组“，记作`String[]`。 因为这个数组被规定只有`String`一种数据结构，所以只有`String`类型可以在其中被存取。 在这里，`shoppinglist`数组由两个`String`值（`"Eggs"` 和`"Milk"`）构造，并且由字面量定义。 `shoppingList`变量被声明为“字符串值类型的数组“，记作`String[]`。 因为这个数组被规定只有`String`一种数据结构，所以只有`String`类型可以在其中被存取。 在这里，`shoppinglist`数组由两个`String`值（`"Eggs"` 和`"Milk"`）构造，并且由字面量定义。
> 注意： > 注意：
> `Shoppinglist`数组被声明为变量（`var`关键字创建）而不是常量（`let`创建）是因为以后可能会有更多的数据项被插入其中。 > `Shoppinglist`数组被声明为变量（`var`关键字创建）而不是常量（`let`创建）是因为以后可能会有更多的数据项被插入其中。
在这个例子中，字面量仅仅包含两个`String`值。匹配了该数组的变量声明（只能包含`String`的数组），所以这个字面量的分配过程就是允许用两个初始项来构造`shoppinglist`。 在这个例子中，字面量仅仅包含两个`String`值。匹配了该数组的变量声明（只能包含`String`的数组），所以这个字面量的分配过程就是允许用两个初始项来构造`shoppinglist`。
由于 Swift 的类型推断机制，当我们用字面量构造只拥有相同类型值数组的时候，我们不必把数组的类型定义清楚。 `shoppinglist`的构造也可以这样写： 由于 Swift 的类型推断机制，当我们用字面量构造只拥有相同类型值数组的时候，我们不必把数组的类型定义清楚。 `shoppinglist`的构造也可以这样写：
```swift ```swift
var shoppingList = ["Eggs", "Milk"] var shoppingList = ["Eggs", "Milk"]
``` ```
因为所有字面量中的值都是相同的类型，Swift 可以推断出`String[]`是`shoppinglist`中变量的正确类型。 因为所有字面量中的值都是相同的类型，Swift 可以推断出`String[]`是`shoppinglist`中变量的正确类型。
<a name="accessing_and_modifying_an_array"></a> <a name="accessing_and_modifying_an_array"></a>
### 访问和修改数组 ### 访问和修改数组
我们可以通过数组的方法和属性来访问和修改数组，或者下标语法。 我们可以通过数组的方法和属性来访问和修改数组，或者下标语法。
还可以使用数组的只读属性`count`来获取数组中的数据项数量。 还可以使用数组的只读属性`count`来获取数组中的数据项数量。
```swift ```swift
println("The shopping list contains \(shoppingList.count) items.") println("The shopping list contains \(shoppingList.count) items.")
// 输出"The shopping list contains 2 items."（这个数组有2个项） // 输出"The shopping list contains 2 items."（这个数组有2个项）
``` ```
使用布尔项`isEmpty`来作为检查`count`属性的值是否为 0 的捷径。 使用布尔项`isEmpty`来作为检查`count`属性的值是否为 0 的捷径。
```swift ```swift
if shoppingList.isEmpty { if shoppingList.isEmpty {
println("The shopping list is empty.") println("The shopping list is empty.")
} else { } else {
println("The shopping list is not empty.") println("The shopping list is not empty.")
} }
// 打印 "The shopping list is not empty."（shoppinglist不是空的） // 打印 "The shopping list is not empty."（shoppinglist不是空的）
``` ```
也可以使用`append`方法在数组后面添加新的数据项： 也可以使用`append`方法在数组后面添加新的数据项：
```swift ```swift
shoppingList.append("Flour") shoppingList.append("Flour")
// shoppingList 现在有3个数据项，有人在摊煎饼 // shoppingList 现在有3个数据项，有人在摊煎饼
``` ```
除此之外，使用加法赋值运算符（`+=`）也可以直接在数组后面添加数据项： 除此之外，使用加法赋值运算符（`+=`）也可以直接在数组后面添加数据项：
```swift ```swift
shoppingList += "Baking Powder" shoppingList += "Baking Powder"
// shoppingList 现在有四项了 // shoppingList 现在有四项了
``` ```
我们也可以使用加法赋值运算符（`+=`）直接添加拥有相同类型数据的数组。 我们也可以使用加法赋值运算符（`+=`）直接添加拥有相同类型数据的数组。
```swift ```swift
shoppingList += ["Chocolate Spread", "Cheese", "Butter"] shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
// shoppingList 现在有7项了 // shoppingList 现在有7项了
``` ```
可以直接使用下标语法来获取数组中的数据项，把我们需要的数据项的索引值放在直接放在数组名称的方括号中： 可以直接使用下标语法来获取数组中的数据项，把我们需要的数据项的索引值放在直接放在数组名称的方括号中：
```swift ```swift
var firstItem = shoppingList[0] var firstItem = shoppingList[0]
// 第一项是 "Eggs" // 第一项是 "Eggs"
``` ```
注意第一项在数组中的索引值是`0`而不是`1`。 Swift 中的数组索引总是从零开始。 注意第一项在数组中的索引值是`0`而不是`1`。 Swift 中的数组索引总是从零开始。
我们也可以用下标来改变某个已有索引值对应的数据值： 我们也可以用下标来改变某个已有索引值对应的数据值：
```swift ```swift
shoppingList[0] = "Six eggs" shoppingList[0] = "Six eggs"
// 其中的第一项现在是 "Six eggs" 而不是 "Eggs" // 其中的第一项现在是 "Six eggs" 而不是 "Eggs"
``` ```
还可以利用下标来一次改变一系列数据值，即使新数据和原有数据的数量是不一样的。下面的例子把`"Chocolate Spread"`，`"Cheese"`，和`"Butter"`替换为`"Bananas"`和 `"Apples"`： 还可以利用下标来一次改变一系列数据值，即使新数据和原有数据的数量是不一样的。下面的例子把`"Chocolate Spread"`，`"Cheese"`，和`"Butter"`替换为`"Bananas"`和 `"Apples"`：
```swift ```swift
shoppingList[4...6] = ["Bananas", "Apples"] shoppingList[4...6] = ["Bananas", "Apples"]
// shoppingList 现在有六项 // shoppingList 现在有六项
``` ```
> 注意： > 注意：
>我们不能使用下标语法在数组尾部添加新项。如果我们试着用这种方法对索引越界的数据进行检索或者设置新值的操作，我们会引发一个运行期错误。我们可以使用索引值和数组的`count`属性进行比较来在使用某个索引之前先检验是否有效。除了当`count`等于 0 时（说明这是个空数组），最大索引值一直是`count - 1`，因为数组都是零起索引。 >我们不能使用下标语法在数组尾部添加新项。如果我们试着用这种方法对索引越界的数据进行检索或者设置新值的操作，我们会引发一个运行期错误。我们可以使用索引值和数组的`count`属性进行比较来在使用某个索引之前先检验是否有效。除了当`count`等于 0 时（说明这是个空数组），最大索引值一直是`count - 1`，因为数组都是零起索引。
调用数组的`insert(atIndex:)`方法来在某个具体索引值之前添加数据项： 调用数组的`insert(atIndex:)`方法来在某个具体索引值之前添加数据项：
```swift ```swift
shoppingList.insert("Maple Syrup", atIndex: 0) shoppingList.insert("Maple Syrup", atIndex: 0)
// shoppingList 现在有7项 // shoppingList 现在有7项
// "Maple Syrup" 现在是这个列表中的第一项 // "Maple Syrup" 现在是这个列表中的第一项
``` ```
这次`insert`函数调用把值为`"Maple Syrup"`的新数据项插入列表的最开始位置，并且使用`0`作为索引值。 这次`insert`函数调用把值为`"Maple Syrup"`的新数据项插入列表的最开始位置，并且使用`0`作为索引值。
类似的我们可以使用`removeAtIndex`方法来移除数组中的某一项。这个方法把数组在特定索引值中存储的数据项移除并且返回这个被移除的数据项（我们不需要的时候就可以无视它）: 类似的我们可以使用`removeAtIndex`方法来移除数组中的某一项。这个方法把数组在特定索引值中存储的数据项移除并且返回这个被移除的数据项（我们不需要的时候就可以无视它）:
```swift ```swift
let mapleSyrup = shoppingList.removeAtIndex(0) let mapleSyrup = shoppingList.removeAtIndex(0)
// 索引值为0的数据项被移除 // 索引值为0的数据项被移除
// shoppingList 现在只有6项，而且不包括Maple Syrup // shoppingList 现在只有6项，而且不包括Maple Syrup
// mapleSyrup常量的值等于被移除数据项的值 "Maple Syrup" // mapleSyrup常量的值等于被移除数据项的值 "Maple Syrup"
``` ```
数据项被移除后数组中的空出项会被自动填补，所以现在索引值为`0`的数据项的值再次等于`"Six eggs"`: 数据项被移除后数组中的空出项会被自动填补，所以现在索引值为`0`的数据项的值再次等于`"Six eggs"`:
```swift ```swift
firstItem = shoppingList[0] firstItem = shoppingList[0]
// firstItem 现在等于 "Six eggs" // firstItem 现在等于 "Six eggs"
``` ```
如果我们只想把数组中的最后一项移除，可以使用`removeLast`方法而不是`removeAtIndex`方法来避免我们需要获取数组的`count`属性。就像后者一样，前者也会返回被移除的数据项： 如果我们只想把数组中的最后一项移除，可以使用`removeLast`方法而不是`removeAtIndex`方法来避免我们需要获取数组的`count`属性。就像后者一样，前者也会返回被移除的数据项：
```swift ```swift
let apples = shoppingList.removeLast() let apples = shoppingList.removeLast()
// 数组的最后一项被移除了 // 数组的最后一项被移除了
// shoppingList现在只有5项，不包括cheese // shoppingList现在只有5项，不包括cheese
// apples 常量的值现在等于"Apples" 字符串 // apples 常量的值现在等于"Apples" 字符串
``` ```
<a name="iterating_over_an_array"></a> <a name="iterating_over_an_array"></a>
### 数组的遍历 ### 数组的遍历
我们可以使用`for-in`循环来遍历所有数组中的数据项： 我们可以使用`for-in`循环来遍历所有数组中的数据项：
```swift ```swift
for item in shoppingList { for item in shoppingList {
println(item) println(item)
} }
// Six eggs // Six eggs
// Milk // Milk
// Flour // Flour
// Baking Powder // Baking Powder
// Bananas // Bananas
``` ```
如果我们同时需要每个数据项的值和索引值，可以使用全局`enumerate`函数来进行数组遍历。`enumerate`返回一个由每一个数据项索引值和数据值组成的元组。我们可以把这个元组分解成临时常量或者变量来进行遍历： 如果我们同时需要每个数据项的值和索引值，可以使用全局`enumerate`函数来进行数组遍历。`enumerate`返回一个由每一个数据项索引值和数据值组成的元组。我们可以把这个元组分解成临时常量或者变量来进行遍历：
```swift ```swift
for (index, value) in enumerate(shoppingList) { for (index, value) in enumerate(shoppingList) {
println("Item \(index + 1): \(value)") println("Item \(index + 1): \(value)")
} }
// Item 1: Six eggs // Item 1: Six eggs
// Item 2: Milk // Item 2: Milk
// Item 3: Flour // Item 3: Flour
// Item 4: Baking Powder // Item 4: Baking Powder
// Item 5: Bananas // Item 5: Bananas
``` ```
更多关于`for-in`循环的介绍请参见[for 循环](05_Control_Flow.html#for_loops)。 更多关于`for-in`循环的介绍请参见[for 循环](05_Control_Flow.html#for_loops)。
<a name="creating_and_initializing_an_array"></a> <a name="creating_and_initializing_an_array"></a>
### 创建并且构造一个数组 ### 创建并且构造一个数组
我们可以使用构造语法来创建一个由特定数据类型构成的空数组： 我们可以使用构造语法来创建一个由特定数据类型构成的空数组：
```swift ```swift
var someInts = Int[]() var someInts = Int[]()
println("someInts is of type Int[] with \(someInts.count) items。") println("someInts is of type Int[] with \(someInts.count) items。")
// 打印 "someInts is of type Int[] with 0 items。"（someInts是0数据项的Int[]数组） // 打印 "someInts is of type Int[] with 0 items。"（someInts是0数据项的Int[]数组）
``` ```
注意`someInts`被设置为一个`Int[]`构造函数的输出所以它的变量类型被定义为`Int[]`。 注意`someInts`被设置为一个`Int[]`构造函数的输出所以它的变量类型被定义为`Int[]`。
除此之外，如果代码上下文中提供了类型信息， 例如一个函数参数或者一个已经定义好类型的常量或者变量，我们可以使用空数组语句创建一个空数组，它的写法很简单：`[]`（一对空方括号）： 除此之外，如果代码上下文中提供了类型信息， 例如一个函数参数或者一个已经定义好类型的常量或者变量，我们可以使用空数组语句创建一个空数组，它的写法很简单：`[]`（一对空方括号）：
```swift ```swift
someInts.append(3) someInts.append(3)
// someInts 现在包含一个INT值 // someInts 现在包含一个INT值
someInts = [] someInts = []
// someInts 现在是空数组，但是仍然是Int[]类型的。 // someInts 现在是空数组，但是仍然是Int[]类型的。
``` ```
Swift 中的`Array`类型还提供一个可以创建特定大小并且所有数据都被默认的构造方法。我们可以把准备加入新数组的数据项数量（`count`）和适当类型的初始值（`repeatedValue`）传入数组构造函数： Swift 中的`Array`类型还提供一个可以创建特定大小并且所有数据都被默认的构造方法。我们可以把准备加入新数组的数据项数量（`count`）和适当类型的初始值（`repeatedValue`）传入数组构造函数：
```swift ```swift
var threeDoubles = Double[](count: 3, repeatedValue:0.0) var threeDoubles = Double[](count: 3, repeatedValue:0.0)
// threeDoubles 是一种 Double[]数组, 等于 [0.0, 0.0, 0.0] // threeDoubles 是一种 Double[]数组, 等于 [0.0, 0.0, 0.0]
``` ```
因为类型推断的存在，我们使用这种构造方法的时候不需要特别指定数组中存储的数据类型，因为类型可以从默认值推断出来： 因为类型推断的存在，我们使用这种构造方法的时候不需要特别指定数组中存储的数据类型，因为类型可以从默认值推断出来：
```swift ```swift
var anotherThreeDoubles = Array(count: 3, repeatedValue: 2.5) var anotherThreeDoubles = Array(count: 3, repeatedValue: 2.5)
// anotherThreeDoubles is inferred as Double[], and equals [2.5, 2.5, 2.5] // anotherThreeDoubles is inferred as Double[], and equals [2.5, 2.5, 2.5]
``` ```
最后，我们可以使用加法操作符（`+`）来组合两种已存在的相同类型数组。新数组的数据类型会被从两个数组的数据类型中推断出来： 最后，我们可以使用加法操作符（`+`）来组合两种已存在的相同类型数组。新数组的数据类型会被从两个数组的数据类型中推断出来：
```swift ```swift
var sixDoubles = threeDoubles + anotherThreeDoubles var sixDoubles = threeDoubles + anotherThreeDoubles
// sixDoubles 被推断为 Double[], 等于 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5] // sixDoubles 被推断为 Double[], 等于 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]
``` ```
<a name="dictionaries"></a> <a name="dictionaries"></a>
## 字典 ## 字典
字典是一种存储多个相同类型的值的容器。每个值（value）都关联唯一的键（key），键作为字典中的这个值数据的标识符。和数组中的数据项不同，字典中的数据项并没有具体顺序。我们在需要通过标识符（键）访问数据的时候使用字典，这种方法很大程度上和我们在现实世界中使用字典查字义的方法一样。 字典是一种存储多个相同类型的值的容器。每个值（value）都关联唯一的键（key），键作为字典中的这个值数据的标识符。和数组中的数据项不同，字典中的数据项并没有具体顺序。我们在需要通过标识符（键）访问数据的时候使用字典，这种方法很大程度上和我们在现实世界中使用字典查字义的方法一样。
Swift 的字典使用时需要具体规定可以存储键和值类型。不同于 Objective-C 的`NSDictionary`和`NSMutableDictionary` 类可以使用任何类型的对象来作键和值并且不提供任何关于这些对象的本质信息。在 Swift 中，在某个特定字典中可以存储的键和值必须提前定义清楚，方法是通过显性类型标注或者类型推断。 Swift 的字典使用时需要具体规定可以存储键和值类型。不同于 Objective-C 的`NSDictionary`和`NSMutableDictionary` 类可以使用任何类型的对象来作键和值并且不提供任何关于这些对象的本质信息。在 Swift 中，在某个特定字典中可以存储的键和值必须提前定义清楚，方法是通过显性类型标注或者类型推断。
Swift 的字典使用`Dictionary<KeyType, ValueType>`定义,其中`KeyType`是字典中键的数据类型，`ValueType`是字典中对应于这些键所存储值的数据类型。 Swift 的字典使用`Dictionary<KeyType, ValueType>`定义,其中`KeyType`是字典中键的数据类型，`ValueType`是字典中对应于这些键所存储值的数据类型。
`KeyType`的唯一限制就是可哈希的，这样可以保证它是独一无二的，所有的 Swift 基本类型（例如`String`，`Int`， `Double`和`Bool`）都是默认可哈希的，并且所有这些类型都可以在字典中当做键使用。未关联值的枚举成员（参见[枚举](08_Enumerations.html)）也是默认可哈希的。 `KeyType`的唯一限制就是可哈希的，这样可以保证它是独一无二的，所有的 Swift 基本类型（例如`String`，`Int`， `Double`和`Bool`）都是默认可哈希的，并且所有这些类型都可以在字典中当做键使用。未关联值的枚举成员（参见[枚举](08_Enumerations.html)）也是默认可哈希的。
<a name="dictionary_literals"></a> <a name="dictionary_literals"></a>
## 字典字面量 ## 字典字面量
我们可以使用字典字面量来构造字典，它们和我们刚才介绍过的数组字面量拥有相似语法。一个字典字面量是一个定义拥有一个或者多个键值对的字典集合的简单语句。 我们可以使用字典字面量来构造字典，它们和我们刚才介绍过的数组字面量拥有相似语法。一个字典字面量是一个定义拥有一个或者多个键值对的字典集合的简单语句。
一个键值对是一个`key`和一个`value`的结合体。在字典字面量中，每一个键值对的键和值都由冒号分割。这些键值对构成一个列表，其中这些键值对由方括号包含并且由逗号分割： 一个键值对是一个`key`和一个`value`的结合体。在字典字面量中，每一个键值对的键和值都由冒号分割。这些键值对构成一个列表，其中这些键值对由方括号包含并且由逗号分割：
```swift ```swift
[key 1: value 1, key 2: value 2, key 3: value 3] [key 1: value 1, key 2: value 2, key 3: value 3]
``` ```
下面的例子创建了一个存储国际机场名称的字典。在这个字典中键是三个字母的国际航空运输相关代码，值是机场名称： 下面的例子创建了一个存储国际机场名称的字典。在这个字典中键是三个字母的国际航空运输相关代码，值是机场名称：
```swift ```swift
var airports: Dictionary<String, String> = ["TYO": "Tokyo", "DUB": "Dublin"] var airports: Dictionary<String, String> = ["TYO": "Tokyo", "DUB": "Dublin"]
``` ```
`airports`字典被定义为一种`Dictionary<String, String>`,它意味着这个字典的键和值都是`String`类型。 `airports`字典被定义为一种`Dictionary<String, String>`,它意味着这个字典的键和值都是`String`类型。
> 注意： > 注意：
> `airports`字典被声明为变量（用`var`关键字）而不是常量（`let`关键字）因为后来更多的机场信息会被添加到这个示例字典中。 > `airports`字典被声明为变量（用`var`关键字）而不是常量（`let`关键字）因为后来更多的机场信息会被添加到这个示例字典中。
`airports`字典使用字典字面量初始化，包含两个键值对。第一对的键是`TYO`，值是`Tokyo`。第二对的键是`DUB`，值是`Dublin`。 `airports`字典使用字典字面量初始化，包含两个键值对。第一对的键是`TYO`，值是`Tokyo`。第二对的键是`DUB`，值是`Dublin`。
这个字典语句包含了两个`String: String`类型的键值对。它们对应`airports`变量声明的类型（一个只有`String`键和`String`值的字典）所以这个字典字面量是构造两个初始数据项的`airport`字典。 这个字典语句包含了两个`String: String`类型的键值对。它们对应`airports`变量声明的类型（一个只有`String`键和`String`值的字典）所以这个字典字面量是构造两个初始数据项的`airport`字典。
和数组一样，如果我们使用字面量构造字典就不用把类型定义清楚。`airports`的也可以用这种方法简短定义： 和数组一样，如果我们使用字面量构造字典就不用把类型定义清楚。`airports`的也可以用这种方法简短定义：
```swift ```swift
var airports = ["TYO": "Tokyo", "DUB": "Dublin"] var airports = ["TYO": "Tokyo", "DUB": "Dublin"]
``` ```
因为这个语句中所有的键和值都分别是相同的数据类型，Swift 可以推断出`Dictionary<String, String>`是`airports`字典的正确类型。 因为这个语句中所有的键和值都分别是相同的数据类型，Swift 可以推断出`Dictionary<String, String>`是`airports`字典的正确类型。
<a name="accessing_and_modifying_a_dictionary"></a> <a name="accessing_and_modifying_a_dictionary"></a>
### 读取和修改字典 ### 读取和修改字典
我们可以通过字典的方法和属性来读取和修改字典，或者使用下标语法。和数组一样，我们可以通过字典的只读属性`count`来获取某个字典的数据项数量： 我们可以通过字典的方法和属性来读取和修改字典，或者使用下标语法。和数组一样，我们可以通过字典的只读属性`count`来获取某个字典的数据项数量：
```swift ```swift
println("The dictionary of airports contains \(airports.count) items.") println("The dictionary of airports contains \(airports.count) items.")
// 打印 "The dictionary of airports contains 2 items."（这个字典有两个数据项） // 打印 "The dictionary of airports contains 2 items."（这个字典有两个数据项）
``` ```
我们也可以在字典中使用下标语法来添加新的数据项。可以使用一个合适类型的 key 作为下标索引，并且分配新的合适类型的值： 我们也可以在字典中使用下标语法来添加新的数据项。可以使用一个合适类型的 key 作为下标索引，并且分配新的合适类型的值：
```swift ```swift
airports["LHR"] = "London" airports["LHR"] = "London"
// airports 字典现在有三个数据项 // airports 字典现在有三个数据项
``` ```
我们也可以使用下标语法来改变特定键对应的值： 我们也可以使用下标语法来改变特定键对应的值：
```swift ```swift
airports["LHR"] = "London Heathrow" airports["LHR"] = "London Heathrow"
// "LHR"对应的值 被改为 "London Heathrow // "LHR"对应的值 被改为 "London Heathrow
``` ```
作为另一种下标方法，字典的`updateValue(forKey:)`方法可以设置或者更新特定键对应的值。就像上面所示的示例，`updateValue(forKey:)`方法在这个键不存在对应值的时候设置值或者在存在时更新已存在的值。和上面的下标方法不一样，这个方法返回更新值之前的原值。这样方便我们检查更新是否成功。 作为另一种下标方法，字典的`updateValue(forKey:)`方法可以设置或者更新特定键对应的值。就像上面所示的示例，`updateValue(forKey:)`方法在这个键不存在对应值的时候设置值或者在存在时更新已存在的值。和上面的下标方法不一样，这个方法返回更新值之前的原值。这样方便我们检查更新是否成功。
`updateValue(forKey:)`函数会返回包含一个字典值类型的可选值。举例来说：对于存储`String`值的字典，这个函数会返回一个`String?`或者“可选 `String`”类型的值。如果值存在，则这个可选值值等于被替换的值，否则将会是`nil`。 `updateValue(forKey:)`函数会返回包含一个字典值类型的可选值。举例来说：对于存储`String`值的字典，这个函数会返回一个`String?`或者“可选 `String`”类型的值。如果值存在，则这个可选值值等于被替换的值，否则将会是`nil`。
```swift ```swift
if let oldValue = airports.updateValue("Dublin Internation", forKey: "DUB") { if let oldValue = airports.updateValue("Dublin Internation", forKey: "DUB") {
println("The old value for DUB was \(oldValue).") println("The old value for DUB was \(oldValue).")
} }
// 输出 "The old value for DUB was Dublin."（DUB原值是dublin） // 输出 "The old value for DUB was Dublin."（DUB原值是dublin）
``` ```
我们也可以使用下标语法来在字典中检索特定键对应的值。由于使用一个没有值的键这种情况是有可能发生的，可选类型返回这个键存在的相关值，否则就返回`nil`： 我们也可以使用下标语法来在字典中检索特定键对应的值。由于使用一个没有值的键这种情况是有可能发生的，可选类型返回这个键存在的相关值，否则就返回`nil`：
```swift ```swift
if let airportName = airports["DUB"] { if let airportName = airports["DUB"] {
println("The name of the airport is \(airportName).") println("The name of the airport is \(airportName).")
} else { } else {
println("That airport is not in the airports dictionary.") println("That airport is not in the airports dictionary.")
} }
// 打印 "The name of the airport is Dublin Internation."（机场的名字是都柏林国际） // 打印 "The name of the airport is Dublin Internation."（机场的名字是都柏林国际）
``` ```
我们还可以使用下标语法来通过给某个键的对应值赋值为`nil`来从字典里移除一个键值对： 我们还可以使用下标语法来通过给某个键的对应值赋值为`nil`来从字典里移除一个键值对：
```swift ```swift
airports["APL"] = "Apple Internation" airports["APL"] = "Apple Internation"
// "Apple Internation"不是真的 APL机场, 删除它 // "Apple Internation"不是真的 APL机场, 删除它
airports["APL"] = nil airports["APL"] = nil
// APL现在被移除了 // APL现在被移除了
``` ```
另外，`removeValueForKey`方法也可以用来在字典中移除键值对。这个方法在键值对存在的情况下会移除该键值对并且返回被移除的value或者在没有值的情况下返回`nil`： 另外，`removeValueForKey`方法也可以用来在字典中移除键值对。这个方法在键值对存在的情况下会移除该键值对并且返回被移除的value或者在没有值的情况下返回`nil`：
```swift ```swift
if let removedValue = airports.removeValueForKey("DUB") { if let removedValue = airports.removeValueForKey("DUB") {
println("The removed airport's name is \(removedValue).") println("The removed airport's name is \(removedValue).")
} else { } else {
println("The airports dictionary does not contain a value for DUB.") println("The airports dictionary does not contain a value for DUB.")
} }
// prints "The removed airport's name is Dublin International." // prints "The removed airport's name is Dublin International."
``` ```
<a name="iterating_over_a_dictionary"></a> <a name="iterating_over_a_dictionary"></a>
### 字典遍历 ### 字典遍历
我们可以使用`for-in`循环来遍历某个字典中的键值对。每一个字典中的数据项都由`(key, value)`元组形式返回，并且我们可以使用临时常量或者变量来分解这些元组： 我们可以使用`for-in`循环来遍历某个字典中的键值对。每一个字典中的数据项都由`(key, value)`元组形式返回，并且我们可以使用临时常量或者变量来分解这些元组：
```swift ```swift
for (airportCode, airportName) in airports { for (airportCode, airportName) in airports {
println("\(airportCode): \(airportName)") println("\(airportCode): \(airportName)")
} }
// TYO: Tokyo // TYO: Tokyo
// LHR: London Heathrow // LHR: London Heathrow
``` ```
`for-in`循环请参见[For 循环](05_Control_Flow.html#for_loops)。 `for-in`循环请参见[For 循环](05_Control_Flow.html#for_loops)。
我们也可以通过访问它的`keys`或者`values`属性（都是可遍历集合）检索一个字典的键或者值： 我们也可以通过访问它的`keys`或者`values`属性（都是可遍历集合）检索一个字典的键或者值：
```swift ```swift
for airportCode in airports.keys { for airportCode in airports.keys {
println("Airport code: \(airportCode)") println("Airport code: \(airportCode)")
} }
// Airport code: TYO // Airport code: TYO
// Airport code: LHR // Airport code: LHR
for airportName in airports.values { for airportName in airports.values {
println("Airport name: \(airportName)") println("Airport name: \(airportName)")
} }
// Airport name: Tokyo // Airport name: Tokyo
// Airport name: London Heathrow // Airport name: London Heathrow
``` ```
如果我们只是需要使用某个字典的键集合或者值集合来作为某个接受`Array`实例 API 的参数，可以直接使用`keys`或者`values`属性直接构造一个新数组： 如果我们只是需要使用某个字典的键集合或者值集合来作为某个接受`Array`实例 API 的参数，可以直接使用`keys`或者`values`属性直接构造一个新数组：
```swift ```swift
let airportCodes = Array(airports.keys) let airportCodes = Array(airports.keys)
// airportCodes is ["TYO", "LHR"] // airportCodes is ["TYO", "LHR"]
let airportNames = Array(airports.values) let airportNames = Array(airports.values)
// airportNames is ["Tokyo", "London Heathrow"] // airportNames is ["Tokyo", "London Heathrow"]
``` ```
> 注意： > 注意：
> Swift 的字典类型是无序集合类型。其中字典键，值，键值对在遍历的时候会重新排列，而且其中顺序是不固定的。 > Swift 的字典类型是无序集合类型。其中字典键，值，键值对在遍历的时候会重新排列，而且其中顺序是不固定的。
<a name="creating_an_empty_dictionary"></a> <a name="creating_an_empty_dictionary"></a>
### 创建一个空字典 ### 创建一个空字典
我们可以像数组一样使用构造语法创建一个空字典： 我们可以像数组一样使用构造语法创建一个空字典：
```swift ```swift
var namesOfIntegers = Dictionary<Int, String>() var namesOfIntegers = Dictionary<Int, String>()
// namesOfIntegers 是一个空的 Dictionary<Int, String> // namesOfIntegers 是一个空的 Dictionary<Int, String>
``` ```
这个例子创建了一个`Int, String`类型的空字典来储存英语对整数的命名。它的键是`Int`型，值是`String`型。 这个例子创建了一个`Int, String`类型的空字典来储存英语对整数的命名。它的键是`Int`型，值是`String`型。
如果上下文已经提供了信息类型，我们可以使用空字典字面量来创建一个空字典，记作`[:]`（中括号中放一个冒号）： 如果上下文已经提供了信息类型，我们可以使用空字典字面量来创建一个空字典，记作`[:]`（中括号中放一个冒号）：
```swift ```swift
namesOfIntegers[16] = "sixteen" namesOfIntegers[16] = "sixteen"
// namesOfIntegers 现在包含一个键值对 // namesOfIntegers 现在包含一个键值对
namesOfIntegers = [:] namesOfIntegers = [:]
// namesOfIntegers 又成为了一个 Int, String类型的空字典 // namesOfIntegers 又成为了一个 Int, String类型的空字典
``` ```
> 注意： > 注意：
> 在后台，Swift 的数组和字典都是由泛型集合来实现的，想了解更多泛型和集合信息请参见[泛型](22_Generics.html)。 > 在后台，Swift 的数组和字典都是由泛型集合来实现的，想了解更多泛型和集合信息请参见[泛型](22_Generics.html)。
<a name="mutability_of_collections"></a> <a name="mutability_of_collections"></a>
## 集合的可变性 ## 集合的可变性
数组和字典都是在单个集合中存储可变值。如果我们创建一个数组或者字典并且把它分配成一个变量，这个集合将会是可变的。这意味着我们可以在创建之后添加更多或移除已存在的数据项来改变这个集合的大小。与此相反，如果我们把数组或字典分配成常量，那么它就是不可变的，它的大小不能被改变。 数组和字典都是在单个集合中存储可变值。如果我们创建一个数组或者字典并且把它分配成一个变量，这个集合将会是可变的。这意味着我们可以在创建之后添加更多或移除已存在的数据项来改变这个集合的大小。与此相反，如果我们把数组或字典分配成常量，那么它就是不可变的，它的大小不能被改变。
对字典来说，不可变性也意味着我们不能替换其中任何现有键所对应的值。不可变字典的内容在被首次设定之后不能更改。 对字典来说，不可变性也意味着我们不能替换其中任何现有键所对应的值。不可变字典的内容在被首次设定之后不能更改。
不可变性对数组来说有一点不同，当然我们不能试着改变任何不可变数组的大小，但是我们可以重新设定相对现存索引所对应的值。这使得 Swift 数组在大小被固定的时候依然可以做的很棒。 不可变性对数组来说有一点不同，当然我们不能试着改变任何不可变数组的大小，但是我们可以重新设定相对现存索引所对应的值。这使得 Swift 数组在大小被固定的时候依然可以做的很棒。
Swift 数组的可变性行为同时影响了数组实例如何被分配和修改，想获取更多信息，请参见[集合在赋值和复制中的行为](09_Classes_and_Structures.html#assignment_and_copy_behavior_for_collection_types)。 Swift 数组的可变性行为同时影响了数组实例如何被分配和修改，想获取更多信息，请参见[集合在赋值和复制中的行为](09_Classes_and_Structures.html#assignment_and_copy_behavior_for_collection_types)。
> 注意： > 注意：
> 在我们不需要改变数组大小的时候创建不可变数组是很好的习惯。如此 Swift 编译器可以优化我们创建的集合。 > 在我们不需要改变数组大小的时候创建不可变数组是很好的习惯。如此 Swift 编译器可以优化我们创建的集合。

1452
source/chapter2/05_Control_Flow.md
View File

File diff suppressed because it is too large Load Diff

1146
source/chapter2/06_Functions.md
View File

File diff suppressed because it is too large Load Diff

750
source/chapter2/07_Closures.md
View File

@ -1,375 +1,375 @@
> 翻译：[wh1100717](https://github.com/wh1100717) > 翻译：[wh1100717](https://github.com/wh1100717)
> 校对：[lyuka](https://github.com/lyuka) > 校对：[lyuka](https://github.com/lyuka)
# 闭包（Closures） # 闭包（Closures）
----------------- -----------------
本页包含内容： 本页包含内容：
- [闭包表达式（Closure Expressions）](#closure_expressions) - [闭包表达式（Closure Expressions）](#closure_expressions)
- [尾随闭包（Trailing Closures）](#trailing_closures) - [尾随闭包（Trailing Closures）](#trailing_closures)
- [值捕获（Capturing Values）](#capturing_values) - [值捕获（Capturing Values）](#capturing_values)
- [闭包是引用类型（Closures Are Reference Types）](#closures_are_reference_types) - [闭包是引用类型（Closures Are Reference Types）](#closures_are_reference_types)
闭包是自包含的函数代码块，可以在代码中被传递和使用。 闭包是自包含的函数代码块，可以在代码中被传递和使用。
Swift 中的闭包与 C 和 Objective-C 中的代码块（blocks）以及其他一些编程语言中的 lambdas 函数比较相似。 Swift 中的闭包与 C 和 Objective-C 中的代码块（blocks）以及其他一些编程语言中的 lambdas 函数比较相似。
闭包可以捕获和存储其所在上下文中任意常量和变量的引用。 闭包可以捕获和存储其所在上下文中任意常量和变量的引用。
这就是所谓的闭合并包裹着这些常量和变量，俗称闭包。Swift 会为您管理在捕获过程中涉及到的所有内存操作。 这就是所谓的闭合并包裹着这些常量和变量，俗称闭包。Swift 会为您管理在捕获过程中涉及到的所有内存操作。
> 注意： > 注意：
> 如果您不熟悉捕获（capturing）这个概念也不用担心，您可以在 [值捕获](#capturing_values) 章节对其进行详细了解。 > 如果您不熟悉捕获（capturing）这个概念也不用担心，您可以在 [值捕获](#capturing_values) 章节对其进行详细了解。
在[函数](../chapter2/06_Functions.html) 章节中介绍的全局和嵌套函数实际上也是特殊的闭包，闭包采取如下三种形式之一： 在[函数](../chapter2/06_Functions.html) 章节中介绍的全局和嵌套函数实际上也是特殊的闭包，闭包采取如下三种形式之一：
* 全局函数是一个有名字但不会捕获任何值的闭包 * 全局函数是一个有名字但不会捕获任何值的闭包
* 嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包 * 嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
* 闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的匿名闭包 * 闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的匿名闭包
Swift 的闭包表达式拥有简洁的风格，并鼓励在常见场景中进行语法优化，主要优化如下： Swift 的闭包表达式拥有简洁的风格，并鼓励在常见场景中进行语法优化，主要优化如下：
* 利用上下文推断参数和返回值类型 * 利用上下文推断参数和返回值类型
* 隐式返回单表达式闭包，即单表达式闭包可以省略`return`关键字 * 隐式返回单表达式闭包，即单表达式闭包可以省略`return`关键字
* 参数名称缩写 * 参数名称缩写
* 尾随（Trailing）闭包语法 * 尾随（Trailing）闭包语法
<a name="closure_expressions"></a> <a name="closure_expressions"></a>
## 闭包表达式（Closure Expressions） ## 闭包表达式（Closure Expressions）
[嵌套函数](../chapter2/06_Functions.html#nested_function) 是一个在较复杂函数中方便进行命名和定义自包含代码模块的方式。当然，有时候撰写小巧的没有完整定义和命名的类函数结构也是很有用处的，尤其是在您处理一些函数并需要将另外一些函数作为该函数的参数时。 [嵌套函数](../chapter2/06_Functions.html#nested_function) 是一个在较复杂函数中方便进行命名和定义自包含代码模块的方式。当然，有时候撰写小巧的没有完整定义和命名的类函数结构也是很有用处的，尤其是在您处理一些函数并需要将另外一些函数作为该函数的参数时。
闭包表达式是一种利用简洁语法构建内联闭包的方式。 闭包表达式是一种利用简洁语法构建内联闭包的方式。
闭包表达式提供了一些语法优化，使得撰写闭包变得简单明了。 闭包表达式提供了一些语法优化，使得撰写闭包变得简单明了。
下面闭包表达式的例子通过使用几次迭代展示了`sort`函数定义和语法优化的方式。 下面闭包表达式的例子通过使用几次迭代展示了`sort`函数定义和语法优化的方式。
每一次迭代都用更简洁的方式描述了相同的功能。 每一次迭代都用更简洁的方式描述了相同的功能。
<a name="the_sort_function"></a> <a name="the_sort_function"></a>
### sort 函数（The Sort Function） ### sort 函数（The Sort Function）
Swift 标准库提供了`sort`函数，会根据您提供的基于输出类型排序的闭包函数将已知类型数组中的值进行排序。 Swift 标准库提供了`sort`函数，会根据您提供的基于输出类型排序的闭包函数将已知类型数组中的值进行排序。
一旦排序完成，函数会返回一个与原数组大小相同的新数组，该数组中包含已经正确排序的同类型元素。 一旦排序完成，函数会返回一个与原数组大小相同的新数组，该数组中包含已经正确排序的同类型元素。
下面的闭包表达式示例使用`sort`函数对一个`String`类型的数组进行字母逆序排序，以下是初始数组值： 下面的闭包表达式示例使用`sort`函数对一个`String`类型的数组进行字母逆序排序，以下是初始数组值：
```swift ```swift
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"] let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
``` ```
`sort`函数需要传入两个参数： `sort`函数需要传入两个参数：
* 已知类型的数组 * 已知类型的数组
* 闭包函数，该闭包函数需要传入与数组类型相同的两个值，并返回一个布尔类型值来告诉`sort`函数当排序结束后传入的第一个参数排在第二个参数前面还是后面。如果第一个参数值出现在第二个参数值前面，排序闭包函数需要返回`true`，反之返回`false`。 * 闭包函数，该闭包函数需要传入与数组类型相同的两个值，并返回一个布尔类型值来告诉`sort`函数当排序结束后传入的第一个参数排在第二个参数前面还是后面。如果第一个参数值出现在第二个参数值前面，排序闭包函数需要返回`true`，反之返回`false`。
该例子对一个`String`类型的数组进行排序，因此排序闭包函数类型需为`(String, String) -> Bool`。 该例子对一个`String`类型的数组进行排序，因此排序闭包函数类型需为`(String, String) -> Bool`。
提供排序闭包函数的一种方式是撰写一个符合其类型要求的普通函数，并将其作为`sort`函数的第二个参数传入： 提供排序闭包函数的一种方式是撰写一个符合其类型要求的普通函数，并将其作为`sort`函数的第二个参数传入：
```swift ```swift
func backwards(s1: String, s2: String) -> Bool { func backwards(s1: String, s2: String) -> Bool {
return s1 > s2 return s1 > s2
} }
var reversed = sort(names, backwards) var reversed = sort(names, backwards)
// reversed 为 ["Ewa", "Daniella", "Chris", "Barry", "Alex"] // reversed 为 ["Ewa", "Daniella", "Chris", "Barry", "Alex"]
``` ```
如果第一个字符串 (`s1`) 大于第二个字符串 (`s2`)，`backwards`函数返回`true`，表示在新的数组中`s1`应该出现在`s2`前。 如果第一个字符串 (`s1`) 大于第二个字符串 (`s2`)，`backwards`函数返回`true`，表示在新的数组中`s1`应该出现在`s2`前。
对于字符串中的字符来说，“大于” 表示 “按照字母顺序较晚出现”。 对于字符串中的字符来说，“大于” 表示 “按照字母顺序较晚出现”。
这意味着字母`"B"`大于字母`"A"`，字符串`"Tom"`大于字符串`"Tim"`。 这意味着字母`"B"`大于字母`"A"`，字符串`"Tom"`大于字符串`"Tim"`。
其将进行字母逆序排序，`"Barry"`将会排在`"Alex"`之后。 其将进行字母逆序排序，`"Barry"`将会排在`"Alex"`之后。
然而，这是一个相当冗长的方式，本质上只是写了一个单表达式函数 (a > b)。 然而，这是一个相当冗长的方式，本质上只是写了一个单表达式函数 (a > b)。
在下面的例子中，利用闭合表达式语法可以更好的构造一个内联排序闭包。 在下面的例子中，利用闭合表达式语法可以更好的构造一个内联排序闭包。
<a name="closure_expression_syntax"></a> <a name="closure_expression_syntax"></a>
### 闭包表达式语法（Closure Expression Syntax） ### 闭包表达式语法（Closure Expression Syntax）
闭包表达式语法有如下一般形式： 闭包表达式语法有如下一般形式：
```swift ```swift
{ (parameters) -> returnType in { (parameters) -> returnType in
statements statements
} }
``` ```
闭包表达式语法可以使用常量、变量和`inout`类型作为参数，不提供默认值。 闭包表达式语法可以使用常量、变量和`inout`类型作为参数，不提供默认值。
也可以在参数列表的最后使用可变参数。 也可以在参数列表的最后使用可变参数。
元组也可以作为参数和返回值。 元组也可以作为参数和返回值。
下面的例子展示了之前`backwards`函数对应的闭包表达式版本的代码： 下面的例子展示了之前`backwards`函数对应的闭包表达式版本的代码：
```swift ```swift
reversed = sort(names, { (s1: String, s2: String) -> Bool in reversed = sort(names, { (s1: String, s2: String) -> Bool in
return s1 > s2 return s1 > s2
}) })
``` ```
需要注意的是内联闭包参数和返回值类型声明与`backwards`函数类型声明相同。 需要注意的是内联闭包参数和返回值类型声明与`backwards`函数类型声明相同。
在这两种方式中，都写成了`(s1: String, s2: String) -> Bool`。 在这两种方式中，都写成了`(s1: String, s2: String) -> Bool`。
然而在内联闭包表达式中，函数和返回值类型都写在大括号内，而不是大括号外。 然而在内联闭包表达式中，函数和返回值类型都写在大括号内，而不是大括号外。
闭包的函数体部分由关键字`in`引入。 闭包的函数体部分由关键字`in`引入。
该关键字表示闭包的参数和返回值类型定义已经完成，闭包函数体即将开始。 该关键字表示闭包的参数和返回值类型定义已经完成，闭包函数体即将开始。
因为这个闭包的函数体部分如此短以至于可以将其改写成一行代码： 因为这个闭包的函数体部分如此短以至于可以将其改写成一行代码：
```swift ```swift
reversed = sort(names, { (s1: String, s2: String) -> Bool in return s1 > s2 } ) reversed = sort(names, { (s1: String, s2: String) -> Bool in return s1 > s2 } )
``` ```
这说明`sort`函数的整体调用保持不变，一对圆括号仍然包裹住了函数中整个参数集合。而其中一个参数现在变成了内联闭包（相比于`backwards`版本的代码）。 这说明`sort`函数的整体调用保持不变，一对圆括号仍然包裹住了函数中整个参数集合。而其中一个参数现在变成了内联闭包（相比于`backwards`版本的代码）。
<a name="inferring_type_from_context"></a> <a name="inferring_type_from_context"></a>
### 根据上下文推断类型（Inferring Type From Context） ### 根据上下文推断类型（Inferring Type From Context）
因为排序闭包函数是作为`sort`函数的参数进行传入的，Swift可以推断其参数和返回值的类型。 因为排序闭包函数是作为`sort`函数的参数进行传入的，Swift可以推断其参数和返回值的类型。
`sort`期望第二个参数是类型为`(String, String) -> Bool`的函数，因此实际上`String`,`String`和`Bool`类型并不需要作为闭包表达式定义中的一部分。 `sort`期望第二个参数是类型为`(String, String) -> Bool`的函数，因此实际上`String`,`String`和`Bool`类型并不需要作为闭包表达式定义中的一部分。
因为所有的类型都可以被正确推断，返回箭头 (`->`) 和围绕在参数周围的括号也可以被省略： 因为所有的类型都可以被正确推断，返回箭头 (`->`) 和围绕在参数周围的括号也可以被省略：
```swift ```swift
reversed = sort(names, { s1, s2 in return s1 > s2 } ) reversed = sort(names, { s1, s2 in return s1 > s2 } )
``` ```
实际上任何情况下，通过内联闭包表达式构造的闭包作为参数传递给函数时，都可以推断出闭包的参数和返回值类型，这意味着您几乎不需要利用完整格式构造任何内联闭包。 实际上任何情况下，通过内联闭包表达式构造的闭包作为参数传递给函数时，都可以推断出闭包的参数和返回值类型，这意味着您几乎不需要利用完整格式构造任何内联闭包。
<a name="implicit_returns_from_single_expression_closures"></a> <a name="implicit_returns_from_single_expression_closures"></a>
### 单表达式闭包隐式返回（Implicit Return From Single-Expression Clossures） ### 单表达式闭包隐式返回（Implicit Return From Single-Expression Clossures）
单行表达式闭包可以通过隐藏`return`关键字来隐式返回单行表达式的结果，如上版本的例子可以改写为： 单行表达式闭包可以通过隐藏`return`关键字来隐式返回单行表达式的结果，如上版本的例子可以改写为：
```swift ```swift
reversed = sort(names, { s1, s2 in s1 > s2 } ) reversed = sort(names, { s1, s2 in s1 > s2 } )
``` ```
在这个例子中，`sort`函数的第二个参数函数类型明确了闭包必须返回一个`Bool`类型值。 在这个例子中，`sort`函数的第二个参数函数类型明确了闭包必须返回一个`Bool`类型值。
因为闭包函数体只包含了一个单一表达式 (`s1 > s2`)，该表达式返回`Bool`类型值，因此这里没有歧义，`return`关键字可以省略。 因为闭包函数体只包含了一个单一表达式 (`s1 > s2`)，该表达式返回`Bool`类型值，因此这里没有歧义，`return`关键字可以省略。
<a name="shorthand_argument_names"></a> <a name="shorthand_argument_names"></a>
### 参数名称缩写（Shorthand Argument Names） ### 参数名称缩写（Shorthand Argument Names）
Swift 自动为内联函数提供了参数名称缩写功能，您可以直接通过`$0`,`$1`,`$2`来顺序调用闭包的参数。 Swift 自动为内联函数提供了参数名称缩写功能，您可以直接通过`$0`,`$1`,`$2`来顺序调用闭包的参数。
如果您在闭包表达式中使用参数名称缩写，您可以在闭包参数列表中省略对其的定义，并且对应参数名称缩写的类型会通过函数类型进行推断。 如果您在闭包表达式中使用参数名称缩写，您可以在闭包参数列表中省略对其的定义，并且对应参数名称缩写的类型会通过函数类型进行推断。
`in`关键字也同样可以被省略，因为此时闭包表达式完全由闭包函数体构成： `in`关键字也同样可以被省略，因为此时闭包表达式完全由闭包函数体构成：
```swift ```swift
reversed = sort(names, { $0 > $1 } ) reversed = sort(names, { $0 > $1 } )
``` ```
在这个例子中，`$0`和`$1`表示闭包中第一个和第二个`String`类型的参数。 在这个例子中，`$0`和`$1`表示闭包中第一个和第二个`String`类型的参数。
<a name="operator_functions"></a> <a name="operator_functions"></a>
### 运算符函数（Operator Functions） ### 运算符函数（Operator Functions）
实际上还有一种更简短的方式来撰写上面例子中的闭包表达式。 实际上还有一种更简短的方式来撰写上面例子中的闭包表达式。
Swift 的`String`类型定义了关于大于号 (`>`) 的字符串实现，其作为一个函数接受两个`String`类型的参数并返回`Bool`类型的值。 Swift 的`String`类型定义了关于大于号 (`>`) 的字符串实现，其作为一个函数接受两个`String`类型的参数并返回`Bool`类型的值。
而这正好与`sort`函数的第二个参数需要的函数类型相符合。 而这正好与`sort`函数的第二个参数需要的函数类型相符合。
因此，您可以简单地传递一个大于号，Swift可以自动推断出您想使用大于号的字符串函数实现： 因此，您可以简单地传递一个大于号，Swift可以自动推断出您想使用大于号的字符串函数实现：
```swift ```swift
reversed = sort(names, >) reversed = sort(names, >)
``` ```
更多关于运算符表达式的内容请查看 [运算符函数](../chapter2/23_Advanced_Operators.html#operator_functions)。 更多关于运算符表达式的内容请查看 [运算符函数](../chapter2/23_Advanced_Operators.html#operator_functions)。
<a name="trailing_closures"></a> <a name="trailing_closures"></a>
## 尾随闭包（Trailing Closures） ## 尾随闭包（Trailing Closures）
如果您需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用尾随闭包来增强函数的可读性。 如果您需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用尾随闭包来增强函数的可读性。
尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用。 尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用。
```swift ```swift
func someFunctionThatTakesAClosure(closure: () -> ()) { func someFunctionThatTakesAClosure(closure: () -> ()) {
// 函数体部分 // 函数体部分
} }
// 以下是不使用尾随闭包进行函数调用 // 以下是不使用尾随闭包进行函数调用
someFunctionThatTakesAClosure({ someFunctionThatTakesAClosure({
// 闭包主体部分 // 闭包主体部分
}) })
// 以下是使用尾随闭包进行函数调用 // 以下是使用尾随闭包进行函数调用
someFunctionThatTakesAClosure() { someFunctionThatTakesAClosure() {
// 闭包主体部分 // 闭包主体部分
} }
``` ```
> 注意： > 注意：
> 如果函数只需要闭包表达式一个参数，当您使用尾随闭包时，您甚至可以把`()`省略掉。 > 如果函数只需要闭包表达式一个参数，当您使用尾随闭包时，您甚至可以把`()`省略掉。
在上例中作为`sort`函数参数的字符串排序闭包可以改写为： 在上例中作为`sort`函数参数的字符串排序闭包可以改写为：
```swift ```swift
reversed = sort(names) { $0 > $1 } reversed = sort(names) { $0 > $1 }
``` ```
当闭包非常长以至于不能在一行中进行书写时，尾随闭包变得非常有用。 当闭包非常长以至于不能在一行中进行书写时，尾随闭包变得非常有用。
举例来说，Swift 的`Array`类型有一个`map`方法，其获取一个闭包表达式作为其唯一参数。 举例来说，Swift 的`Array`类型有一个`map`方法，其获取一个闭包表达式作为其唯一参数。
数组中的每一个元素调用一次该闭包函数，并返回该元素所映射的值(也可以是不同类型的值)。 数组中的每一个元素调用一次该闭包函数，并返回该元素所映射的值(也可以是不同类型的值)。
具体的映射方式和返回值类型由闭包来指定。 具体的映射方式和返回值类型由闭包来指定。
当提供给数组闭包函数后，`map`方法将返回一个新的数组，数组中包含了与原数组一一对应的映射后的值。 当提供给数组闭包函数后，`map`方法将返回一个新的数组，数组中包含了与原数组一一对应的映射后的值。
下例介绍了如何在`map`方法中使用尾随闭包将`Int`类型数组`[16,58,510]`转换为包含对应`String`类型的数组`["OneSix", "FiveEight", "FiveOneZero"]`: 下例介绍了如何在`map`方法中使用尾随闭包将`Int`类型数组`[16,58,510]`转换为包含对应`String`类型的数组`["OneSix", "FiveEight", "FiveOneZero"]`:
```swift ```swift
let digitNames = [ let digitNames = [
0: "Zero", 1: "One", 2: "Two", 3: "Three", 4: "Four", 0: "Zero", 1: "One", 2: "Two", 3: "Three", 4: "Four",
5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine" 5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine"
] ]
let numbers = [16, 58, 510] let numbers = [16, 58, 510]
``` ```
如上代码创建了一个数字位和它们名字映射的英文版本字典。 如上代码创建了一个数字位和它们名字映射的英文版本字典。
同时定义了一个准备转换为字符串的整型数组。 同时定义了一个准备转换为字符串的整型数组。
您现在可以通过传递一个尾随闭包给`numbers`的`map`方法来创建对应的字符串版本数组。 您现在可以通过传递一个尾随闭包给`numbers`的`map`方法来创建对应的字符串版本数组。
需要注意的时调用`numbers.map`不需要在`map`后面包含任何括号，因为其只需要传递闭包表达式这一个参数，并且该闭包表达式参数通过尾随方式进行撰写： 需要注意的时调用`numbers.map`不需要在`map`后面包含任何括号，因为其只需要传递闭包表达式这一个参数，并且该闭包表达式参数通过尾随方式进行撰写：
```swift ```swift
let strings = numbers.map { let strings = numbers.map {
(var number) -> String in (var number) -> String in
var output = "" var output = ""
while number > 0 { while number > 0 {
output = digitNames[number % 10]! + output output = digitNames[number % 10]! + output
number /= 10 number /= 10
} }
return output return output
} }
// strings 常量被推断为字符串类型数组，即 String[] // strings 常量被推断为字符串类型数组，即 String[]
// 其值为 ["OneSix", "FiveEight", "FiveOneZero"] // 其值为 ["OneSix", "FiveEight", "FiveOneZero"]
``` ```
`map`在数组中为每一个元素调用了闭包表达式。 `map`在数组中为每一个元素调用了闭包表达式。
您不需要指定闭包的输入参数`number`的类型，因为可以通过要映射的数组类型进行推断。 您不需要指定闭包的输入参数`number`的类型，因为可以通过要映射的数组类型进行推断。
闭包`number`参数被声明为一个变量参数（变量的具体描述请参看[常量参数和变量参数](../chapter2/06_Functions.html#constant_and_variable_parameters)），因此可以在闭包函数体内对其进行修改。闭包表达式制定了返回类型为`String`，以表明存储映射值的新数组类型为`String`。 闭包`number`参数被声明为一个变量参数（变量的具体描述请参看[常量参数和变量参数](../chapter2/06_Functions.html#constant_and_variable_parameters)），因此可以在闭包函数体内对其进行修改。闭包表达式制定了返回类型为`String`，以表明存储映射值的新数组类型为`String`。
闭包表达式在每次被调用的时候创建了一个字符串并返回。 闭包表达式在每次被调用的时候创建了一个字符串并返回。
其使用求余运算符 (number % 10) 计算最后一位数字并利用`digitNames`字典获取所映射的字符串。 其使用求余运算符 (number % 10) 计算最后一位数字并利用`digitNames`字典获取所映射的字符串。
> 注意： > 注意：
> 字典`digitNames`下标后跟着一个叹号 (!)，因为字典下标返回一个可选值 (optional value)，表明即使该 key 不存在也不会查找失败。 > 字典`digitNames`下标后跟着一个叹号 (!)，因为字典下标返回一个可选值 (optional value)，表明即使该 key 不存在也不会查找失败。
> 在上例中，它保证了`number % 10`可以总是作为一个`digitNames`字典的有效下标 key。 > 在上例中，它保证了`number % 10`可以总是作为一个`digitNames`字典的有效下标 key。
> 因此叹号可以用于强制解析 (force-unwrap) 存储在可选下标项中的`String`类型值。 > 因此叹号可以用于强制解析 (force-unwrap) 存储在可选下标项中的`String`类型值。
从`digitNames`字典中获取的字符串被添加到输出的前部，逆序建立了一个字符串版本的数字。 从`digitNames`字典中获取的字符串被添加到输出的前部，逆序建立了一个字符串版本的数字。
（在表达式`number % 10`中，如果number为16，则返回6，58返回8，510返回0）。 （在表达式`number % 10`中，如果number为16，则返回6，58返回8，510返回0）。
`number`变量之后除以10。 `number`变量之后除以10。
因为其是整数，在计算过程中未除尽部分被忽略。 因为其是整数，在计算过程中未除尽部分被忽略。
因此 16变成了1，58变成了5，510变成了51。 因此 16变成了1，58变成了5，510变成了51。
整个过程重复进行，直到`number /= 10`为0，这时闭包会将字符串输出，而`map`函数则会将字符串添加到所映射的数组中。 整个过程重复进行，直到`number /= 10`为0，这时闭包会将字符串输出，而`map`函数则会将字符串添加到所映射的数组中。
上例中尾随闭包语法在函数后整洁封装了具体的闭包功能，而不再需要将整个闭包包裹在`map`函数的括号内。 上例中尾随闭包语法在函数后整洁封装了具体的闭包功能，而不再需要将整个闭包包裹在`map`函数的括号内。
<a name="capturing_values"></a> <a name="capturing_values"></a>
## 捕获值（Capturing Values） ## 捕获值（Capturing Values）
闭包可以在其定义的上下文中捕获常量或变量。 闭包可以在其定义的上下文中捕获常量或变量。
即使定义这些常量和变量的原域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。 即使定义这些常量和变量的原域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。
Swift最简单的闭包形式是嵌套函数，也就是定义在其他函数的函数体内的函数。 Swift最简单的闭包形式是嵌套函数，也就是定义在其他函数的函数体内的函数。
嵌套函数可以捕获其外部函数所有的参数以及定义的常量和变量。 嵌套函数可以捕获其外部函数所有的参数以及定义的常量和变量。
下例为一个叫做`makeIncrementor`的函数，其包含了一个叫做`incrementor`嵌套函数。 下例为一个叫做`makeIncrementor`的函数，其包含了一个叫做`incrementor`嵌套函数。
嵌套函数`incrementor`从上下文中捕获了两个值，`runningTotal`和`amount`。 嵌套函数`incrementor`从上下文中捕获了两个值，`runningTotal`和`amount`。
之后`makeIncrementor`将`incrementor`作为闭包返回。 之后`makeIncrementor`将`incrementor`作为闭包返回。
每次调用`incrementor`时，其会以`amount`作为增量增加`runningTotal`的值。 每次调用`incrementor`时，其会以`amount`作为增量增加`runningTotal`的值。
```swift ```swift
func makeIncrementor(forIncrement amount: Int) -> () -> Int { func makeIncrementor(forIncrement amount: Int) -> () -> Int {
var runningTotal = 0 var runningTotal = 0
func incrementor() -> Int { func incrementor() -> Int {
runningTotal += amount runningTotal += amount
return runningTotal return runningTotal
} }
return incrementor return incrementor
} }
``` ```
`makeIncrementor`返回类型为`() -> Int`。 `makeIncrementor`返回类型为`() -> Int`。
这意味着其返回的是一个函数，而不是一个简单类型值。 这意味着其返回的是一个函数，而不是一个简单类型值。
该函数在每次调用时不接受参数只返回一个`Int`类型的值。 该函数在每次调用时不接受参数只返回一个`Int`类型的值。
关于函数返回其他函数的内容，请查看[函数类型作为返回类型](../chapter2/06_Functions.html#function_types_as_return_types)。 关于函数返回其他函数的内容，请查看[函数类型作为返回类型](../chapter2/06_Functions.html#function_types_as_return_types)。
`makeIncrementor`函数定义了一个整型变量`runningTotal`(初始为0) 用来存储当前跑步总数。 `makeIncrementor`函数定义了一个整型变量`runningTotal`(初始为0) 用来存储当前跑步总数。
该值通过`incrementor`返回。 该值通过`incrementor`返回。
`makeIncrementor`有一个`Int`类型的参数，其外部命名为`forIncrement`， 内部命名为`amount`，表示每次`incrementor`被调用时`runningTotal`将要增加的量。 `makeIncrementor`有一个`Int`类型的参数，其外部命名为`forIncrement`， 内部命名为`amount`，表示每次`incrementor`被调用时`runningTotal`将要增加的量。
`incrementor`函数用来执行实际的增加操作。 `incrementor`函数用来执行实际的增加操作。
该函数简单地使`runningTotal`增加`amount`，并将其返回。 该函数简单地使`runningTotal`增加`amount`，并将其返回。
如果我们单独看这个函数，会发现看上去不同寻常： 如果我们单独看这个函数，会发现看上去不同寻常：
```swift ```swift
func incrementor() -> Int { func incrementor() -> Int {
runningTotal += amount runningTotal += amount
return runningTotal return runningTotal
} }
``` ```
`incrementor`函数并没有获取任何参数，但是在函数体内访问了`runningTotal`和`amount`变量。这是因为其通过捕获在包含它的函数体内已经存在的`runningTotal`和`amount`变量而实现。 `incrementor`函数并没有获取任何参数，但是在函数体内访问了`runningTotal`和`amount`变量。这是因为其通过捕获在包含它的函数体内已经存在的`runningTotal`和`amount`变量而实现。
由于没有修改`amount`变量，`incrementor`实际上捕获并存储了该变量的一个副本，而该副本随着`incrementor`一同被存储。 由于没有修改`amount`变量，`incrementor`实际上捕获并存储了该变量的一个副本，而该副本随着`incrementor`一同被存储。
然而，因为每次调用该函数的时候都会修改`runningTotal`的值，`incrementor`捕获了当前`runningTotal`变量的引用，而不是仅仅复制该变量的初始值。捕获一个引用保证了当`makeIncrementor`结束时候并不会消失，也保证了当下一次执行`incrementor`函数时，`runningTotal`可以继续增加。 然而，因为每次调用该函数的时候都会修改`runningTotal`的值，`incrementor`捕获了当前`runningTotal`变量的引用，而不是仅仅复制该变量的初始值。捕获一个引用保证了当`makeIncrementor`结束时候并不会消失，也保证了当下一次执行`incrementor`函数时，`runningTotal`可以继续增加。
> 注意： > 注意：
> Swift 会决定捕获引用还是拷贝值。 > Swift 会决定捕获引用还是拷贝值。
> 您不需要标注`amount`或者`runningTotal`来声明在嵌入的`incrementor`函数中的使用方式。 > 您不需要标注`amount`或者`runningTotal`来声明在嵌入的`incrementor`函数中的使用方式。
> Swift 同时也处理`runingTotal`变量的内存管理操作，如果不再被`incrementor`函数使用，则会被清除。 > Swift 同时也处理`runingTotal`变量的内存管理操作，如果不再被`incrementor`函数使用，则会被清除。
下面代码为一个使用`makeIncrementor`的例子： 下面代码为一个使用`makeIncrementor`的例子：
```swift ```swift
let incrementByTen = makeIncrementor(forIncrement: 10) let incrementByTen = makeIncrementor(forIncrement: 10)
``` ```
该例子定义了一个叫做`incrementByTen`的常量，该常量指向一个每次调用会加10的`incrementor`函数。 该例子定义了一个叫做`incrementByTen`的常量，该常量指向一个每次调用会加10的`incrementor`函数。
调用这个函数多次可以得到以下结果： 调用这个函数多次可以得到以下结果：
```swift ```swift
incrementByTen() incrementByTen()
// 返回的值为10 // 返回的值为10
incrementByTen() incrementByTen()
// 返回的值为20 // 返回的值为20
incrementByTen() incrementByTen()
// 返回的值为30 // 返回的值为30
``` ```
如果您创建了另一个`incrementor`，其会有一个属于自己的独立的`runningTotal`变量的引用。 如果您创建了另一个`incrementor`，其会有一个属于自己的独立的`runningTotal`变量的引用。
下面的例子中，`incrementBySevne`捕获了一个新的`runningTotal`变量，该变量和`incrementByTen`中捕获的变量没有任何联系： 下面的例子中，`incrementBySevne`捕获了一个新的`runningTotal`变量，该变量和`incrementByTen`中捕获的变量没有任何联系：
```swift ```swift
let incrementBySeven = makeIncrementor(forIncrement: 7) let incrementBySeven = makeIncrementor(forIncrement: 7)
incrementBySeven() incrementBySeven()
// 返回的值为7 // 返回的值为7
incrementByTen() incrementByTen()
// 返回的值为40 // 返回的值为40
``` ```
> 注意： > 注意：
> 如果您将闭包赋值给一个类实例的属性，并且该闭包通过指向该实例或其成员来捕获了该实例，您将创建一个在闭包和实例间的强引用环。 > 如果您将闭包赋值给一个类实例的属性，并且该闭包通过指向该实例或其成员来捕获了该实例，您将创建一个在闭包和实例间的强引用环。
> Swift 使用捕获列表来打破这种强引用环。更多信息，请参考 [闭包引起的循环强引用](../chapter2/16_Automatic_Reference_Counting.html#strong_reference_cycles_for_closures)。 > Swift 使用捕获列表来打破这种强引用环。更多信息，请参考 [闭包引起的循环强引用](../chapter2/16_Automatic_Reference_Counting.html#strong_reference_cycles_for_closures)。
<a name="closures_are_reference_types"></a> <a name="closures_are_reference_types"></a>
## 闭包是引用类型（Closures Are Reference Types） ## 闭包是引用类型（Closures Are Reference Types）
上面的例子中，`incrementBySeven`和`incrementByTen`是常量，但是这些常量指向的闭包仍然可以增加其捕获的变量值。 上面的例子中，`incrementBySeven`和`incrementByTen`是常量，但是这些常量指向的闭包仍然可以增加其捕获的变量值。
这是因为函数和闭包都是引用类型。 这是因为函数和闭包都是引用类型。
无论您将函数/闭包赋值给一个常量还是变量，您实际上都是将常量/变量的值设置为对应函数/闭包的引用。 无论您将函数/闭包赋值给一个常量还是变量，您实际上都是将常量/变量的值设置为对应函数/闭包的引用。
上面的例子中，`incrementByTen`指向闭包的引用是一个常量，而并非闭包内容本身。 上面的例子中，`incrementByTen`指向闭包的引用是一个常量，而并非闭包内容本身。
这也意味着如果您将闭包赋值给了两个不同的常量/变量，两个值都会指向同一个闭包： 这也意味着如果您将闭包赋值给了两个不同的常量/变量，两个值都会指向同一个闭包：
```swift ```swift
let alsoIncrementByTen = incrementByTen let alsoIncrementByTen = incrementByTen
alsoIncrementByTen() alsoIncrementByTen()
// 返回的值为50 // 返回的值为50
``` ```

2
source/chapter2/08_Enumerations.md
View File

@ -1,4 +1,4 @@
> 翻译：[yankuangshi](https://github.com/yankuangshi) > 翻译：[yankuangshi](https://github.com/yankuangshi)
> 校对：[shinyzhu](https://github.com/shinyzhu) > 校对：[shinyzhu](https://github.com/shinyzhu)
# 枚举（Enumerations） # 枚举（Enumerations）

886
source/chapter2/09_Classes_and_Structures.md
View File

@ -1,443 +1,443 @@
> 翻译：[JaySurplus](https://github.com/JaySurplus) > 翻译：[JaySurplus](https://github.com/JaySurplus)
> 校对：[sg552](https://github.com/sg552) > 校对：[sg552](https://github.com/sg552)
# 类和结构体 # 类和结构体
本页包含内容： 本页包含内容：
- [类和结构体对比](#comparing_classes_and_structures) - [类和结构体对比](#comparing_classes_and_structures)
- [结构体和枚举是值类型](#structures_and_enumerations_are_value_types) - [结构体和枚举是值类型](#structures_and_enumerations_are_value_types)
- [类是引用类型](#classes_are_reference_types) - [类是引用类型](#classes_are_reference_types)
- [类和结构体的选择](#choosing_between_classes_and_structures) - [类和结构体的选择](#choosing_between_classes_and_structures)
- [集合（collection）类型的赋值与复制行为](#assignment_and_copy_behavior_for_collection_types) - [集合（collection）类型的赋值与复制行为](#assignment_and_copy_behavior_for_collection_types)
类和结构体是人们构建代码所用的一种通用且灵活的构造体。为了在类和结构体中实现各种功能，我们必须要严格按照对于常量，变量以及函数所规定的语法规则来定义属性和添加方法。 类和结构体是人们构建代码所用的一种通用且灵活的构造体。为了在类和结构体中实现各种功能，我们必须要严格按照对于常量，变量以及函数所规定的语法规则来定义属性和添加方法。
与其他编程语言所不同的是，Swift 并不要求你为自定义类和结构去创建独立的接口和实现文件。你所要做的是在一个单一文件中定义一个类或者结构体，系统将会自动生成面向其它代码的外部接口。 与其他编程语言所不同的是，Swift 并不要求你为自定义类和结构去创建独立的接口和实现文件。你所要做的是在一个单一文件中定义一个类或者结构体，系统将会自动生成面向其它代码的外部接口。
> 注意： > 注意：
通常一个`类`的实例被称为`对象`。然而在Swift 中，类和结构体的关系要比在其他语言中更加的密切，本章中所讨论的大部分功能都可以用在类和结构体上。因此，我们会主要使用`实例`而不是`对象`。 通常一个`类`的实例被称为`对象`。然而在Swift 中，类和结构体的关系要比在其他语言中更加的密切，本章中所讨论的大部分功能都可以用在类和结构体上。因此，我们会主要使用`实例`而不是`对象`。
<a name="comparing_classes_and_structures"></a> <a name="comparing_classes_and_structures"></a>
###类和结构体对比 ###类和结构体对比
Swift 中类和结构体有很多共同点。共同处在于： Swift 中类和结构体有很多共同点。共同处在于：
* 定义属性用于储存值 * 定义属性用于储存值
* 定义方法用于提供功能 * 定义方法用于提供功能
* 定义附属脚本用于访问值 * 定义附属脚本用于访问值
* 定义构造器用于生成初始化值 * 定义构造器用于生成初始化值
* 通过扩展以增加默认实现的功能 * 通过扩展以增加默认实现的功能
* 符合协议以对某类提供标准功能 * 符合协议以对某类提供标准功能
更多信息请参见 [属性](10_Properties.html)，[方法](11_Methods.html)，[下标脚本](12_Subscripts.html)，[初始过程](14_Initialization.html)，[扩展](20_Extensions.html)，和[协议](21_Protocols.html)。 更多信息请参见 [属性](10_Properties.html)，[方法](11_Methods.html)，[下标脚本](12_Subscripts.html)，[初始过程](14_Initialization.html)，[扩展](20_Extensions.html)，和[协议](21_Protocols.html)。
与结构体相比，类还有如下的附加功能： 与结构体相比，类还有如下的附加功能：
* 继承允许一个类继承另一个类的特征 * 继承允许一个类继承另一个类的特征
* 类型转换允许在运行时检查和解释一个类实例的类型 * 类型转换允许在运行时检查和解释一个类实例的类型
* 解构器允许一个类实例释放任何其所被分配的资源 * 解构器允许一个类实例释放任何其所被分配的资源
* 引用计数允许对一个类的多次引用 * 引用计数允许对一个类的多次引用
更多信息请参见[继承](http://)，[类型转换](http://)，[初始化](http://)，和[自动引用计数](http://)。 更多信息请参见[继承](http://)，[类型转换](http://)，[初始化](http://)，和[自动引用计数](http://)。
> 注意： > 注意：
结构体总是通过被复制的方式在代码中传递，因此请不要使用引用计数。 结构体总是通过被复制的方式在代码中传递，因此请不要使用引用计数。
### 定义 ### 定义
类和结构体有着类似的定义方式。我们通过关键字`class`和`struct`来分别表示类和结构体，并在一对大括号中定义它们的具体内容： 类和结构体有着类似的定义方式。我们通过关键字`class`和`struct`来分别表示类和结构体，并在一对大括号中定义它们的具体内容：
```swift ```swift
class SomeClass { class SomeClass {
// class definition goes here // class definition goes here
} }
struct SomeStructure { struct SomeStructure {
// structure definition goes here // structure definition goes here
} }
``` ```
> 注意： > 注意：
在你每次定义一个新类或者结构体的时候，实际上你是有效地定义了一个新的 Swift 类型。因此请使用 `UpperCamelCase` 这种方式来命名（如 `SomeClass` 和`SomeStructure`等），以便符合标准Swift 类型的大写命名风格（如`String`，`Int`和`Bool`）。相反的，请使用`lowerCamelCase`这种方式为属性和方法命名（如`framerate`和`incrementCount`），以便和类区分。 在你每次定义一个新类或者结构体的时候，实际上你是有效地定义了一个新的 Swift 类型。因此请使用 `UpperCamelCase` 这种方式来命名（如 `SomeClass` 和`SomeStructure`等），以便符合标准Swift 类型的大写命名风格（如`String`，`Int`和`Bool`）。相反的，请使用`lowerCamelCase`这种方式为属性和方法命名（如`framerate`和`incrementCount`），以便和类区分。
以下是定义结构体和定义类的示例： 以下是定义结构体和定义类的示例：
```swift ```swift
struct Resolution { struct Resolution {
var width = 0 var width = 0
var heigth = 0 var heigth = 0
} }
class VideoMode { class VideoMode {
var resolution = Resolution() var resolution = Resolution()
var interlaced = false var interlaced = false
var frameRate = 0.0 var frameRate = 0.0
var name: String? var name: String?
} }
``` ```
在上面的示例中我们定义了一个名为`Resolution`的结构体，用来描述一个显示器的像素分辨率。这个结构体包含了两个名为`width`和`height`的储存属性。储存属性是捆绑和储存在类或结构体中的常量或变量。当这两个属性被初始化为整数`0`的时候，它们会被推断为`Int`类型。 在上面的示例中我们定义了一个名为`Resolution`的结构体，用来描述一个显示器的像素分辨率。这个结构体包含了两个名为`width`和`height`的储存属性。储存属性是捆绑和储存在类或结构体中的常量或变量。当这两个属性被初始化为整数`0`的时候，它们会被推断为`Int`类型。
在上面的示例中我们还定义了一个名为`VideoMode`的类，用来描述一个视频显示器的特定模式。这个类包含了四个储存属性变量。第一个是`分辨率`，它被初始化为一个新的`Resolution`结构体的实例，具有`Resolution`的属性类型。新`VideoMode`实例同时还会初始化其它三个属性，它们分别是，初始值为`false`(意为“non-interlaced video”)的`inteflaced`，回放帧率初始值为`0.0`的`frameRate`和值为可选`String`的`name`。`name`属性会被自动赋予一个默认值`nil`，意为“没有`name`值”，因它是一个可选类型。 在上面的示例中我们还定义了一个名为`VideoMode`的类，用来描述一个视频显示器的特定模式。这个类包含了四个储存属性变量。第一个是`分辨率`，它被初始化为一个新的`Resolution`结构体的实例，具有`Resolution`的属性类型。新`VideoMode`实例同时还会初始化其它三个属性，它们分别是，初始值为`false`(意为“non-interlaced video”)的`inteflaced`，回放帧率初始值为`0.0`的`frameRate`和值为可选`String`的`name`。`name`属性会被自动赋予一个默认值`nil`，意为“没有`name`值”，因它是一个可选类型。
### 类和结构体实例 ### 类和结构体实例
`Resolution`结构体和`VideoMode`类的定义仅描述了什么是`Resolution`和`VideoMode`。它们并没有描述一个特定的分辨率（resolution）或者视频模式（video mode）。为了描述一个特定的分辨率或者视频模式，我们需要生成一个它们的实例。 `Resolution`结构体和`VideoMode`类的定义仅描述了什么是`Resolution`和`VideoMode`。它们并没有描述一个特定的分辨率（resolution）或者视频模式（video mode）。为了描述一个特定的分辨率或者视频模式，我们需要生成一个它们的实例。
生成结构体和类实例的语法非常相似： 生成结构体和类实例的语法非常相似：
```swift ```swift
let someResolution = Resolution() let someResolution = Resolution()
let someVideoMode = VideoMode() let someVideoMode = VideoMode()
``` ```
结构体和类都使用构造器语法来生成新的实例。构造器语法的最简单形式是在结构体或者类的类型名称后跟随一个空括弧，如`Resolution()`或`VideoMode()`。通过这种方式所创建的类或者结构体实例，其属均会被初始化为默认值。[构造过程](14_Initialization.html)章节会对类和结构体的初始化进行更详细的讨论。 结构体和类都使用构造器语法来生成新的实例。构造器语法的最简单形式是在结构体或者类的类型名称后跟随一个空括弧，如`Resolution()`或`VideoMode()`。通过这种方式所创建的类或者结构体实例，其属均会被初始化为默认值。[构造过程](14_Initialization.html)章节会对类和结构体的初始化进行更详细的讨论。
### 属性访问 ### 属性访问
通过使用*点语法*（*dot syntax*）,你可以访问实例中所含有的属性。其语法规则是，实例名后面紧跟属性名，两者通过点号(.)连接： 通过使用*点语法*（*dot syntax*）,你可以访问实例中所含有的属性。其语法规则是，实例名后面紧跟属性名，两者通过点号(.)连接：
```swift ```swift
println("The width of someResolution is \(someResolution.width)") println("The width of someResolution is \(someResolution.width)")
// 输出 "The width of someResolution is 0" // 输出 "The width of someResolution is 0"
``` ```
在上面的例子中，`someResolution.width`引用`someResolution`的`width`属性，返回`width`的初始值`0`。 在上面的例子中，`someResolution.width`引用`someResolution`的`width`属性，返回`width`的初始值`0`。
你也可以访问子属性，如何`VideoMode`中`Resolution`属性的`width`属性： 你也可以访问子属性，如何`VideoMode`中`Resolution`属性的`width`属性：
```swift ```swift
println("The width of someVideoMode is \(someVideoMode.resolution.width)") println("The width of someVideoMode is \(someVideoMode.resolution.width)")
// 输出 "The width of someVideoMode is 0" // 输出 "The width of someVideoMode is 0"
``` ```
你也可以使用点语法为属性变量赋值： 你也可以使用点语法为属性变量赋值：
```swift ```swift
someVideoMode.resolution.width = 12880 someVideoMode.resolution.width = 12880
println("The width of someVideoMode is now \(someVideoMode.resolution.width)") println("The width of someVideoMode is now \(someVideoMode.resolution.width)")
// 输出 "The width of someVideoMode is now 1280" // 输出 "The width of someVideoMode is now 1280"
``` ```
> 注意： > 注意：
与 Objective-C 语言不同的是，Swift 允许直接设置结构体属性的子属性。上面的最后一个例子，就是直接设置了`someVideoMode`中`resolution`属性的`width`这个子属性，以上操作并不需要从新设置`resolution`属性。 与 Objective-C 语言不同的是，Swift 允许直接设置结构体属性的子属性。上面的最后一个例子，就是直接设置了`someVideoMode`中`resolution`属性的`width`这个子属性，以上操作并不需要从新设置`resolution`属性。
### 结构体类型的成员逐一构造器(Memberwise Initializers for structure Types) ### 结构体类型的成员逐一构造器(Memberwise Initializers for structure Types)
所有结构体都有一个自动生成的成员逐一构造器，用于初始化新结构体实例中成员的属性。新实例中各个属性的初始值可以通过属性的名称传递到成员逐一构造器之中： 所有结构体都有一个自动生成的成员逐一构造器，用于初始化新结构体实例中成员的属性。新实例中各个属性的初始值可以通过属性的名称传递到成员逐一构造器之中：
```swift ```swift
let vga = resolution(width:640, heigth: 480) let vga = resolution(width:640, heigth: 480)
``` ```
与结构体不同，类实例没有默认的成员逐一构造器。[构造过程](14_Initialization.html)章节会对构造器进行更详细的讨论。 与结构体不同，类实例没有默认的成员逐一构造器。[构造过程](14_Initialization.html)章节会对构造器进行更详细的讨论。
<a name="structures_and_enumerations_are_value_types"></a> <a name="structures_and_enumerations_are_value_types"></a>
## 结构体和枚举是值类型 ## 结构体和枚举是值类型
值类型被赋予给一个变量，常数或者本身被传递给一个函数的时候，实际上操作的是其的拷贝。 值类型被赋予给一个变量，常数或者本身被传递给一个函数的时候，实际上操作的是其的拷贝。
在之前的章节中，我们已经大量使用了值类型。实际上，在 Swift 中，所有的基本类型：整数（Integer）、浮点数（floating-point）、布尔值（Booleans）、字符串（string)、数组（array）和字典（dictionaries），都是值类型，并且都是以结构体的形式在后台所实现。 在之前的章节中，我们已经大量使用了值类型。实际上，在 Swift 中，所有的基本类型：整数（Integer）、浮点数（floating-point）、布尔值（Booleans）、字符串（string)、数组（array）和字典（dictionaries），都是值类型，并且都是以结构体的形式在后台所实现。
在 Swift 中，所有的结构体和枚举都是值类型。这意味着它们的实例，以及实例中所包含的任何值类型属性，在代码中传递的时候都会被复制。 在 Swift 中，所有的结构体和枚举都是值类型。这意味着它们的实例，以及实例中所包含的任何值类型属性，在代码中传递的时候都会被复制。
请看下面这个示例，其使用了前一个示例中`Resolution`结构体： 请看下面这个示例，其使用了前一个示例中`Resolution`结构体：
```swift ```swift
let hd = Resolution(width: 1920, height: 1080) let hd = Resolution(width: 1920, height: 1080)
var cinema = hd var cinema = hd
``` ```
在以上示例中，声明了一个名为`hd`的常量，其值为一个初始化为全高清视频分辨率（1920 像素宽，1080 像素高）的`Resolution`实例。 在以上示例中，声明了一个名为`hd`的常量，其值为一个初始化为全高清视频分辨率（1920 像素宽，1080 像素高）的`Resolution`实例。
然后示例中又声明了一个名为`cinema`的变量，其值为之前声明的`hd`。因为`Resolution`是一个结构体，所以`cinema`的值其实是`hd`的一个拷贝副本，而不是`hd`本身。尽管`hd`和`cinema`有着相同的宽（width）和高（height）属性，但是在后台中，它们是两个完全不同的实例。 然后示例中又声明了一个名为`cinema`的变量，其值为之前声明的`hd`。因为`Resolution`是一个结构体，所以`cinema`的值其实是`hd`的一个拷贝副本，而不是`hd`本身。尽管`hd`和`cinema`有着相同的宽（width）和高（height）属性，但是在后台中，它们是两个完全不同的实例。
下面，为了符合数码影院放映的需求（2048 像素宽，1080 像素高），`cinema`的`width`属性需要作如下修改： 下面，为了符合数码影院放映的需求（2048 像素宽，1080 像素高），`cinema`的`width`属性需要作如下修改：
```swift ```swift
cinema.width = 2048 cinema.width = 2048
``` ```
这里，将会显示`cinema`的`width`属性确已改为了`2048`： 这里，将会显示`cinema`的`width`属性确已改为了`2048`：
```swift ```swift
println("cinema is now \(cinema.width) pixels wide") println("cinema is now \(cinema.width) pixels wide")
// 输出 "cinema is now 2048 pixels wide" // 输出 "cinema is now 2048 pixels wide"
``` ```
然而，初始的`hd`实例中`width`属性还是`1920`： 然而，初始的`hd`实例中`width`属性还是`1920`：
```swift ```swift
println("hd is still \(hd.width ) pixels wide") println("hd is still \(hd.width ) pixels wide")
// 输出 "hd is still 1920 pixels wide" // 输出 "hd is still 1920 pixels wide"
``` ```
在将`hd`赋予给`cinema`的时候，实际上是将`hd`中所储存的`值（values）`进行拷贝，然后将拷贝的数据储存到新的`cinema`实例中。结果就是两个完全独立的实例碰巧包含有相同的数值。由于两者相互独立，因此将`cinema`的`width`修改为`2048`并不会影响`hd`中的宽（width）。 在将`hd`赋予给`cinema`的时候，实际上是将`hd`中所储存的`值（values）`进行拷贝，然后将拷贝的数据储存到新的`cinema`实例中。结果就是两个完全独立的实例碰巧包含有相同的数值。由于两者相互独立，因此将`cinema`的`width`修改为`2048`并不会影响`hd`中的宽（width）。
枚举也遵循相同的行为准则： 枚举也遵循相同的行为准则：
```swift ```swift
enum CompassPoint { enum CompassPoint {
case North, South, East, West case North, South, East, West
} }
var currentDirection = CompassPoint.West var currentDirection = CompassPoint.West
let rememberedDirection = currentDirection let rememberedDirection = currentDirection
currentDirection = .East currentDirection = .East
if rememberDirection == .West { if rememberDirection == .West {
println("The remembered direction is still .West") println("The remembered direction is still .West")
} }
// 输出 "The remembered direction is still .West" // 输出 "The remembered direction is still .West"
``` ```
上例中`rememberedDirection`被赋予了`currentDirection`的值（value），实际上它被赋予的是值（value）的一个拷贝。赋值过程结束后再修改`currentDirection`的值并不影响`rememberedDirection`所储存的原始值（value）的拷贝。 上例中`rememberedDirection`被赋予了`currentDirection`的值（value），实际上它被赋予的是值（value）的一个拷贝。赋值过程结束后再修改`currentDirection`的值并不影响`rememberedDirection`所储存的原始值（value）的拷贝。
<a name="classes_are_reference_types"></a> <a name="classes_are_reference_types"></a>
## 类是引用类型 ## 类是引用类型
与值类型不同，引用类型在被赋予到一个变量，常量或者被传递到一个函数时，操作的并不是其拷贝。因此，引用的是已存在的实例本身而不是其拷贝。 与值类型不同，引用类型在被赋予到一个变量，常量或者被传递到一个函数时，操作的并不是其拷贝。因此，引用的是已存在的实例本身而不是其拷贝。
请看下面这个示例，其使用了之前定义的`VideoMode`类： 请看下面这个示例，其使用了之前定义的`VideoMode`类：
```swift ```swift
let tenEighty = VideoMode() let tenEighty = VideoMode()
tenEighty.resolution = hd tenEighty.resolution = hd
tenEighty.interlaced = true tenEighty.interlaced = true
tenEighty.name = "1080i" tenEighty.name = "1080i"
tenEighty.frameRate = 25.0 tenEighty.frameRate = 25.0
``` ```
以上示例中，声明了一个名为`tenEighty`的常量，其引用了一个`VideoMode`类的新实例。在之前的示例中，这个视频模式（video mode）被赋予了HD分辨率（1920*1080）的一个拷贝（`hd`）。同时设置为交错（interlaced）,命名为`“1080i”`。最后，其帧率是`25.0`帧每秒。 以上示例中，声明了一个名为`tenEighty`的常量，其引用了一个`VideoMode`类的新实例。在之前的示例中，这个视频模式（video mode）被赋予了HD分辨率（1920*1080）的一个拷贝（`hd`）。同时设置为交错（interlaced）,命名为`“1080i”`。最后，其帧率是`25.0`帧每秒。
然后，`tenEighty` 被赋予名为`alsoTenEighty`的新常量，同时对`alsoTenEighty`的帧率进行修改： 然后，`tenEighty` 被赋予名为`alsoTenEighty`的新常量，同时对`alsoTenEighty`的帧率进行修改：
```swift ```swift
let alsoTenEighty = tenEighty let alsoTenEighty = tenEighty
alsoTenEighty.frameRate = 30.0 alsoTenEighty.frameRate = 30.0
``` ```
因为类是引用类型，所以`tenEight`和`alsoTenEight`实际上引用的是相同的`VideoMode`实例。换句话说，它们只是同一个实例的两种叫法。 因为类是引用类型，所以`tenEight`和`alsoTenEight`实际上引用的是相同的`VideoMode`实例。换句话说，它们只是同一个实例的两种叫法。
下面，通过查看`tenEighty`的`frameRate`属性，我们会发现它正确的显示了基本`VideoMode`实例的新帧率，其值为`30.0`： 下面，通过查看`tenEighty`的`frameRate`属性，我们会发现它正确的显示了基本`VideoMode`实例的新帧率，其值为`30.0`：
```swift ```swift
println("The frameRate property of tenEighty is now \(tenEighty.frameRate)") println("The frameRate property of tenEighty is now \(tenEighty.frameRate)")
// 输出 "The frameRate property of theEighty is now 30.0" // 输出 "The frameRate property of theEighty is now 30.0"
``` ```
需要注意的是`tenEighty`和`alsoTenEighty`被声明为*常量（（constants）*而不是变量。然而你依然可以改变`tenEighty.frameRate`和`alsoTenEighty.frameRate`,因为这两个常量本身不会改变。它们并不`储存`这个`VideoMode`实例，在后台仅仅是对`VideoMode`实例的引用。所以，改变的是被引用的基础`VideoMode`的`frameRate`参数，而不改变常量的值。 需要注意的是`tenEighty`和`alsoTenEighty`被声明为*常量（（constants）*而不是变量。然而你依然可以改变`tenEighty.frameRate`和`alsoTenEighty.frameRate`,因为这两个常量本身不会改变。它们并不`储存`这个`VideoMode`实例，在后台仅仅是对`VideoMode`实例的引用。所以，改变的是被引用的基础`VideoMode`的`frameRate`参数，而不改变常量的值。
### 恒等运算符 ### 恒等运算符
因为类是引用类型，有可能有多个常量和变量在后台同时引用某一个类实例。（对于结构体和枚举来说，这并不成立。因为它们作值类型，在被赋予到常量，变量或者传递到函数时，总是会被拷贝。） 因为类是引用类型，有可能有多个常量和变量在后台同时引用某一个类实例。（对于结构体和枚举来说，这并不成立。因为它们作值类型，在被赋予到常量，变量或者传递到函数时，总是会被拷贝。）
如果能够判定两个常量或者变量是否引用同一个类实例将会很有帮助。为了达到这个目的，Swift 内建了两个恒等运算符： 如果能够判定两个常量或者变量是否引用同一个类实例将会很有帮助。为了达到这个目的，Swift 内建了两个恒等运算符：
* 等价于 （ === ） * 等价于 （ === ）
* 不等价于 （ !== ） * 不等价于 （ !== ）
以下是运用这两个运算符检测两个常量或者变量是否引用同一个实例： 以下是运用这两个运算符检测两个常量或者变量是否引用同一个实例：
```swift ```swift
if tenEighty === alsoTenTighty { if tenEighty === alsoTenTighty {
println("tenTighty and alsoTenEighty refer to the same Resolution instance.") println("tenTighty and alsoTenEighty refer to the same Resolution instance.")
} }
//输出 "tenEighty and alsoTenEighty refer to the same Resolution instance." //输出 "tenEighty and alsoTenEighty refer to the same Resolution instance."
``` ```
请注意“等价于”（用三个等号表示，===） 与“等于”（用两个等号表示，==）的不同： 请注意“等价于”（用三个等号表示，===） 与“等于”（用两个等号表示，==）的不同：
* “等价于”表示两个类类型（class type）的常量或者变量引用同一个类实例。 * “等价于”表示两个类类型（class type）的常量或者变量引用同一个类实例。
* “等于”表示两个实例的值“相等”或“相同”，判定时要遵照类设计者定义定义的评判标准，因此相比于“相等”，这是一种更加合适的叫法。 * “等于”表示两个实例的值“相等”或“相同”，判定时要遵照类设计者定义定义的评判标准，因此相比于“相等”，这是一种更加合适的叫法。
当你在定义你的自定义类和结构体的时候，你有义务来决定判定两个实例“相等”的标准。在章节[运算符函数(Operator Functions)](23_Advanced_Operators.html#operator_functions)中将会详细介绍实现自定义“等于”和“不等于”运算符的流程。 当你在定义你的自定义类和结构体的时候，你有义务来决定判定两个实例“相等”的标准。在章节[运算符函数(Operator Functions)](23_Advanced_Operators.html#operator_functions)中将会详细介绍实现自定义“等于”和“不等于”运算符的流程。
### 指针 ### 指针
如果你有 C，C++ 或者 Objective-C 语言的经验，那么你也许会知道这些语言使用指针来引用内存中的地址。一个 Swift 常量或者变量引用一个引用类型的实例与 C 语言中的指针类似，不同的是并不直接指向内存中的某个地址，而且也不要求你使用星号（*）来表明你在创建一个引用。Swift 中这些引用与其它的常量或变量的定义方式相同。 如果你有 C，C++ 或者 Objective-C 语言的经验，那么你也许会知道这些语言使用指针来引用内存中的地址。一个 Swift 常量或者变量引用一个引用类型的实例与 C 语言中的指针类似，不同的是并不直接指向内存中的某个地址，而且也不要求你使用星号（*）来表明你在创建一个引用。Swift 中这些引用与其它的常量或变量的定义方式相同。
<a name="choosing_between_classes_and_structures"></a> <a name="choosing_between_classes_and_structures"></a>
## 类和结构体的选择 ## 类和结构体的选择
在你的代码中，你可以使用类和结构体来定义你的自定义数据类型。 在你的代码中，你可以使用类和结构体来定义你的自定义数据类型。
然而，结构体实例总是通过值传递，类实例总是通过引用传递。这意味两者适用不同的任务。当你的在考虑一个工程项目的数据构造和功能的时候，你需要决定每个数据构造是定义成类还是结构体。 然而，结构体实例总是通过值传递，类实例总是通过引用传递。这意味两者适用不同的任务。当你的在考虑一个工程项目的数据构造和功能的时候，你需要决定每个数据构造是定义成类还是结构体。
按照通用的准则，当符合一条或多条以下条件时，请考虑构建结构体： 按照通用的准则，当符合一条或多条以下条件时，请考虑构建结构体：
* 结构体的主要目的是用来封装少量相关简单数据值。 * 结构体的主要目的是用来封装少量相关简单数据值。
* 有理由预计一个结构体实例在赋值或传递时，封装的数据将会被拷贝而不是被引用。 * 有理由预计一个结构体实例在赋值或传递时，封装的数据将会被拷贝而不是被引用。
* 任何在结构体中储存的值类型属性，也将会被拷贝，而不是被引用。 * 任何在结构体中储存的值类型属性，也将会被拷贝，而不是被引用。
* 结构体不需要去继承另一个已存在类型的属性或者行为。 * 结构体不需要去继承另一个已存在类型的属性或者行为。
合适的结构体候选者包括： 合适的结构体候选者包括：
* 几何形状的大小，封装一个`width`属性和`height`属性，两者均为`Double`类型。 * 几何形状的大小，封装一个`width`属性和`height`属性，两者均为`Double`类型。
* 一定范围内的路径，封装一个`start`属性和`length`属性，两者均为`Int`类型。 * 一定范围内的路径，封装一个`start`属性和`length`属性，两者均为`Int`类型。
* 三维坐标系内一点，封装`x`，`y`和`z`属性，三者均为`Double`类型。 * 三维坐标系内一点，封装`x`，`y`和`z`属性，三者均为`Double`类型。
在所有其它案例中，定义一个类，生成一个它的实例，并通过引用来管理和传递。实际中，这意味着绝大部分的自定义数据构造都应该是类，而非结构体。 在所有其它案例中，定义一个类，生成一个它的实例，并通过引用来管理和传递。实际中，这意味着绝大部分的自定义数据构造都应该是类，而非结构体。
<a name="assignment_and_copy_behavior_for_collection_types"></a> <a name="assignment_and_copy_behavior_for_collection_types"></a>
## 集合（Collection）类型的赋值和拷贝行为 ## 集合（Collection）类型的赋值和拷贝行为
Swift 中`数组（Array）`和`字典（Dictionary）`类型均以结构体的形式实现。然而当数组被赋予一个常量或变量，或被传递给一个函数或方法时，其拷贝行为与字典和其它结构体有些许不同。 Swift 中`数组（Array）`和`字典（Dictionary）`类型均以结构体的形式实现。然而当数组被赋予一个常量或变量，或被传递给一个函数或方法时，其拷贝行为与字典和其它结构体有些许不同。
以下对`数组`和`结构体`的行为描述与对`NSArray`和`NSDictionary`的行为描述在本质上不同，后者是以类的形式实现，前者是以结构体的形式实现。`NSArray`和`NSDictionary`实例总是以对已有实例引用,而不是拷贝的方式被赋值和传递。 以下对`数组`和`结构体`的行为描述与对`NSArray`和`NSDictionary`的行为描述在本质上不同，后者是以类的形式实现，前者是以结构体的形式实现。`NSArray`和`NSDictionary`实例总是以对已有实例引用,而不是拷贝的方式被赋值和传递。
> 注意： > 注意：
以下是对于数组，字典，字符串和其它值的`拷贝`的描述。 以下是对于数组，字典，字符串和其它值的`拷贝`的描述。
在你的代码中，拷贝好像是确实是在有拷贝行为的地方产生过。然而，在 Swift 的后台中，只有确有必要，`实际（actual）`拷贝才会被执行。Swift 管理所有的值拷贝以确保性能最优化的性能，所以你也没有必要去避免赋值以保证最优性能。（实际赋值由系统管理优化） 在你的代码中，拷贝好像是确实是在有拷贝行为的地方产生过。然而，在 Swift 的后台中，只有确有必要，`实际（actual）`拷贝才会被执行。Swift 管理所有的值拷贝以确保性能最优化的性能，所以你也没有必要去避免赋值以保证最优性能。（实际赋值由系统管理优化）
### 字典类型的赋值和拷贝行为 ### 字典类型的赋值和拷贝行为
无论何时将一个`字典`实例赋给一个常量或变量，或者传递给一个函数或方法，这个字典会即会在赋值或调用发生时被拷贝。在章节[结构体和枚举是值类型](#structures_and_enumerations_are_value_types)中将会对此过程进行详细介绍。 无论何时将一个`字典`实例赋给一个常量或变量，或者传递给一个函数或方法，这个字典会即会在赋值或调用发生时被拷贝。在章节[结构体和枚举是值类型](#structures_and_enumerations_are_value_types)中将会对此过程进行详细介绍。
如果`字典`实例中所储存的键（keys）和/或值（values）是值类型（结构体或枚举），当赋值或调用发生时，它们都会被拷贝。相反，如果键（keys）和/或值（values）是引用类型，被拷贝的将会是引用，而不是被它们引用的类实例或函数。`字典`的键和值的拷贝行为与结构体所储存的属性的拷贝行为相同。 如果`字典`实例中所储存的键（keys）和/或值（values）是值类型（结构体或枚举），当赋值或调用发生时，它们都会被拷贝。相反，如果键（keys）和/或值（values）是引用类型，被拷贝的将会是引用，而不是被它们引用的类实例或函数。`字典`的键和值的拷贝行为与结构体所储存的属性的拷贝行为相同。
下面的示例定义了一个名为`ages`的字典，其中储存了四个人的名字和年龄。`ages`字典被赋予了一个名为`copiedAges`的新变量，同时`ages`在赋值的过程中被拷贝。赋值结束后，`ages`和`copiedAges`成为两个相互独立的字典。 下面的示例定义了一个名为`ages`的字典，其中储存了四个人的名字和年龄。`ages`字典被赋予了一个名为`copiedAges`的新变量，同时`ages`在赋值的过程中被拷贝。赋值结束后，`ages`和`copiedAges`成为两个相互独立的字典。
```swift ```swift
var ages = ["Peter": 23, "Wei": 35, "Anish": 65, "Katya": 19] var ages = ["Peter": 23, "Wei": 35, "Anish": 65, "Katya": 19]
var copiedAges = ages var copiedAges = ages
``` ```
这个字典的键（keys）是`字符串（String）`类型，值（values）是`整（Int）`类型。这两种类型在Swift 中都是值类型（value types），所以当字典被拷贝时，两者都会被拷贝。 这个字典的键（keys）是`字符串（String）`类型，值（values）是`整（Int）`类型。这两种类型在Swift 中都是值类型（value types），所以当字典被拷贝时，两者都会被拷贝。
我们可以通过改变一个字典中的年龄值（age value），检查另一个字典中所对应的值，来证明`ages`字典确实是被拷贝了。如果在`copiedAges`字典中将`Peter`的值设为`24`，那么`ages`字典仍然会返回修改前的值`23`： 我们可以通过改变一个字典中的年龄值（age value），检查另一个字典中所对应的值，来证明`ages`字典确实是被拷贝了。如果在`copiedAges`字典中将`Peter`的值设为`24`，那么`ages`字典仍然会返回修改前的值`23`：
```swift ```swift
copiedAges["Peter"] = 24 copiedAges["Peter"] = 24
println(ages["Peter"]) println(ages["Peter"])
// 输出 "23" // 输出 "23"
``` ```
### 数组的赋值和拷贝行为 ### 数组的赋值和拷贝行为
在Swift 中，`数组（Arrays）`类型的赋值和拷贝行为要比`字典（Dictionary）`类型的复杂的多。当操作数组内容时，`数组（Array）`能提供接近C语言的的性能，并且拷贝行为只有在必要时才会发生。 在Swift 中，`数组（Arrays）`类型的赋值和拷贝行为要比`字典（Dictionary）`类型的复杂的多。当操作数组内容时，`数组（Array）`能提供接近C语言的的性能，并且拷贝行为只有在必要时才会发生。
如果你将一个`数组（Array）`实例赋给一个变量或常量，或者将其作为参数传递给函数或方法调用，在事件发生时数组的内容`不`会被拷贝。相反，数组公用相同的元素序列。当你在一个数组内修改某一元素，修改结果也会在另一数组显示。 如果你将一个`数组（Array）`实例赋给一个变量或常量，或者将其作为参数传递给函数或方法调用，在事件发生时数组的内容`不`会被拷贝。相反，数组公用相同的元素序列。当你在一个数组内修改某一元素，修改结果也会在另一数组显示。
对数组来说，拷贝行为仅仅当操作有可能修改数组`长度`时才会发生。这种行为包括了附加（appending）,插入（inserting）,删除（removing）或者使用范围下标（ranged subscript）去替换这一范围内的元素。只有当数组拷贝确要发生时，数组内容的行为规则与字典中键值的相同，参见章节[集合（collection）类型的赋值与复制行为](#assignment_and_copy_behavior_for_collection_types。 对数组来说，拷贝行为仅仅当操作有可能修改数组`长度`时才会发生。这种行为包括了附加（appending）,插入（inserting）,删除（removing）或者使用范围下标（ranged subscript）去替换这一范围内的元素。只有当数组拷贝确要发生时，数组内容的行为规则与字典中键值的相同，参见章节[集合（collection）类型的赋值与复制行为](#assignment_and_copy_behavior_for_collection_types。
下面的示例将一个`整数（Int）`数组赋给了一个名为`a`的变量，继而又被赋给了变量`b`和`c`： 下面的示例将一个`整数（Int）`数组赋给了一个名为`a`的变量，继而又被赋给了变量`b`和`c`：
```swift ```swift
var a = [1, 2, 3] var a = [1, 2, 3]
var b = a var b = a
var c = a var c = a
``` ```
我们可以在`a`,`b`,`c`上使用下标语法以得到数组的第一个元素： 我们可以在`a`,`b`,`c`上使用下标语法以得到数组的第一个元素：
```swift ```swift
println(a[0]) println(a[0])
// 1 // 1
println(b[0]) println(b[0])
// 1 // 1
println(c[0]) println(c[0])
// 1 // 1
``` ```
如果通过下标语法修改数组中某一元素的值，那么`a`,`b`,`c`中的相应值都会发生改变。请注意当你用下标语法修改某一值时，并没有拷贝行为伴随发生，因为下表语法修改值时没有改变数组长度的可能： 如果通过下标语法修改数组中某一元素的值，那么`a`,`b`,`c`中的相应值都会发生改变。请注意当你用下标语法修改某一值时，并没有拷贝行为伴随发生，因为下表语法修改值时没有改变数组长度的可能：
```swift ```swift
a[0] = 42 a[0] = 42
println(a[0]) println(a[0])
// 42 // 42
println(b[0]) println(b[0])
// 42 // 42
println(c[0]) println(c[0])
// 42 // 42
``` ```
然而，当你给`a`附加新元素时，数组的长度`会`改变。 然而，当你给`a`附加新元素时，数组的长度`会`改变。
当附加元素这一事件发生时，Swift 会创建这个数组的一个拷贝。从此以后，`a`将会是原数组的一个独立拷贝。 当附加元素这一事件发生时，Swift 会创建这个数组的一个拷贝。从此以后，`a`将会是原数组的一个独立拷贝。
拷贝发生后，如果再修改`a`中元素值的话，`a`将会返回与`b`，`c`不同的结果，因为后两者引用的是原来的数组： 拷贝发生后，如果再修改`a`中元素值的话，`a`将会返回与`b`，`c`不同的结果，因为后两者引用的是原来的数组：
```swift ```swift
a.append(4) a.append(4)
a[0] = 777 a[0] = 777
println(a[0]) println(a[0])
// 777 // 777
println(b[0]) println(b[0])
// 42 // 42
println(c[0]) println(c[0])
// 42 // 42
``` ```
### 确保数组的唯一性 ### 确保数组的唯一性
在操作一个数组，或将其传递给函数以及方法调用之前是很有必要先确定这个数组是有一个唯一拷贝的。通过在数组变量上调用`unshare`方法来确定数组引用的唯一性。（当数组赋给常量时，不能调用`unshare`方法） 在操作一个数组，或将其传递给函数以及方法调用之前是很有必要先确定这个数组是有一个唯一拷贝的。通过在数组变量上调用`unshare`方法来确定数组引用的唯一性。（当数组赋给常量时，不能调用`unshare`方法）
如果一个数组被多个变量引用，在其中的一个变量上调用`unshare`方法，则会拷贝此数组，此时这个变量将会有属于它自己的独立数组拷贝。当数组仅被一个变量引用时，则不会有拷贝发生。 如果一个数组被多个变量引用，在其中的一个变量上调用`unshare`方法，则会拷贝此数组，此时这个变量将会有属于它自己的独立数组拷贝。当数组仅被一个变量引用时，则不会有拷贝发生。
在上一个示例的最后，`b`和`c`都引用了同一个数组。此时在`b`上调用`unshare`方法则会将`b`变成一个唯一个拷贝： 在上一个示例的最后，`b`和`c`都引用了同一个数组。此时在`b`上调用`unshare`方法则会将`b`变成一个唯一个拷贝：
```swift ```swift
b.unshare() b.unshare()
``` ```
在`unshare`方法调用后再修改`b`中第一个元素的值，这三个数组（`a`,`b`,`c`）会返回不同的三个值： 在`unshare`方法调用后再修改`b`中第一个元素的值，这三个数组（`a`,`b`,`c`）会返回不同的三个值：
```swift ```swift
b[0] = -105 b[0] = -105
println(a[0]) println(a[0])
// 77 // 77
println(b[0]) println(b[0])
// -105 // -105
println(c[0]) println(c[0])
// 42 // 42
``` ```
### 判定两个数组是否共用相同元素 ### 判定两个数组是否共用相同元素
我们通过使用恒等运算符（identity operators）（ === 和 !==）来判定两个数组或子数组共用相同的储存空间或元素。 我们通过使用恒等运算符（identity operators）（ === 和 !==）来判定两个数组或子数组共用相同的储存空间或元素。
下面这个示例使用了“等同（identical to）” 运算符（===） 来判定`b`和`c`是否共用相同的数组元素： 下面这个示例使用了“等同（identical to）” 运算符（===） 来判定`b`和`c`是否共用相同的数组元素：
```swift ```swift
if b === c { if b === c {
println("b and c still share the same array elements.") println("b and c still share the same array elements.")
} else { } else {
println("b and c now refer to two independent sets of array elements.") println("b and c now refer to two independent sets of array elements.")
} }
``` ```
```swift ```swift
// 输出 "b and c now refer totwo independent sets of array elements." // 输出 "b and c now refer totwo independent sets of array elements."
``` ```
此外，我们还可以使用恒等运算符来判定两个子数组是否共用相同的元素。下面这个示例中，比较了`b`的两个相等的子数组，并且确定了这两个子数组都引用相同的元素： 此外，我们还可以使用恒等运算符来判定两个子数组是否共用相同的元素。下面这个示例中，比较了`b`的两个相等的子数组，并且确定了这两个子数组都引用相同的元素：
```swift ```swift
if b[0...1] === b[0...1] { if b[0...1] === b[0...1] {
println("These two subarrays share the same elements.") println("These two subarrays share the same elements.")
} else { } else {
println("These two subarrays do not share the same elements.") println("These two subarrays do not share the same elements.")
} }
// 输出 "These two subarrays share the same elements." // 输出 "These two subarrays share the same elements."
``` ```
### 强制复制数组 ### 强制复制数组
我们通过调用数组的`copy`方法进行强制显性复制。这个方法对数组进行了浅拷贝（shallow copy）,并且返回一个包含此拷贝的新数组。 我们通过调用数组的`copy`方法进行强制显性复制。这个方法对数组进行了浅拷贝（shallow copy）,并且返回一个包含此拷贝的新数组。
下面这个示例中定义了一个`names`数组，其包含了七个人名。还定义了一个`copiedNames`变量，用以储存在`names`上调用`copy`方法所返回的结果： 下面这个示例中定义了一个`names`数组，其包含了七个人名。还定义了一个`copiedNames`变量，用以储存在`names`上调用`copy`方法所返回的结果：
```swift ```swift
var names = ["Mohsen", "Hilary", "Justyn", "Amy", "Rich", "Graham", "Vic"] var names = ["Mohsen", "Hilary", "Justyn", "Amy", "Rich", "Graham", "Vic"]
var copiedNames = names.copy() var copiedNames = names.copy()
``` ```
我们可以通过修改一个数组中某元素，并且检查另一个数组中对应元素的方法来判定`names`数组确已被复制。如果你将`copiedNames`中第一个元素从"`Mohsen`"修改为"`Mo`",则`names`数组返回的仍是拷贝发生前的"`Mohsen`"： 我们可以通过修改一个数组中某元素，并且检查另一个数组中对应元素的方法来判定`names`数组确已被复制。如果你将`copiedNames`中第一个元素从"`Mohsen`"修改为"`Mo`",则`names`数组返回的仍是拷贝发生前的"`Mohsen`"：
```swift ```swift
copiedName[0] = "Mo" copiedName[0] = "Mo"
println(name[0]) println(name[0])
// 输出 "Mohsen" // 输出 "Mohsen"
``` ```
> 注意： > 注意：
如果你仅需要确保你对数组的引用是唯一引用，请调用`unshare`方法，而不是`copy`方法。`unshare`方法仅会在确有必要时才会创建数组拷贝。`copy`方法会在任何时候都创建一个新的拷贝，即使引用已经是唯一引用。 如果你仅需要确保你对数组的引用是唯一引用，请调用`unshare`方法，而不是`copy`方法。`unshare`方法仅会在确有必要时才会创建数组拷贝。`copy`方法会在任何时候都创建一个新的拷贝，即使引用已经是唯一引用。

856
source/chapter2/10_Properties.md
View File

@ -1,428 +1,428 @@
> 翻译：[shinyzhu](https://github.com/shinyzhu) > 翻译：[shinyzhu](https://github.com/shinyzhu)
> 校对：[pp-prog](https://github.com/pp-prog) > 校对：[pp-prog](https://github.com/pp-prog)
# 属性 (Properties) # 属性 (Properties)
--- ---
本页包含内容： 本页包含内容：
- [存储属性（Stored Properties）](#stored_properties) - [存储属性（Stored Properties）](#stored_properties)
- [计算属性（Computed Properties）](#computed_properties) - [计算属性（Computed Properties）](#computed_properties)
- [属性监视器（Property Observers）](#property_observers) - [属性监视器（Property Observers）](#property_observers)
- [全局变量和局部变量（Global and Local Variables）](global_and_local_variables) - [全局变量和局部变量（Global and Local Variables）](global_and_local_variables)
- [类型属性（Type Properties）](#type_properties) - [类型属性（Type Properties）](#type_properties)
**属性**将值跟特定的类、结构或枚举关联。存储属性存储常量或变量作为实例的一部分，计算属性计算（而不是存储）一个值。计算属性可以用于类、结构体和枚举里，存储属性只能用于类和结构体。 **属性**将值跟特定的类、结构或枚举关联。存储属性存储常量或变量作为实例的一部分，计算属性计算（而不是存储）一个值。计算属性可以用于类、结构体和枚举里，存储属性只能用于类和结构体。
存储属性和计算属性通常用于特定类型的实例，但是，属性也可以直接用于类型本身，这种属性称为类型属性。 存储属性和计算属性通常用于特定类型的实例，但是，属性也可以直接用于类型本身，这种属性称为类型属性。
另外，还可以定义属性监视器来监控属性值的变化，以此来触发一个自定义的操作。属性监视器可以添加到自己写的存储属性上，也可以添加到从父类继承的属性上。 另外，还可以定义属性监视器来监控属性值的变化，以此来触发一个自定义的操作。属性监视器可以添加到自己写的存储属性上，也可以添加到从父类继承的属性上。
<a name="stored_properties"></a> <a name="stored_properties"></a>
## 存储属性 ## 存储属性
简单来说，一个存储属性就是存储在特定类或结构体的实例里的一个常量或变量，存储属性可以是*变量存储属性*（用关键字`var`定义），也可以是*常量存储属性*（用关键字`let`定义）。 简单来说，一个存储属性就是存储在特定类或结构体的实例里的一个常量或变量，存储属性可以是*变量存储属性*（用关键字`var`定义），也可以是*常量存储属性*（用关键字`let`定义）。
可以在定义存储属性的时候指定默认值，请参考[构造过程](../chapter2/14_Initialization.html)一章的[默认属性值](../chapter2/14_Initialization.html#default_property_values)一节。也可以在构造过程中设置或修改存储属性的值，甚至修改常量存储属性的值，请参考[构造过程](../chapter2/14_Initialization.html)一章的[在初始化阶段修改常量存储属性](../chapter2/14_Initialization.html#modifying_constant_properties_during_initialization)一节。 可以在定义存储属性的时候指定默认值，请参考[构造过程](../chapter2/14_Initialization.html)一章的[默认属性值](../chapter2/14_Initialization.html#default_property_values)一节。也可以在构造过程中设置或修改存储属性的值，甚至修改常量存储属性的值，请参考[构造过程](../chapter2/14_Initialization.html)一章的[在初始化阶段修改常量存储属性](../chapter2/14_Initialization.html#modifying_constant_properties_during_initialization)一节。
下面的例子定义了一个名为`FixedLengthRange`的结构体，它描述了一个在创建后无法修改值域宽度的区间： 下面的例子定义了一个名为`FixedLengthRange`的结构体，它描述了一个在创建后无法修改值域宽度的区间：
```swift ```swift
struct FixedLengthRange { struct FixedLengthRange {
var firstValue: Int var firstValue: Int
let length: Int let length: Int
} }
var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3) var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)
// 该区间表示整数0，1，2 // 该区间表示整数0，1，2
rangeOfThreeItems.firstValue = 6 rangeOfThreeItems.firstValue = 6
// 该区间现在表示整数6，7，8 // 该区间现在表示整数6，7，8
``` ```
`FixedLengthRange`的实例包含一个名为`firstValue`的变量存储属性和一个名为`length`的常量存储属性。在上面的例子中，`length`在创建实例的时候被赋值，因为它是一个常量存储属性，所以之后无法修改它的值。 `FixedLengthRange`的实例包含一个名为`firstValue`的变量存储属性和一个名为`length`的常量存储属性。在上面的例子中，`length`在创建实例的时候被赋值，因为它是一个常量存储属性，所以之后无法修改它的值。
<a name="stored_properties_of_constant_structure_instances"></a> <a name="stored_properties_of_constant_structure_instances"></a>
### 常量和存储属性 ### 常量和存储属性
如果创建了一个结构体的实例并赋值给一个常量，则无法修改实例的任何属性，即使定义了变量存储属性： 如果创建了一个结构体的实例并赋值给一个常量，则无法修改实例的任何属性，即使定义了变量存储属性：
```swift ```swift
let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4) let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
// 该区间表示整数0，1，2，3 // 该区间表示整数0，1，2，3
rangeOfFourItems.firstValue = 6 rangeOfFourItems.firstValue = 6
// 尽管 firstValue 是个变量属性，这里还是会报错 // 尽管 firstValue 是个变量属性，这里还是会报错
``` ```
因为`rangeOfFourItems`声明成了常量（用`let`关键字），即使`firstValue`是一个变量属性，也无法再修改它了。 因为`rangeOfFourItems`声明成了常量（用`let`关键字），即使`firstValue`是一个变量属性，也无法再修改它了。
这种行为是由于结构体（struct）属于*值类型*。当值类型的实例被声明为常量的时候，它的所有属性也就成了常量。 这种行为是由于结构体（struct）属于*值类型*。当值类型的实例被声明为常量的时候，它的所有属性也就成了常量。
属于*引用类型*的类（class）则不一样，把一个引用类型的实例赋给一个常量后，仍然可以修改实例的变量属性。 属于*引用类型*的类（class）则不一样，把一个引用类型的实例赋给一个常量后，仍然可以修改实例的变量属性。
<a name="lazy_stored_properties"></a> <a name="lazy_stored_properties"></a>
### 延迟存储属性 ### 延迟存储属性
延迟存储属性是指当第一次被调用的时候才会计算其初始值的属性。在属性声明前使用`@lazy`来标示一个延迟存储属性。 延迟存储属性是指当第一次被调用的时候才会计算其初始值的属性。在属性声明前使用`@lazy`来标示一个延迟存储属性。
> 注意： > 注意：
> 必须将延迟存储属性声明成变量（使用`var`关键字），因为属性的值在实例构造完成之前可能无法得到。而常量属性在构造过程完成之前必须要有初始值，因此无法声明成延迟属性。 > 必须将延迟存储属性声明成变量（使用`var`关键字），因为属性的值在实例构造完成之前可能无法得到。而常量属性在构造过程完成之前必须要有初始值，因此无法声明成延迟属性。
延迟属性很有用，当属性的值依赖于在实例的构造过程结束前无法知道具体值的外部因素时，或者当属性的值需要复杂或大量计算时，可以只在需要的时候来计算它。 延迟属性很有用，当属性的值依赖于在实例的构造过程结束前无法知道具体值的外部因素时，或者当属性的值需要复杂或大量计算时，可以只在需要的时候来计算它。
下面的例子使用了延迟存储属性来避免复杂类的不必要的初始化。例子中定义了`DataImporter`和`DataManager`两个类，下面是部分代码： 下面的例子使用了延迟存储属性来避免复杂类的不必要的初始化。例子中定义了`DataImporter`和`DataManager`两个类，下面是部分代码：
```swift ```swift
class DataImporter { class DataImporter {
/* /*
DataImporter 是一个将外部文件中的数据导入的类。 DataImporter 是一个将外部文件中的数据导入的类。
这个类的初始化会消耗不少时间。 这个类的初始化会消耗不少时间。
*/ */
var fileName = "data.txt" var fileName = "data.txt"
// 这是提供数据导入功能 // 这是提供数据导入功能
} }
class DataManager { class DataManager {
@lazy var importer = DataImporter() @lazy var importer = DataImporter()
var data = String[]() var data = String[]()
// 这是提供数据管理功能 // 这是提供数据管理功能
} }
let manager = DataManager() let manager = DataManager()
manager.data += "Some data" manager.data += "Some data"
manager.data += "Some more data" manager.data += "Some more data"
// DataImporter 实例的 importer 属性还没有被创建 // DataImporter 实例的 importer 属性还没有被创建
``` ```
`DataManager`类包含一个名为`data`的存储属性，初始值是一个空的字符串（`String`）数组。虽然没有写出全部代码，`DataManager`类的目的是管理和提供对这个字符串数组的访问。 `DataManager`类包含一个名为`data`的存储属性，初始值是一个空的字符串（`String`）数组。虽然没有写出全部代码，`DataManager`类的目的是管理和提供对这个字符串数组的访问。
`DataManager`的一个功能是从文件导入数据，该功能由`DataImporter`类提供，`DataImporter`需要消耗不少时间完成初始化：因为它的实例在初始化时可能要打开文件，还要读取文件内容到内存。 `DataManager`的一个功能是从文件导入数据，该功能由`DataImporter`类提供，`DataImporter`需要消耗不少时间完成初始化：因为它的实例在初始化时可能要打开文件，还要读取文件内容到内存。
`DataManager`也可能不从文件中导入数据。所以当`DataManager`的实例被创建时，没必要创建一个`DataImporter`的实例，更明智的是当用到`DataImporter`的时候才去创建它。 `DataManager`也可能不从文件中导入数据。所以当`DataManager`的实例被创建时，没必要创建一个`DataImporter`的实例，更明智的是当用到`DataImporter`的时候才去创建它。
由于使用了`@lazy`，`importer`属性只有在第一次被访问的时候才被创建。比如访问它的属性`fileName`时： 由于使用了`@lazy`，`importer`属性只有在第一次被访问的时候才被创建。比如访问它的属性`fileName`时：
```swift ```swift
println(manager.importer.fileName) println(manager.importer.fileName)
// DataImporter 实例的 importer 属性现在被创建了 // DataImporter 实例的 importer 属性现在被创建了
// 输出 "data.txt” // 输出 "data.txt”
``` ```
<a name="stored_properties_and_instance_variables"></a> <a name="stored_properties_and_instance_variables"></a>
### 存储属性和实例变量 ### 存储属性和实例变量
如果您有过 Objective-C 经验，应该知道有两种方式在类实例存储值和引用。对于属性来说，也可以使用实例变量作为属性值的后端存储。 如果您有过 Objective-C 经验，应该知道有两种方式在类实例存储值和引用。对于属性来说，也可以使用实例变量作为属性值的后端存储。
Swift 编程语言中把这些理论统一用属性来实现。Swift 中的属性没有对应的实例变量，属性的后端存储也无法直接访问。这就避免了不同场景下访问方式的困扰，同时也将属性的定义简化成一个语句。 Swift 编程语言中把这些理论统一用属性来实现。Swift 中的属性没有对应的实例变量，属性的后端存储也无法直接访问。这就避免了不同场景下访问方式的困扰，同时也将属性的定义简化成一个语句。
一个类型中属性的全部信息——包括命名、类型和内存管理特征——都在唯一一个地方（类型定义中）定义。 一个类型中属性的全部信息——包括命名、类型和内存管理特征——都在唯一一个地方（类型定义中）定义。
<a name="computed_properties"></a> <a name="computed_properties"></a>
## 计算属性 ## 计算属性
除存储属性外，类、结构体和枚举可以定义*计算属性*，计算属性不直接存储值，而是提供一个 getter 来获取值，一个可选的 setter 来间接设置其他属性或变量的值。 除存储属性外，类、结构体和枚举可以定义*计算属性*，计算属性不直接存储值，而是提供一个 getter 来获取值，一个可选的 setter 来间接设置其他属性或变量的值。
```swift ```swift
struct Point { struct Point {
var x = 0.0, y = 0.0 var x = 0.0, y = 0.0
} }
struct Size { struct Size {
var width = 0.0, height = 0.0 var width = 0.0, height = 0.0
} }
struct Rect { struct Rect {
var origin = Point() var origin = Point()
var size = Size() var size = Size()
var center: Point { var center: Point {
get { get {
let centerX = origin.x + (size.width / 2) let centerX = origin.x + (size.width / 2)
let centerY = origin.y + (size.height / 2) let centerY = origin.y + (size.height / 2)
return Point(x: centerX, y: centerY) return Point(x: centerX, y: centerY)
} }
set(newCenter) { set(newCenter) {
origin.x = newCenter.x - (size.width / 2) origin.x = newCenter.x - (size.width / 2)
origin.y = newCenter.y - (size.height / 2) origin.y = newCenter.y - (size.height / 2)
} }
} }
} }
var square = Rect(origin: Point(x: 0.0, y: 0.0), var square = Rect(origin: Point(x: 0.0, y: 0.0),
size: Size(width: 10.0, height: 10.0)) size: Size(width: 10.0, height: 10.0))
let initialSquareCenter = square.center let initialSquareCenter = square.center
square.center = Point(x: 15.0, y: 15.0) square.center = Point(x: 15.0, y: 15.0)
println("square.origin is now at (\(square.origin.x), \(square.origin.y))") println("square.origin is now at (\(square.origin.x), \(square.origin.y))")
// 输出 "square.origin is now at (10.0, 10.0)” // 输出 "square.origin is now at (10.0, 10.0)”
``` ```
这个例子定义了 3 个几何形状的结构体： 这个例子定义了 3 个几何形状的结构体：
- `Point`封装了一个`(x, y)`的坐标 - `Point`封装了一个`(x, y)`的坐标
- `Size`封装了一个`width`和`height` - `Size`封装了一个`width`和`height`
- `Rect`表示一个有原点和尺寸的矩形 - `Rect`表示一个有原点和尺寸的矩形
`Rect`也提供了一个名为`center`的计算属性。一个矩形的中心点可以从原点和尺寸来算出，所以不需要将它以显式声明的`Point`来保存。`Rect`的计算属性`center`提供了自定义的 getter 和 setter 来获取和设置矩形的中心点，就像它有一个存储属性一样。 `Rect`也提供了一个名为`center`的计算属性。一个矩形的中心点可以从原点和尺寸来算出，所以不需要将它以显式声明的`Point`来保存。`Rect`的计算属性`center`提供了自定义的 getter 和 setter 来获取和设置矩形的中心点，就像它有一个存储属性一样。
例子中接下来创建了一个名为`square`的`Rect`实例，初始值原点是`(0, 0)`，宽度高度都是`10`。如图所示蓝色正方形。 例子中接下来创建了一个名为`square`的`Rect`实例，初始值原点是`(0, 0)`，宽度高度都是`10`。如图所示蓝色正方形。
`square`的`center`属性可以通过点运算符（`square.center`）来访问，这会调用 getter 来获取属性的值。跟直接返回已经存在的值不同，getter 实际上通过计算然后返回一个新的`Point`来表示`square`的中心点。如代码所示，它正确返回了中心点`(5, 5)`。 `square`的`center`属性可以通过点运算符（`square.center`）来访问，这会调用 getter 来获取属性的值。跟直接返回已经存在的值不同，getter 实际上通过计算然后返回一个新的`Point`来表示`square`的中心点。如代码所示，它正确返回了中心点`(5, 5)`。
`center`属性之后被设置了一个新的值`(15, 15)`，表示向右上方移动正方形到如图所示橙色正方形的位置。设置属性`center`的值会调用 setter 来修改属性`origin`的`x`和`y`的值，从而实现移动正方形到新的位置。 `center`属性之后被设置了一个新的值`(15, 15)`，表示向右上方移动正方形到如图所示橙色正方形的位置。设置属性`center`的值会调用 setter 来修改属性`origin`的`x`和`y`的值，从而实现移动正方形到新的位置。
<img src="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/computedProperties_2x.png" alt="Computed Properties sample" width="388" height="387" /> <img src="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/computedProperties_2x.png" alt="Computed Properties sample" width="388" height="387" />
<a name="shorthand_setter_declaration"></a> <a name="shorthand_setter_declaration"></a>
### 便捷 setter 声明 ### 便捷 setter 声明
如果计算属性的 setter 没有定义表示新值的参数名，则可以使用默认名称`newValue`。下面是使用了便捷 setter 声明的`Rect`结构体代码： 如果计算属性的 setter 没有定义表示新值的参数名，则可以使用默认名称`newValue`。下面是使用了便捷 setter 声明的`Rect`结构体代码：
```swift ```swift
struct AlternativeRect { struct AlternativeRect {
var origin = Point() var origin = Point()
var size = Size() var size = Size()
var center: Point { var center: Point {
get { get {
let centerX = origin.x + (size.width / 2) let centerX = origin.x + (size.width / 2)
let centerY = origin.y + (size.height / 2) let centerY = origin.y + (size.height / 2)
return Point(x: centerX, y: centerY) return Point(x: centerX, y: centerY)
} }
set { set {
origin.x = newValue.x - (size.width / 2) origin.x = newValue.x - (size.width / 2)
origin.y = newValue.y - (size.height / 2) origin.y = newValue.y - (size.height / 2)
} }
} }
} }
``` ```
<a name="readonly_computed_properties"></a> <a name="readonly_computed_properties"></a>
### 只读计算属性 ### 只读计算属性
只有 getter 没有 setter 的计算属性就是*只读计算属性*。只读计算属性总是返回一个值，可以通过点运算符访问，但不能设置新的值。 只有 getter 没有 setter 的计算属性就是*只读计算属性*。只读计算属性总是返回一个值，可以通过点运算符访问，但不能设置新的值。
<<<<<<< HEAD <<<<<<< HEAD
> 注意： > 注意：
> 必须使用`var`关键字定义计算属性，包括只读计算属性，因为他们的值不是固定的。`let`关键字只用来声明常量属性，表示初始化后再也无法修改的值。 > 必须使用`var`关键字定义计算属性，包括只读计算属性，因为他们的值不是固定的。`let`关键字只用来声明常量属性，表示初始化后再也无法修改的值。
======= =======
> 注意： > 注意：
> >
> 必须使用`var`关键字定义计算属性，包括只读计算属性，因为它们的值不是固定的。`let`关键字只用来声明常量属性，表示初始化后再也无法修改的值。 > 必须使用`var`关键字定义计算属性，包括只读计算属性，因为它们的值不是固定的。`let`关键字只用来声明常量属性，表示初始化后再也无法修改的值。
>>>>>>> a516af6a531a104ec88da0d236ecf389a5ec72af >>>>>>> a516af6a531a104ec88da0d236ecf389a5ec72af
只读计算属性的声明可以去掉`get`关键字和花括号： 只读计算属性的声明可以去掉`get`关键字和花括号：
```swift ```swift
struct Cuboid { struct Cuboid {
var width = 0.0, height = 0.0, depth = 0.0 var width = 0.0, height = 0.0, depth = 0.0
var volume: Double { var volume: Double {
return width * height * depth return width * height * depth
} }
} }
let fourByFiveByTwo = Cuboid(width: 4.0, height: 5.0, depth: 2.0) let fourByFiveByTwo = Cuboid(width: 4.0, height: 5.0, depth: 2.0)
println("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)") println("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")
// 输出 "the volume of fourByFiveByTwo is 40.0" // 输出 "the volume of fourByFiveByTwo is 40.0"
``` ```
这个例子定义了一个名为`Cuboid`的结构体，表示三维空间的立方体，包含`width`、`height`和`depth`属性，还有一个名为`volume`的只读计算属性用来返回立方体的体积。设置`volume`的值毫无意义，因为通过`width`、`height`和`depth`就能算出`volume`。然而，`Cuboid`提供一个只读计算属性来让外部用户直接获取体积是很有用的。 这个例子定义了一个名为`Cuboid`的结构体，表示三维空间的立方体，包含`width`、`height`和`depth`属性，还有一个名为`volume`的只读计算属性用来返回立方体的体积。设置`volume`的值毫无意义，因为通过`width`、`height`和`depth`就能算出`volume`。然而，`Cuboid`提供一个只读计算属性来让外部用户直接获取体积是很有用的。
<a name="property_observers"></a> <a name="property_observers"></a>
## 属性监视器 ## 属性监视器
*属性监视器*监控和响应属性值的变化，每次属性被设置值的时候都会调用属性监视器，甚至新的值和现在的值相同的时候也不例外。 *属性监视器*监控和响应属性值的变化，每次属性被设置值的时候都会调用属性监视器，甚至新的值和现在的值相同的时候也不例外。
可以为除了延迟存储属性之外的其他存储属性添加属性监视器，也可以通过重载属性的方式为继承的属性（包括存储属性和计算属性）添加属性监视器。属性重载请参考[继承](chapter/13_Inheritance.html)一章的[重载](chapter/13_Inheritance.html#overriding)。 可以为除了延迟存储属性之外的其他存储属性添加属性监视器，也可以通过重载属性的方式为继承的属性（包括存储属性和计算属性）添加属性监视器。属性重载请参考[继承](chapter/13_Inheritance.html)一章的[重载](chapter/13_Inheritance.html#overriding)。
> 注意： > 注意：
> 不需要为无法重载的计算属性添加属性监视器，因为可以通过 setter 直接监控和响应值的变化。 > 不需要为无法重载的计算属性添加属性监视器，因为可以通过 setter 直接监控和响应值的变化。
可以为属性添加如下的一个或全部监视器： 可以为属性添加如下的一个或全部监视器：
- `willSet`在设置新的值之前调用 - `willSet`在设置新的值之前调用
- `didSet`在新的值被设置之后立即调用 - `didSet`在新的值被设置之后立即调用
`willSet`监视器会将新的属性值作为固定参数传入，在`willSet`的实现代码中可以为这个参数指定一个名称，如果不指定则参数仍然可用，这时使用默认名称`newValue`表示。 `willSet`监视器会将新的属性值作为固定参数传入，在`willSet`的实现代码中可以为这个参数指定一个名称，如果不指定则参数仍然可用，这时使用默认名称`newValue`表示。
类似地，`didSet`监视器会将旧的属性值作为参数传入，可以为该参数命名或者使用默认参数名`oldValue`。 类似地，`didSet`监视器会将旧的属性值作为参数传入，可以为该参数命名或者使用默认参数名`oldValue`。
<<<<<<< HEAD <<<<<<< HEAD
> 注意： > 注意：
> `willSet`和`didSet`监视器在属性初始化过程中不会被调用，他们只会当属性的值在初始化之外的地方被设置时被调用。 > `willSet`和`didSet`监视器在属性初始化过程中不会被调用，他们只会当属性的值在初始化之外的地方被设置时被调用。
======= =======
> 注意： > 注意：
> >
> `willSet`和`didSet`监视器在属性初始化过程中不会被调用，它们只会当属性的值在初始化之外的地方被设置时被调用。 > `willSet`和`didSet`监视器在属性初始化过程中不会被调用，它们只会当属性的值在初始化之外的地方被设置时被调用。
>>>>>>> a516af6a531a104ec88da0d236ecf389a5ec72af >>>>>>> a516af6a531a104ec88da0d236ecf389a5ec72af
这里是一个`willSet`和`didSet`的实际例子，其中定义了一个名为`StepCounter`的类，用来统计当人步行时的总步数，可以跟计步器或其他日常锻炼的统计装置的输入数据配合使用。 这里是一个`willSet`和`didSet`的实际例子，其中定义了一个名为`StepCounter`的类，用来统计当人步行时的总步数，可以跟计步器或其他日常锻炼的统计装置的输入数据配合使用。
```swift ```swift
class StepCounter { class StepCounter {
var totalSteps: Int = 0 { var totalSteps: Int = 0 {
willSet(newTotalSteps) { willSet(newTotalSteps) {
println("About to set totalSteps to \(newTotalSteps)") println("About to set totalSteps to \(newTotalSteps)")
} }
didSet { didSet {
if totalSteps > oldValue { if totalSteps > oldValue {
println("Added \(totalSteps - oldValue) steps") println("Added \(totalSteps - oldValue) steps")
} }
} }
} }
} }
let stepCounter = StepCounter() let stepCounter = StepCounter()
stepCounter.totalSteps = 200 stepCounter.totalSteps = 200
// About to set totalSteps to 200 // About to set totalSteps to 200
// Added 200 steps // Added 200 steps
stepCounter.totalSteps = 360 stepCounter.totalSteps = 360
// About to set totalSteps to 360 // About to set totalSteps to 360
// Added 160 steps // Added 160 steps
stepCounter.totalSteps = 896 stepCounter.totalSteps = 896
// About to set totalSteps to 896 // About to set totalSteps to 896
// Added 536 steps // Added 536 steps
``` ```
`StepCounter`类定义了一个`Int`类型的属性`totalSteps`，它是一个存储属性，包含`willSet`和`didSet`监视器。 `StepCounter`类定义了一个`Int`类型的属性`totalSteps`，它是一个存储属性，包含`willSet`和`didSet`监视器。
当`totalSteps`设置新值的时候，它的`willSet`和`didSet`监视器都会被调用，甚至当新的值和现在的值完全相同也会调用。 当`totalSteps`设置新值的时候，它的`willSet`和`didSet`监视器都会被调用，甚至当新的值和现在的值完全相同也会调用。
例子中的`willSet`监视器将表示新值的参数自定义为`newTotalSteps`，这个监视器只是简单的将新的值输出。 例子中的`willSet`监视器将表示新值的参数自定义为`newTotalSteps`，这个监视器只是简单的将新的值输出。
`didSet`监视器在`totalSteps`的值改变后被调用，它把新的值和旧的值进行对比，如果总的步数增加了，就输出一个消息表示增加了多少步。`didSet`没有提供自定义名称，所以默认值`oldValue`表示旧值的参数名。 `didSet`监视器在`totalSteps`的值改变后被调用，它把新的值和旧的值进行对比，如果总的步数增加了，就输出一个消息表示增加了多少步。`didSet`没有提供自定义名称，所以默认值`oldValue`表示旧值的参数名。
> 注意： > 注意：
> 如果在`didSet`监视器里为属性赋值，这个值会替换监视器之前设置的值。 > 如果在`didSet`监视器里为属性赋值，这个值会替换监视器之前设置的值。
<a name="global_and_local_variables"></a> <a name="global_and_local_variables"></a>
##全局变量和局部变量 ##全局变量和局部变量
计算属性和属性监视器所描述的模式也可以用于*全局变量*和*局部变量*，全局变量是在函数、方法、闭包或任何类型之外定义的变量，局部变量是在函数、方法或闭包内部定义的变量。 计算属性和属性监视器所描述的模式也可以用于*全局变量*和*局部变量*，全局变量是在函数、方法、闭包或任何类型之外定义的变量，局部变量是在函数、方法或闭包内部定义的变量。
前面章节提到的全局或局部变量都属于存储型变量，跟存储属性类似，它提供特定类型的存储空间，并允许读取和写入。 前面章节提到的全局或局部变量都属于存储型变量，跟存储属性类似，它提供特定类型的存储空间，并允许读取和写入。
另外，在全局或局部范围都可以定义计算型变量和为存储型变量定义监视器，计算型变量跟计算属性一样，返回一个计算的值而不是存储值，声明格式也完全一样。 另外，在全局或局部范围都可以定义计算型变量和为存储型变量定义监视器，计算型变量跟计算属性一样，返回一个计算的值而不是存储值，声明格式也完全一样。
> 注意： > 注意：
> 全局的常量或变量都是延迟计算的，跟[延迟存储属性](#lazy_stored_properties)相似，不同的地方在于，全局的常量或变量不需要标记`@lazy`特性。 > 全局的常量或变量都是延迟计算的，跟[延迟存储属性](#lazy_stored_properties)相似，不同的地方在于，全局的常量或变量不需要标记`@lazy`特性。
> 局部范围的常量或变量不会延迟计算。 > 局部范围的常量或变量不会延迟计算。
<a name="type_properties"></a> <a name="type_properties"></a>
##类型属性 ##类型属性
实例的属性属于一个特定类型实例，每次类型实例化后都拥有自己的一套属性值，实例之间的属性相互独立。 实例的属性属于一个特定类型实例，每次类型实例化后都拥有自己的一套属性值，实例之间的属性相互独立。
也可以为类型本身定义属性，不管类型有多少个实例，这些属性都只有唯一一份。这种属性就是*类型属性*。 也可以为类型本身定义属性，不管类型有多少个实例，这些属性都只有唯一一份。这种属性就是*类型属性*。
类型属性用于定义特定类型所有实例共享的数据，比如所有实例都能用的一个常量（就像 C 语言中的静态常量），或者所有实例都能访问的一个变量（就像 C 语言中的静态变量）。 类型属性用于定义特定类型所有实例共享的数据，比如所有实例都能用的一个常量（就像 C 语言中的静态常量），或者所有实例都能访问的一个变量（就像 C 语言中的静态变量）。
对于值类型（指结构体和枚举）可以定义存储型和计算型类型属性，对于类（class）则只能定义计算型类型属性。 对于值类型（指结构体和枚举）可以定义存储型和计算型类型属性，对于类（class）则只能定义计算型类型属性。
值类型的存储型类型属性可以是变量或常量，计算型类型属性跟实例的计算属性一样定义成变量属性。 值类型的存储型类型属性可以是变量或常量，计算型类型属性跟实例的计算属性一样定义成变量属性。
> 注意： > 注意：
> 跟实例的存储属性不同，必须给存储型类型属性指定默认值，因为类型本身无法在初始化过程中使用构造器给类型属性赋值。 > 跟实例的存储属性不同，必须给存储型类型属性指定默认值，因为类型本身无法在初始化过程中使用构造器给类型属性赋值。
<a name="type_property_syntax"></a> <a name="type_property_syntax"></a>
###类型属性语法 ###类型属性语法
在 C 或 Objective-C 中，静态常量和静态变量的定义是通过特定类型加上`global`关键字。在 Swift 编程语言中，类型属性是作为类型定义的一部分写在类型最外层的花括号内，因此它的作用范围也就在类型支持的范围内。 在 C 或 Objective-C 中，静态常量和静态变量的定义是通过特定类型加上`global`关键字。在 Swift 编程语言中，类型属性是作为类型定义的一部分写在类型最外层的花括号内，因此它的作用范围也就在类型支持的范围内。
使用关键字`static`来定义值类型的类型属性，关键字`class`来为类（class）定义类型属性。下面的例子演示了存储型和计算型类型属性的语法： 使用关键字`static`来定义值类型的类型属性，关键字`class`来为类（class）定义类型属性。下面的例子演示了存储型和计算型类型属性的语法：
```swift ```swift
struct SomeStructure { struct SomeStructure {
static var storedTypeProperty = "Some value." static var storedTypeProperty = "Some value."
static var computedTypeProperty: Int { static var computedTypeProperty: Int {
// 这里返回一个 Int 值 // 这里返回一个 Int 值
} }
} }
enum SomeEnumeration { enum SomeEnumeration {
static var storedTypeProperty = "Some value." static var storedTypeProperty = "Some value."
static var computedTypeProperty: Int { static var computedTypeProperty: Int {
// 这里返回一个 Int 值 // 这里返回一个 Int 值
} }
} }
class SomeClass { class SomeClass {
class var computedTypeProperty: Int { class var computedTypeProperty: Int {
// 这里返回一个 Int 值 // 这里返回一个 Int 值
} }
} }
``` ```
> 注意： > 注意：
> 例子中的计算型类型属性是只读的，但也可以定义可读可写的计算型类型属性，跟实例计算属性的语法类似。 > 例子中的计算型类型属性是只读的，但也可以定义可读可写的计算型类型属性，跟实例计算属性的语法类似。
<a name="querying_and_setting_type_properties"></a> <a name="querying_and_setting_type_properties"></a>
###获取和设置类型属性的值 ###获取和设置类型属性的值
跟实例的属性一样，类型属性的访问也是通过点运算符来进行，但是，类型属性是通过类型本身来获取和设置，而不是通过实例。比如： 跟实例的属性一样，类型属性的访问也是通过点运算符来进行，但是，类型属性是通过类型本身来获取和设置，而不是通过实例。比如：
```swift ```swift
println(SomeClass.computedTypeProperty) println(SomeClass.computedTypeProperty)
// 输出 "42" // 输出 "42"
println(SomeStructure.storedTypeProperty) println(SomeStructure.storedTypeProperty)
// 输出 "Some value." // 输出 "Some value."
SomeStructure.storedTypeProperty = "Another value." SomeStructure.storedTypeProperty = "Another value."
println(SomeStructure.storedTypeProperty) println(SomeStructure.storedTypeProperty)
// 输出 "Another value.” // 输出 "Another value.”
``` ```
下面的例子定义了一个结构体，使用两个存储型类型属性来表示多个声道的声音电平值，每个声道有一个 0 到 10 之间的整数表示声音电平值。 下面的例子定义了一个结构体，使用两个存储型类型属性来表示多个声道的声音电平值，每个声道有一个 0 到 10 之间的整数表示声音电平值。
后面的图表展示了如何联合使用两个声道来表示一个立体声的声音电平值。当声道的电平值是 0，没有一个灯会亮；当声道的电平值是 10，所有灯点亮。本图中，左声道的电平是 9，右声道的电平是 7。 后面的图表展示了如何联合使用两个声道来表示一个立体声的声音电平值。当声道的电平值是 0，没有一个灯会亮；当声道的电平值是 10，所有灯点亮。本图中，左声道的电平是 9，右声道的电平是 7。
<img src="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/staticPropertiesVUMeter_2x.png" alt="Static Properties VUMeter" width="243" height="357" /> <img src="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/staticPropertiesVUMeter_2x.png" alt="Static Properties VUMeter" width="243" height="357" />
上面所描述的声道模型使用`AudioChannel`结构体来表示： 上面所描述的声道模型使用`AudioChannel`结构体来表示：
```swift ```swift
struct AudioChannel { struct AudioChannel {
static let thresholdLevel = 10 static let thresholdLevel = 10
static var maxInputLevelForAllChannels = 0 static var maxInputLevelForAllChannels = 0
var currentLevel: Int = 0 { var currentLevel: Int = 0 {
didSet { didSet {
if currentLevel > AudioChannel.thresholdLevel { if currentLevel > AudioChannel.thresholdLevel {
// 将新电平值设置为阀值 // 将新电平值设置为阀值
currentLevel = AudioChannel.thresholdLevel currentLevel = AudioChannel.thresholdLevel
} }
if currentLevel > AudioChannel.maxInputLevelForAllChannels { if currentLevel > AudioChannel.maxInputLevelForAllChannels {
// 存储当前电平值作为新的最大输入电平 // 存储当前电平值作为新的最大输入电平
AudioChannel.maxInputLevelForAllChannels = currentLevel AudioChannel.maxInputLevelForAllChannels = currentLevel
} }
} }
} }
} }
``` ```
结构`AudioChannel`定义了 2 个存储型类型属性来实现上述功能。第一个是`thresholdLevel`，表示声音电平的最大上限阈值，它是一个取值为 10 的常量，对所有实例都可见，如果声音电平高于 10，则取最大上限值 10（见后面描述）。 结构`AudioChannel`定义了 2 个存储型类型属性来实现上述功能。第一个是`thresholdLevel`，表示声音电平的最大上限阈值，它是一个取值为 10 的常量，对所有实例都可见，如果声音电平高于 10，则取最大上限值 10（见后面描述）。
第二个类型属性是变量存储型属性`maxInputLevelForAllChannels`，它用来表示所有`AudioChannel`实例的电平值的最大值，初始值是 0。 第二个类型属性是变量存储型属性`maxInputLevelForAllChannels`，它用来表示所有`AudioChannel`实例的电平值的最大值，初始值是 0。
`AudioChannel`也定义了一个名为`currentLevel`的实例存储属性，表示当前声道现在的电平值，取值为 0 到 10。 `AudioChannel`也定义了一个名为`currentLevel`的实例存储属性，表示当前声道现在的电平值，取值为 0 到 10。
属性`currentLevel`包含`didSet`属性监视器来检查每次新设置后的属性值，有如下两个检查： 属性`currentLevel`包含`didSet`属性监视器来检查每次新设置后的属性值，有如下两个检查：
- 如果`currentLevel`的新值大于允许的阈值`thresholdLevel`，属性监视器将`currentLevel`的值限定为阈值`thresholdLevel`。 - 如果`currentLevel`的新值大于允许的阈值`thresholdLevel`，属性监视器将`currentLevel`的值限定为阈值`thresholdLevel`。
- 如果修正后的`currentLevel`值大于任何之前任意`AudioChannel`实例中的值，属性监视器将新值保存在静态属性`maxInputLevelForAllChannels`中。 - 如果修正后的`currentLevel`值大于任何之前任意`AudioChannel`实例中的值，属性监视器将新值保存在静态属性`maxInputLevelForAllChannels`中。
> 注意： > 注意：
> 在第一个检查过程中，`didSet`属性监视器将`currentLevel`设置成了不同的值，但这时不会再次调用属性监视器。 > 在第一个检查过程中，`didSet`属性监视器将`currentLevel`设置成了不同的值，但这时不会再次调用属性监视器。
可以使用结构体`AudioChannel`来创建表示立体声系统的两个声道`leftChannel`和`rightChannel`： 可以使用结构体`AudioChannel`来创建表示立体声系统的两个声道`leftChannel`和`rightChannel`：
```swift ```swift
var leftChannel = AudioChannel() var leftChannel = AudioChannel()
var rightChannel = AudioChannel() var rightChannel = AudioChannel()
``` ```
如果将左声道的电平设置成 7，类型属性`maxInputLevelForAllChannels`也会更新成 7： 如果将左声道的电平设置成 7，类型属性`maxInputLevelForAllChannels`也会更新成 7：
```swift ```swift
leftChannel.currentLevel = 7 leftChannel.currentLevel = 7
println(leftChannel.currentLevel) println(leftChannel.currentLevel)
// 输出 "7" // 输出 "7"
println(AudioChannel.maxInputLevelForAllChannels) println(AudioChannel.maxInputLevelForAllChannels)
// 输出 "7" // 输出 "7"
``` ```
如果试图将右声道的电平设置成 11，则会将右声道的`currentLevel`修正到最大值 10，同时`maxInputLevelForAllChannels`的值也会更新到 10： 如果试图将右声道的电平设置成 11，则会将右声道的`currentLevel`修正到最大值 10，同时`maxInputLevelForAllChannels`的值也会更新到 10：
```swift ```swift
rightChannel.currentLevel = 11 rightChannel.currentLevel = 11
println(rightChannel.currentLevel) println(rightChannel.currentLevel)
// 输出 "10" // 输出 "10"
println(AudioChannel.maxInputLevelForAllChannels) println(AudioChannel.maxInputLevelForAllChannels)
// 输出 "10" // 输出 "10"
``` ```

618
source/chapter2/11_Methods.md
View File

@ -1,309 +1,309 @@
> 翻译：[pp-prog](https://github.com/pp-prog) > 翻译：[pp-prog](https://github.com/pp-prog)
> 校对：[zqp](https://github.com/zqp) > 校对：[zqp](https://github.com/zqp)
# 方法（Methods） # 方法（Methods）
----------------- -----------------
本页包含内容： 本页包含内容：
- [实例方法(Instance Methods](#instance_methods) - [实例方法(Instance Methods](#instance_methods)
- [类型方法(Type Methods)](#type_methods) - [类型方法(Type Methods)](#type_methods)
**方法**是与某些特定类型相关联的函数。类、结构体、枚举都可以定义实例方法；实例方法为给定类型的实例封装了具体的任务与功能。类、结构体、枚举也可以定义类型方法；类型方法与类型本身相关联。类型方法与 Objective-C 中的类方法（class methods）相似。 **方法**是与某些特定类型相关联的函数。类、结构体、枚举都可以定义实例方法；实例方法为给定类型的实例封装了具体的任务与功能。类、结构体、枚举也可以定义类型方法；类型方法与类型本身相关联。类型方法与 Objective-C 中的类方法（class methods）相似。
结构体和枚举能够定义方法是 Swift 与 C/Objective-C 的主要区别之一。在 Objective-C 中，类是唯一能定义方法的类型。但在 Swift 中，你不仅能选择是否要定义一个类/结构体/枚举，还能灵活的在你创建的类型（类/结构体/枚举）上定义方法。 结构体和枚举能够定义方法是 Swift 与 C/Objective-C 的主要区别之一。在 Objective-C 中，类是唯一能定义方法的类型。但在 Swift 中，你不仅能选择是否要定义一个类/结构体/枚举，还能灵活的在你创建的类型（类/结构体/枚举）上定义方法。
<a name="instance_methods"></a> <a name="instance_methods"></a>
## 实例方法(Instance Methods) ## 实例方法(Instance Methods)
**实例方法**是属于某个特定类、结构体或者枚举类型实例的方法。实例方法提供访问和修改实例属性的方法或提供与实例目的相关的功能，并以此来支撑实例的功能。实例方法的语法与函数完全一致，详情参见[函数](../charpter2/06_Functions.md)。 **实例方法**是属于某个特定类、结构体或者枚举类型实例的方法。实例方法提供访问和修改实例属性的方法或提供与实例目的相关的功能，并以此来支撑实例的功能。实例方法的语法与函数完全一致，详情参见[函数](../charpter2/06_Functions.md)。
实例方法要写在它所属的类型的前后大括号之间。实例方法能够隐式访问它所属类型的所有的其他实例方法和属性。实例方法只能被它所属的类的某个特定实例调用。实例方法不能脱离于现存的实例而被调用。 实例方法要写在它所属的类型的前后大括号之间。实例方法能够隐式访问它所属类型的所有的其他实例方法和属性。实例方法只能被它所属的类的某个特定实例调用。实例方法不能脱离于现存的实例而被调用。
下面的例子，定义一个很简单的类`Counter`，`Counter`能被用来对一个动作发生的次数进行计数： 下面的例子，定义一个很简单的类`Counter`，`Counter`能被用来对一个动作发生的次数进行计数：
```swift ```swift
class Counter { class Counter {
var count = 0 var count = 0
func increment() { func increment() {
count++ count++
} }
func incrementBy(amount: Int) { func incrementBy(amount: Int) {
count += amount count += amount
} }
func reset() { func reset() {
count = 0 count = 0
} }
} }
``` ```
`Counter`类定义了三个实例方法： `Counter`类定义了三个实例方法：
- `increment`让计数器按一递增； - `increment`让计数器按一递增；
- `incrementBy(amount: Int)`让计数器按一个指定的整数值递增； - `incrementBy(amount: Int)`让计数器按一个指定的整数值递增；
- `reset`将计数器重置为0。 - `reset`将计数器重置为0。
`Counter`这个类还声明了一个可变属性`count`，用它来保持对当前计数器值的追踪。 `Counter`这个类还声明了一个可变属性`count`，用它来保持对当前计数器值的追踪。
和调用属性一样，用点语法（dot syntax）调用实例方法： 和调用属性一样，用点语法（dot syntax）调用实例方法：
```swift ```swift
let counter = Counter() let counter = Counter()
// 初始计数值是0 // 初始计数值是0
counter.increment() counter.increment()
// 计数值现在是1 // 计数值现在是1
counter.incrementBy(5) counter.incrementBy(5)
// 计数值现在是6 // 计数值现在是6
counter.reset() counter.reset()
// 计数值现在是0 // 计数值现在是0
``` ```
<a name="local_and_external_parameter"></a> <a name="local_and_external_parameter"></a>
### 方法的局部参数名称和外部参数名称(Local and External Parameter Names for Methods) ### 方法的局部参数名称和外部参数名称(Local and External Parameter Names for Methods)
函数参数可以同时有一个局部名称（在函数体内部使用）和一个外部名称（在调用函数时使用），详情参见[函数的外部参数名](06_Functions.html)。方法参数也一样（因为方法就是函数，只是这个函数与某个类型相关联了）。但是，方法和函数的局部名称和外部名称的默认行为是不一样的。 函数参数可以同时有一个局部名称（在函数体内部使用）和一个外部名称（在调用函数时使用），详情参见[函数的外部参数名](06_Functions.html)。方法参数也一样（因为方法就是函数，只是这个函数与某个类型相关联了）。但是，方法和函数的局部名称和外部名称的默认行为是不一样的。
Swift 中的方法和 Objective-C 中的方法极其相似。像在 Objective-C 中一样，Swift 中方法的名称通常用一个介词指向方法的第一个参数，比如：`with`，`for`，`by`等等。前面的`Counter`类的例子中`incrementBy`方法就是这样的。介词的使用让方法在被调用时能像一个句子一样被解读。和函数参数不同，对于方法的参数，Swift 使用不同的默认处理方式，这可以让方法命名规范更容易写。 Swift 中的方法和 Objective-C 中的方法极其相似。像在 Objective-C 中一样，Swift 中方法的名称通常用一个介词指向方法的第一个参数，比如：`with`，`for`，`by`等等。前面的`Counter`类的例子中`incrementBy`方法就是这样的。介词的使用让方法在被调用时能像一个句子一样被解读。和函数参数不同，对于方法的参数，Swift 使用不同的默认处理方式，这可以让方法命名规范更容易写。
具体来说，Swift 默认仅给方法的第一个参数名称一个局部参数名称;默认同时给第二个和后续的参数名称局部参数名称和外部参数名称。这个约定与典型的命名和调用约定相适应，与你在写 Objective-C 的方法时很相似。这个约定还让表达式方法在调用时不需要再限定参数名称。 具体来说，Swift 默认仅给方法的第一个参数名称一个局部参数名称;默认同时给第二个和后续的参数名称局部参数名称和外部参数名称。这个约定与典型的命名和调用约定相适应，与你在写 Objective-C 的方法时很相似。这个约定还让表达式方法在调用时不需要再限定参数名称。
看看下面这个`Counter`的另一个版本（它定义了一个更复杂的`incrementBy`方法）： 看看下面这个`Counter`的另一个版本（它定义了一个更复杂的`incrementBy`方法）：
```swift ```swift
class Counter { class Counter {
var count: Int = 0 var count: Int = 0
func incrementBy(amount: Int, numberOfTimes: Int) { func incrementBy(amount: Int, numberOfTimes: Int) {
count += amount * numberOfTimes count += amount * numberOfTimes
} }
} }
``` ```
`incrementBy`方法有两个参数： `amount`和`numberOfTimes`。默认情况下，Swift 只把`amount`当作一个局部名称，但是把`numberOfTimes`即看作局部名称又看作外部名称。下面调用这个方法： `incrementBy`方法有两个参数： `amount`和`numberOfTimes`。默认情况下，Swift 只把`amount`当作一个局部名称，但是把`numberOfTimes`即看作局部名称又看作外部名称。下面调用这个方法：
```swift ```swift
let counter = Counter() let counter = Counter()
counter.incrementBy(5, numberOfTimes: 3) counter.incrementBy(5, numberOfTimes: 3)
// counter value is now 15 // counter value is now 15
``` ```
你不必为第一个参数值再定义一个外部变量名：因为从函数名`incrementBy`已经能很清楚地看出它的作用。但是第二个参数，就要被一个外部参数名称所限定，以便在方法被调用时明确它的作用。 你不必为第一个参数值再定义一个外部变量名：因为从函数名`incrementBy`已经能很清楚地看出它的作用。但是第二个参数，就要被一个外部参数名称所限定，以便在方法被调用时明确它的作用。
这种默认的行为能够有效的处理方法（method）,类似于在参数`numberOfTimes`前写一个井号（`#`）： 这种默认的行为能够有效的处理方法（method）,类似于在参数`numberOfTimes`前写一个井号（`#`）：
```swift ```swift
func incrementBy(amount: Int, #numberOfTimes: Int) { func incrementBy(amount: Int, #numberOfTimes: Int) {
count += amount * numberOfTimes count += amount * numberOfTimes
} }
``` ```
这种默认行为使上面代码意味着：在 Swift 中定义方法使用了与 Objective-C 同样的语法风格，并且方法将以自然表达式的方式被调用。 这种默认行为使上面代码意味着：在 Swift 中定义方法使用了与 Objective-C 同样的语法风格，并且方法将以自然表达式的方式被调用。
<a name="modifying_external_parameter"></a> <a name="modifying_external_parameter"></a>
### 修改方法的外部参数名称(Modifying External Parameter Name Behavior for Methods) ### 修改方法的外部参数名称(Modifying External Parameter Name Behavior for Methods)
有时为方法的第一个参数提供一个外部参数名称是非常有用的，尽管这不是默认的行为。你可以自己添加一个显式的外部名称或者用一个井号（`#`）作为第一个参数的前缀来把这个局部名称当作外部名称使用。 有时为方法的第一个参数提供一个外部参数名称是非常有用的，尽管这不是默认的行为。你可以自己添加一个显式的外部名称或者用一个井号（`#`）作为第一个参数的前缀来把这个局部名称当作外部名称使用。
相反，如果你不想为方法的第二个及后续的参数提供一个外部名称，可以通过使用下划线（`_`）作为该参数的显式外部名称，这样做将覆盖默认行为。 相反，如果你不想为方法的第二个及后续的参数提供一个外部名称，可以通过使用下划线（`_`）作为该参数的显式外部名称，这样做将覆盖默认行为。
<a name="self_property"></a> <a name="self_property"></a>
## `self`属性(The self Property) ## `self`属性(The self Property)
类型的每一个实例都有一个隐含属性叫做`self`，`self`完全等同于该实例本身。你可以在一个实例的实例方法中使用这个隐含的`self`属性来引用当前实例。 类型的每一个实例都有一个隐含属性叫做`self`，`self`完全等同于该实例本身。你可以在一个实例的实例方法中使用这个隐含的`self`属性来引用当前实例。
上面例子中的`increment`方法还可以这样写： 上面例子中的`increment`方法还可以这样写：
```swift ```swift
func increment() { func increment() {
self.count++ self.count++
} }
``` ```
实际上，你不必在你的代码里面经常写`self`。不论何时，只要在一个方法中使用一个已知的属性或者方法名称，如果你没有明确的写`self`，Swift 假定你是指当前实例的属性或者方法。这种假定在上面的`Counter`中已经示范了：`Counter`中的三个实例方法中都使用的是`count`（而不是`self.count`）。 实际上，你不必在你的代码里面经常写`self`。不论何时，只要在一个方法中使用一个已知的属性或者方法名称，如果你没有明确的写`self`，Swift 假定你是指当前实例的属性或者方法。这种假定在上面的`Counter`中已经示范了：`Counter`中的三个实例方法中都使用的是`count`（而不是`self.count`）。
使用这条规则的主要场景是实例方法的某个参数名称与实例的某个属性名称相同的时候。在这种情况下，参数名称享有优先权，并且在引用属性时必须使用一种更严格的方式。这时你可以使用`self`属性来区分参数名称和属性名称。 使用这条规则的主要场景是实例方法的某个参数名称与实例的某个属性名称相同的时候。在这种情况下，参数名称享有优先权，并且在引用属性时必须使用一种更严格的方式。这时你可以使用`self`属性来区分参数名称和属性名称。
下面的例子中，`self`消除方法参数`x`和实例属性`x`之间的歧义： 下面的例子中，`self`消除方法参数`x`和实例属性`x`之间的歧义：
```swift ```swift
struct Point { struct Point {
var x = 0.0, y = 0.0 var x = 0.0, y = 0.0
func isToTheRightOfX(x: Double) -> Bool { func isToTheRightOfX(x: Double) -> Bool {
return self.x > x return self.x > x
} }
} }
let somePoint = Point(x: 4.0, y: 5.0) let somePoint = Point(x: 4.0, y: 5.0)
if somePoint.isToTheRightOfX(1.0) { if somePoint.isToTheRightOfX(1.0) {
println("This point is to the right of the line where x == 1.0") println("This point is to the right of the line where x == 1.0")
} }
// 输出 "This point is to the right of the line where x == 1.0"（这个点在x等于1.0这条线的右边） // 输出 "This point is to the right of the line where x == 1.0"（这个点在x等于1.0这条线的右边）
``` ```
如果不使用`self`前缀，Swift 就认为两次使用的`x`都指的是名称为`x`的函数参数。 如果不使用`self`前缀，Swift 就认为两次使用的`x`都指的是名称为`x`的函数参数。
<a name="modifying_value_types"></a> <a name="modifying_value_types"></a>
### 在实例方法中修改值类型(Modifying Value Types from Within Instance Methods) ### 在实例方法中修改值类型(Modifying Value Types from Within Instance Methods)
结构体和枚举是**值类型**。一般情况下，值类型的属性不能在它的实例方法中被修改。 结构体和枚举是**值类型**。一般情况下，值类型的属性不能在它的实例方法中被修改。
但是，如果你确实需要在某个具体的方法中修改结构体或者枚举的属性，你可以选择`变异(mutating)`这个方法，然后方法就可以从方法内部改变它的属性；并且它做的任何改变在方法结束时还会保留在原始结构中。方法还可以给它隐含的`self`属性赋值一个全新的实例，这个新实例在方法结束后将替换原来的实例。 但是，如果你确实需要在某个具体的方法中修改结构体或者枚举的属性，你可以选择`变异(mutating)`这个方法，然后方法就可以从方法内部改变它的属性；并且它做的任何改变在方法结束时还会保留在原始结构中。方法还可以给它隐含的`self`属性赋值一个全新的实例，这个新实例在方法结束后将替换原来的实例。
要使用`变异`方法， 将关键字`mutating` 放到方法的`func`关键字之前就可以了： 要使用`变异`方法， 将关键字`mutating` 放到方法的`func`关键字之前就可以了：
```swift ```swift
struct Point { struct Point {
var x = 0.0, y = 0.0 var x = 0.0, y = 0.0
mutating func moveByX(deltaX: Double, y deltaY: Double) { mutating func moveByX(deltaX: Double, y deltaY: Double) {
x += deltaX x += deltaX
y += deltaY y += deltaY
} }
} }
var somePoint = Point(x: 1.0, y: 1.0) var somePoint = Point(x: 1.0, y: 1.0)
somePoint.moveByX(2.0, y: 3.0) somePoint.moveByX(2.0, y: 3.0)
println("The point is now at (\(somePoint.x), \(somePoint.y))") println("The point is now at (\(somePoint.x), \(somePoint.y))")
// 输出 "The point is now at (3.0, 4.0)" // 输出 "The point is now at (3.0, 4.0)"
``` ```
上面的`Point`结构体定义了一个变异方法（mutating method）`moveByX`，`moveByX`用来移动点。`moveByX`方法在被调用时修改了这个点，而不是返回一个新的点。方法定义时加上`mutating`关键字,这才让方法可以修改值类型的属性。 上面的`Point`结构体定义了一个变异方法（mutating method）`moveByX`，`moveByX`用来移动点。`moveByX`方法在被调用时修改了这个点，而不是返回一个新的点。方法定义时加上`mutating`关键字,这才让方法可以修改值类型的属性。
注意：不能在结构体类型常量上调用变异方法，因为常量的属性不能被改变，即使想改变的是常量的变量属性也不行，详情参见[存储属性和实例变量]("10_Properties.html") 注意：不能在结构体类型常量上调用变异方法，因为常量的属性不能被改变，即使想改变的是常量的变量属性也不行，详情参见[存储属性和实例变量]("10_Properties.html")
```swift ```swift
let fixedPoint = Point(x: 3.0, y: 3.0) let fixedPoint = Point(x: 3.0, y: 3.0)
fixedPoint.moveByX(2.0, y: 3.0) fixedPoint.moveByX(2.0, y: 3.0)
// this will report an error // this will report an error
``` ```
<a name="mutating_method_self"></a> <a name="mutating_method_self"></a>
### 在变异方法中给self赋值(Assigning to self Within a Mutating Method) ### 在变异方法中给self赋值(Assigning to self Within a Mutating Method)
变异方法能够赋给隐含属性`self`一个全新的实例。上面`Point`的例子可以用下面的方式改写： 变异方法能够赋给隐含属性`self`一个全新的实例。上面`Point`的例子可以用下面的方式改写：
```swift ```swift
struct Point { struct Point {
var x = 0.0, y = 0.0 var x = 0.0, y = 0.0
mutating func moveByX(deltaX: Double, y deltaY: Double) { mutating func moveByX(deltaX: Double, y deltaY: Double) {
self = Point(x: x + deltaX, y: y + deltaY) self = Point(x: x + deltaX, y: y + deltaY)
} }
} }
``` ```
新版的变异方法`moveByX`创建了一个新的结构（它的 x 和 y 的值都被设定为目标值）。调用这个版本的方法和调用上个版本的最终结果是一样的。 新版的变异方法`moveByX`创建了一个新的结构（它的 x 和 y 的值都被设定为目标值）。调用这个版本的方法和调用上个版本的最终结果是一样的。
枚举的变异方法可以把`self`设置为相同的枚举类型中不同的成员： 枚举的变异方法可以把`self`设置为相同的枚举类型中不同的成员：
```swift ```swift
enum TriStateSwitch { enum TriStateSwitch {
case Off, Low, High case Off, Low, High
mutating func next() { mutating func next() {
switch self { switch self {
case Off: case Off:
self = Low self = Low
case Low: case Low:
self = High self = High
case High: case High:
self = Off self = Off
} }
} }
} }
var ovenLight = TriStateSwitch.Low var ovenLight = TriStateSwitch.Low
ovenLight.next() ovenLight.next()
// ovenLight 现在等于 .High // ovenLight 现在等于 .High
ovenLight.next() ovenLight.next()
// ovenLight 现在等于 .Off // ovenLight 现在等于 .Off
``` ```
上面的例子中定义了一个三态开关的枚举。每次调用`next`方法时，开关在不同的电源状态（`Off`，`Low`，`High`）之前循环切换。 上面的例子中定义了一个三态开关的枚举。每次调用`next`方法时，开关在不同的电源状态（`Off`，`Low`，`High`）之前循环切换。
<a name="type_methods"></a> <a name="type_methods"></a>
## 类型方法(Type Methods) ## 类型方法(Type Methods)
实例方法是被类型的某个实例调用的方法。你也可以定义类型本身调用的方法，这种方法就叫做**类型方法**。声明类的类型方法，在方法的`func`关键字之前加上关键字`class`；声明结构体和枚举的类型方法，在方法的`func`关键字之前加上关键字`static`。 实例方法是被类型的某个实例调用的方法。你也可以定义类型本身调用的方法，这种方法就叫做**类型方法**。声明类的类型方法，在方法的`func`关键字之前加上关键字`class`；声明结构体和枚举的类型方法，在方法的`func`关键字之前加上关键字`static`。
> 注意： > 注意：
> 在 Objective-C 里面，你只能为 Objective-C 的类定义类型方法（type-level methods）。在 Swift 中，你可以为所有的类、结构体和枚举定义类型方法：每一个类型方法都被它所支持的类型显式包含。 > 在 Objective-C 里面，你只能为 Objective-C 的类定义类型方法（type-level methods）。在 Swift 中，你可以为所有的类、结构体和枚举定义类型方法：每一个类型方法都被它所支持的类型显式包含。
类型方法和实例方法一样用点语法调用。但是，你是在类型层面上调用这个方法，而不是在实例层面上调用。下面是如何在`SomeClass`类上调用类型方法的例子： 类型方法和实例方法一样用点语法调用。但是，你是在类型层面上调用这个方法，而不是在实例层面上调用。下面是如何在`SomeClass`类上调用类型方法的例子：
```swift ```swift
class SomeClass { class SomeClass {
class func someTypeMethod() { class func someTypeMethod() {
// type method implementation goes here // type method implementation goes here
} }
} }
SomeClass.someTypeMethod() SomeClass.someTypeMethod()
``` ```
在类型方法的方法体（body）中，`self`指向这个类型本身，而不是类型的某个实例。对于结构体和枚举来说，这意味着你可以用`self`来消除静态属性和静态方法参数之间的歧义（类似于我们在前面处理实例属性和实例方法参数时做的那样）。 在类型方法的方法体（body）中，`self`指向这个类型本身，而不是类型的某个实例。对于结构体和枚举来说，这意味着你可以用`self`来消除静态属性和静态方法参数之间的歧义（类似于我们在前面处理实例属性和实例方法参数时做的那样）。
一般来说，任何未限定的方法和属性名称，将会来自于本类中另外的类型级别的方法和属性。一个类型方法可以调用本类中另一个类型方法的名称，而无需在方法名称前面加上类型名称的前缀。同样，结构体和枚举的类型方法也能够直接通过静态属性的名称访问静态属性，而不需要类型名称前缀。 一般来说，任何未限定的方法和属性名称，将会来自于本类中另外的类型级别的方法和属性。一个类型方法可以调用本类中另一个类型方法的名称，而无需在方法名称前面加上类型名称的前缀。同样，结构体和枚举的类型方法也能够直接通过静态属性的名称访问静态属性，而不需要类型名称前缀。
下面的例子定义了一个名为`LevelTracker`结构体。它监测玩家的游戏发展情况（游戏的不同层次或阶段）。这是一个单人游戏，但也可以存储多个玩家在同一设备上的游戏信息。 下面的例子定义了一个名为`LevelTracker`结构体。它监测玩家的游戏发展情况（游戏的不同层次或阶段）。这是一个单人游戏，但也可以存储多个玩家在同一设备上的游戏信息。
游戏初始时，所有的游戏等级（除了等级 1）都被锁定。每次有玩家完成一个等级，这个等级就对这个设备上的所有玩家解锁。`LevelTracker`结构体用静态属性和方法监测游戏的哪个等级已经被解锁。它还监测每个玩家的当前等级。 游戏初始时，所有的游戏等级（除了等级 1）都被锁定。每次有玩家完成一个等级，这个等级就对这个设备上的所有玩家解锁。`LevelTracker`结构体用静态属性和方法监测游戏的哪个等级已经被解锁。它还监测每个玩家的当前等级。
```swift ```swift
struct LevelTracker { struct LevelTracker {
static var highestUnlockedLevel = 1 static var highestUnlockedLevel = 1
static func unlockLevel(level: Int) { static func unlockLevel(level: Int) {
if level > highestUnlockedLevel { highestUnlockedLevel = level } if level > highestUnlockedLevel { highestUnlockedLevel = level }
} }
static func levelIsUnlocked(level: Int) -> Bool { static func levelIsUnlocked(level: Int) -> Bool {
return level <= highestUnlockedLevel return level <= highestUnlockedLevel
} }
var currentLevel = 1 var currentLevel = 1
mutating func advanceToLevel(level: Int) -> Bool { mutating func advanceToLevel(level: Int) -> Bool {
if LevelTracker.levelIsUnlocked(level) { if LevelTracker.levelIsUnlocked(level) {
currentLevel = level currentLevel = level
return true return true
} else { } else {
return false return false
} }
} }
} }
``` ```
`LevelTracker`监测玩家的已解锁的最高等级。这个值被存储在静态属性`highestUnlockedLevel`中。 `LevelTracker`监测玩家的已解锁的最高等级。这个值被存储在静态属性`highestUnlockedLevel`中。
`LevelTracker`还定义了两个类型方法与`highestUnlockedLevel`配合工作。第一个类型方法是`unlockLevel`：一旦新等级被解锁，它会更新`highestUnlockedLevel`的值。第二个类型方法是`levelIsUnlocked`：如果某个给定的等级已经被解锁，它将返回`true`。（注意：尽管我们没有使用类似`LevelTracker.highestUnlockedLevel`的写法，这个类型方法还是能够访问静态属性`highestUnlockedLevel`） `LevelTracker`还定义了两个类型方法与`highestUnlockedLevel`配合工作。第一个类型方法是`unlockLevel`：一旦新等级被解锁，它会更新`highestUnlockedLevel`的值。第二个类型方法是`levelIsUnlocked`：如果某个给定的等级已经被解锁，它将返回`true`。（注意：尽管我们没有使用类似`LevelTracker.highestUnlockedLevel`的写法，这个类型方法还是能够访问静态属性`highestUnlockedLevel`）
除了静态属性和类型方法，`LevelTracker`还监测每个玩家的进度。它用实例属性`currentLevel`来监测玩家当前的等级。 除了静态属性和类型方法，`LevelTracker`还监测每个玩家的进度。它用实例属性`currentLevel`来监测玩家当前的等级。
为了便于管理`currentLevel`属性，`LevelTracker`定义了实例方法`advanceToLevel`。这个方法会在更新`currentLevel`之前检查所请求的新等级是否已经解锁。`advanceToLevel`方法返回布尔值以指示是否能够设置`currentLevel`。 为了便于管理`currentLevel`属性，`LevelTracker`定义了实例方法`advanceToLevel`。这个方法会在更新`currentLevel`之前检查所请求的新等级是否已经解锁。`advanceToLevel`方法返回布尔值以指示是否能够设置`currentLevel`。
下面，`Player`类使用`LevelTracker`来监测和更新每个玩家的发展进度： 下面，`Player`类使用`LevelTracker`来监测和更新每个玩家的发展进度：
```swift ```swift
class Player { class Player {
var tracker = LevelTracker() var tracker = LevelTracker()
let playerName: String let playerName: String
func completedLevel(level: Int) { func completedLevel(level: Int) {
LevelTracker.unlockLevel(level + 1) LevelTracker.unlockLevel(level + 1)
tracker.advanceToLevel(level + 1) tracker.advanceToLevel(level + 1)
} }
init(name: String) { init(name: String) {
playerName = name playerName = name
} }
} }
``` ```
`Player`类创建一个新的`LevelTracker`实例来监测这个用户的发展进度。它提供了`completedLevel`方法：一旦玩家完成某个指定等级就调用它。这个方法为所有玩家解锁下一等级，并且将当前玩家的进度更新为下一等级。（我们忽略了`advanceToLevel`返回的布尔值，因为之前调用`LevelTracker.unlockLevel`时就知道了这个等级已经被解锁了）。 `Player`类创建一个新的`LevelTracker`实例来监测这个用户的发展进度。它提供了`completedLevel`方法：一旦玩家完成某个指定等级就调用它。这个方法为所有玩家解锁下一等级，并且将当前玩家的进度更新为下一等级。（我们忽略了`advanceToLevel`返回的布尔值，因为之前调用`LevelTracker.unlockLevel`时就知道了这个等级已经被解锁了）。
你还可以为一个新的玩家创建一个`Player`的实例，然后看这个玩家完成等级一时发生了什么： 你还可以为一个新的玩家创建一个`Player`的实例，然后看这个玩家完成等级一时发生了什么：
```swift ```swift
var player = Player(name: "Argyrios") var player = Player(name: "Argyrios")
player.completedLevel(1) player.completedLevel(1)
println("highest unlocked level is now \(LevelTracker.highestUnlockedLevel)") println("highest unlocked level is now \(LevelTracker.highestUnlockedLevel)")
// 输出 "highest unlocked level is now 2"（最高等级现在是2） // 输出 "highest unlocked level is now 2"（最高等级现在是2）
``` ```
如果你创建了第二个玩家，并尝试让它开始一个没有被任何玩家解锁的等级，那么这次设置玩家当前等级的尝试将会失败： 如果你创建了第二个玩家，并尝试让它开始一个没有被任何玩家解锁的等级，那么这次设置玩家当前等级的尝试将会失败：
```swift ```swift
player = Player(name: "Beto") player = Player(name: "Beto")
if player.tracker.advanceToLevel(6) { if player.tracker.advanceToLevel(6) {
println("player is now on level 6") println("player is now on level 6")
} else { } else {
println("level 6 has not yet been unlocked") println("level 6 has not yet been unlocked")
} }
// 输出 "level 6 has not yet been unlocked"（等级6还没被解锁） // 输出 "level 6 has not yet been unlocked"（等级6还没被解锁）
``` ```

334
source/chapter2/12_Subscripts.md
View File

@ -1,167 +1,167 @@
> 翻译：[siemenliu](https://github.com/siemenliu) > 翻译：[siemenliu](https://github.com/siemenliu)
> 校对：[zq54zquan](https://github.com/zq54zquan) > 校对：[zq54zquan](https://github.com/zq54zquan)
# 下标脚本（Subscripts） # 下标脚本（Subscripts）
----------------- -----------------
本页包含内容： 本页包含内容：
- [下标脚本语法](#subscript_syntax) - [下标脚本语法](#subscript_syntax)
- [下标脚本用法](#subscript_usage) - [下标脚本用法](#subscript_usage)
- [下标脚本选项](#subscript_options) - [下标脚本选项](#subscript_options)
*下标脚本* 可以定义在类（Class）、结构体（structure）和枚举（enumeration）这些目标中，可以认为是访问对象、集合或序列的快捷方式，不需要再调用实例的特定的赋值和访问方法。举例来说，用下标脚本访问一个数组(Array)实例中的元素可以这样写 `someArray[index]` ，访问字典(Dictionary)实例中的元素可以这样写 `someDictionary[key]`。 *下标脚本* 可以定义在类（Class）、结构体（structure）和枚举（enumeration）这些目标中，可以认为是访问对象、集合或序列的快捷方式，不需要再调用实例的特定的赋值和访问方法。举例来说，用下标脚本访问一个数组(Array)实例中的元素可以这样写 `someArray[index]` ，访问字典(Dictionary)实例中的元素可以这样写 `someDictionary[key]`。
对于同一个目标可以定义多个下标脚本，通过索引值类型的不同来进行重载，而且索引值的个数可以是多个。 对于同一个目标可以定义多个下标脚本，通过索引值类型的不同来进行重载，而且索引值的个数可以是多个。
> 译者：这里附属脚本重载在本小节中原文并没有任何演示 > 译者：这里附属脚本重载在本小节中原文并没有任何演示
<a name="subscript_syntax"></a> <a name="subscript_syntax"></a>
## 下标脚本语法 ## 下标脚本语法
下标脚本允许你通过在实例后面的方括号中传入一个或者多个的索引值来对实例进行访问和赋值。语法类似于实例方法和计算型属性的混合。与定义实例方法类似，定义下标脚本使用`subscript`关键字，显式声明入参（一个或多个）和返回类型。与实例方法不同的是下标脚本可以设定为读写或只读。这种方式又有点像计算型属性的getter和setter： 下标脚本允许你通过在实例后面的方括号中传入一个或者多个的索引值来对实例进行访问和赋值。语法类似于实例方法和计算型属性的混合。与定义实例方法类似，定义下标脚本使用`subscript`关键字，显式声明入参（一个或多个）和返回类型。与实例方法不同的是下标脚本可以设定为读写或只读。这种方式又有点像计算型属性的getter和setter：
```swift ```swift
subscript(index: Int) -> Int { subscript(index: Int) -> Int {
get { get {
// 返回与入参匹配的Int类型的值 // 返回与入参匹配的Int类型的值
} }
set(newValue) { set(newValue) {
// 执行赋值操作 // 执行赋值操作
} }
} }
``` ```
`newValue`的类型必须和下标脚本定义的返回类型相同。与计算型属性相同的是set的入参声明`newValue`就算不写，在set代码块中依然可以使用默认的`newValue`这个变量来访问新赋的值。 `newValue`的类型必须和下标脚本定义的返回类型相同。与计算型属性相同的是set的入参声明`newValue`就算不写，在set代码块中依然可以使用默认的`newValue`这个变量来访问新赋的值。
与只读计算型属性一样，可以直接将原本应该写在`get`代码块中的代码写在`subscript`中： 与只读计算型属性一样，可以直接将原本应该写在`get`代码块中的代码写在`subscript`中：
```swift ```swift
subscript(index: Int) -> Int { subscript(index: Int) -> Int {
// 返回与入参匹配的Int类型的值 // 返回与入参匹配的Int类型的值
} }
``` ```
下面代码演示了一个在`TimesTable`结构体中使用只读下标脚本的用法，该结构体用来展示传入整数的*n*倍。 下面代码演示了一个在`TimesTable`结构体中使用只读下标脚本的用法，该结构体用来展示传入整数的*n*倍。
```swift ```swift
struct TimesTable { struct TimesTable {
let multiplier: Int let multiplier: Int
subscript(index: Int) -> Int { subscript(index: Int) -> Int {
return multiplier * index return multiplier * index
} }
} }
let threeTimesTable = TimesTable(multiplier: 3) let threeTimesTable = TimesTable(multiplier: 3)
println("3的6倍是\(threeTimesTable[6])") println("3的6倍是\(threeTimesTable[6])")
// 输出 "3的6倍是18" // 输出 "3的6倍是18"
``` ```
在上例中，通过`TimesTable`结构体创建了一个用来表示索引值三倍的实例。数值`3`作为结构体`构造函数`入参初始化实例成员`multiplier`。 在上例中，通过`TimesTable`结构体创建了一个用来表示索引值三倍的实例。数值`3`作为结构体`构造函数`入参初始化实例成员`multiplier`。
你可以通过下标脚本来得到结果，比如`threeTimesTable[6]`。这条语句访问了`threeTimesTable`的第六个元素，返回`6`的`3`倍即`18`。 你可以通过下标脚本来得到结果，比如`threeTimesTable[6]`。这条语句访问了`threeTimesTable`的第六个元素，返回`6`的`3`倍即`18`。
>注意： >注意：
> `TimesTable`例子是基于一个固定的数学公式。它并不适合开放写权限来对`threeTimesTable[someIndex]`进行赋值操作，这也是为什么附属脚本只定义为只读的原因。 > `TimesTable`例子是基于一个固定的数学公式。它并不适合开放写权限来对`threeTimesTable[someIndex]`进行赋值操作，这也是为什么附属脚本只定义为只读的原因。
<a name="subscript_usage"></a> <a name="subscript_usage"></a>
## 下标脚本用法 ## 下标脚本用法
根据使用场景不同下标脚本也具有不同的含义。通常下标脚本是用来访问集合（collection），列表（list）或序列（sequence）中元素的快捷方式。你可以在你自己特定的类或结构体中自由的实现下标脚本来提供合适的功能。 根据使用场景不同下标脚本也具有不同的含义。通常下标脚本是用来访问集合（collection），列表（list）或序列（sequence）中元素的快捷方式。你可以在你自己特定的类或结构体中自由的实现下标脚本来提供合适的功能。
例如，Swift 的字典（Dictionary）实现了通过下标脚本来对其实例中存放的值进行存取操作。在下标脚本中使用和字典索引相同类型的值，并且把一个字典值类型的值赋值给这个下标脚本来为字典设值： 例如，Swift 的字典（Dictionary）实现了通过下标脚本来对其实例中存放的值进行存取操作。在下标脚本中使用和字典索引相同类型的值，并且把一个字典值类型的值赋值给这个下标脚本来为字典设值：
```swift ```swift
var numberOfLegs = ["spider": 8, "ant": 6, "cat": 4] var numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]
numberOfLegs["bird"] = 2 numberOfLegs["bird"] = 2
``` ```
上例定义一个名为`numberOfLegs`的变量并用一个字典字面量初始化出了包含三对键值的字典实例。`numberOfLegs`的字典存放值类型推断为`Dictionary<String, Int>`。字典实例创建完成之后通过下标脚本的方式将整型值`2`赋值到字典实例的索引为`bird`的位置中。 上例定义一个名为`numberOfLegs`的变量并用一个字典字面量初始化出了包含三对键值的字典实例。`numberOfLegs`的字典存放值类型推断为`Dictionary<String, Int>`。字典实例创建完成之后通过下标脚本的方式将整型值`2`赋值到字典实例的索引为`bird`的位置中。
更多关于字典（Dictionary）下标脚本的信息请参考[读取和修改字典](../chapter2/04_Collection_Types.html) 更多关于字典（Dictionary）下标脚本的信息请参考[读取和修改字典](../chapter2/04_Collection_Types.html)
> 注意： > 注意：
> Swift 中字典的附属脚本实现中，在`get`部分返回值是`Int?`，上例中的`numberOfLegs`字典通过附属脚本返回的是一个`Int?`或者说“可选的int”，不是每个字典的索引都能得到一个整型值，对于没有设过值的索引的访问返回的结果就是`nil`；同样想要从字典实例中删除某个索引下的值也只需要给这个索引赋值为`nil`即可。 > Swift 中字典的附属脚本实现中，在`get`部分返回值是`Int?`，上例中的`numberOfLegs`字典通过附属脚本返回的是一个`Int?`或者说“可选的int”，不是每个字典的索引都能得到一个整型值，对于没有设过值的索引的访问返回的结果就是`nil`；同样想要从字典实例中删除某个索引下的值也只需要给这个索引赋值为`nil`即可。
<a name="subscript_options"></a> <a name="subscript_options"></a>
## 下标脚本选项 ## 下标脚本选项
下标脚本允许任意数量的入参索引，并且每个入参类型也没有限制。下标脚本的返回值也可以是任何类型。下标脚本可以使用变量参数和可变参数，但使用写入读出（in-out）参数或给参数设置默认值都是不允许的。 下标脚本允许任意数量的入参索引，并且每个入参类型也没有限制。下标脚本的返回值也可以是任何类型。下标脚本可以使用变量参数和可变参数，但使用写入读出（in-out）参数或给参数设置默认值都是不允许的。
一个类或结构体可以根据自身需要提供多个下标脚本实现，在定义下标脚本时通过入参个类型进行区分，使用下标脚本时会自动匹配合适的下标脚本实现运行，这就是*下标脚本的重载*。 一个类或结构体可以根据自身需要提供多个下标脚本实现，在定义下标脚本时通过入参个类型进行区分，使用下标脚本时会自动匹配合适的下标脚本实现运行，这就是*下标脚本的重载*。
一个下标脚本入参是最常见的情况，但只要有合适的场景也可以定义多个下标脚本入参。如下例定义了一个`Matrix`结构体，将呈现一个`Double`类型的二维矩阵。`Matrix`结构体的下标脚本需要两个整型参数： 一个下标脚本入参是最常见的情况，但只要有合适的场景也可以定义多个下标脚本入参。如下例定义了一个`Matrix`结构体，将呈现一个`Double`类型的二维矩阵。`Matrix`结构体的下标脚本需要两个整型参数：
```swift ```swift
struct Matrix { struct Matrix {
let rows: Int, columns: Int let rows: Int, columns: Int
var grid: Double[] var grid: Double[]
init(rows: Int, columns: Int) { init(rows: Int, columns: Int) {
self.rows = rows self.rows = rows
self.columns = columns self.columns = columns
grid = Array(count: rows * columns, repeatedValue: 0.0) grid = Array(count: rows * columns, repeatedValue: 0.0)
} }
func indexIsValidForRow(row: Int, column: Int) -> Bool { func indexIsValidForRow(row: Int, column: Int) -> Bool {
return row >= 0 && row < rows && column >= 0 && column < columns return row >= 0 && row < rows && column >= 0 && column < columns
} }
subscript(row: Int, column: Int) -> Double { subscript(row: Int, column: Int) -> Double {
get { get {
assert(indexIsValidForRow(row, column: column), "Index out of range") assert(indexIsValidForRow(row, column: column), "Index out of range")
return grid[(row * columns) + column] return grid[(row * columns) + column]
} }
set { set {
assert(indexIsValidForRow(row, column: column), "Index out of range") assert(indexIsValidForRow(row, column: column), "Index out of range")
grid[(row * columns) + columns] = newValue grid[(row * columns) + columns] = newValue
} }
} }
} }
``` ```
`Matrix`提供了一个两个入参的构造方法，入参分别是`rows`和`columns`，创建了一个足够容纳`rows * columns`个数的`Double`类型数组。为了存储，将数组的大小和数组每个元素初始值0.0，都传入数组的构造方法中来创建一个正确大小的新数组。关于数组的构造方法和析构方法请参考[创建并且构造一个数组](../chapter2/04_Collection_Types.html)。 `Matrix`提供了一个两个入参的构造方法，入参分别是`rows`和`columns`，创建了一个足够容纳`rows * columns`个数的`Double`类型数组。为了存储，将数组的大小和数组每个元素初始值0.0，都传入数组的构造方法中来创建一个正确大小的新数组。关于数组的构造方法和析构方法请参考[创建并且构造一个数组](../chapter2/04_Collection_Types.html)。
你可以通过传入合适的`row`和`column`的数量来构造一个新的`Matrix`实例： 你可以通过传入合适的`row`和`column`的数量来构造一个新的`Matrix`实例：
```swift ```swift
var matrix = Matrix(rows: 2, columns: 2) var matrix = Matrix(rows: 2, columns: 2)
``` ```
上例中创建了一个新的两行两列的`Matrix`实例。在阅读顺序从左上到右下的`Matrix`实例中的数组实例`grid`是矩阵二维数组的扁平化存储： 上例中创建了一个新的两行两列的`Matrix`实例。在阅读顺序从左上到右下的`Matrix`实例中的数组实例`grid`是矩阵二维数组的扁平化存储：
```swift ```swift
// 示意图 // 示意图
grid = [0.0, 0.0, 0.0, 0.0] grid = [0.0, 0.0, 0.0, 0.0]
col0 col1 col0 col1
row0 [0.0, 0.0, row0 [0.0, 0.0,
row1 0.0, 0.0] row1 0.0, 0.0]
``` ```
将值赋给带有`row`和`column`下标脚本的`matrix`实例表达式可以完成赋值操作，下标脚本入参使用逗号分割 将值赋给带有`row`和`column`下标脚本的`matrix`实例表达式可以完成赋值操作，下标脚本入参使用逗号分割
```swift ```swift
matrix[0, 1] = 1.5 matrix[0, 1] = 1.5
matrix[1, 0] = 3.2 matrix[1, 0] = 3.2
``` ```
上面两条语句分别`让matrix`的右上值为 1.5，坐下值为 3.2： 上面两条语句分别`让matrix`的右上值为 1.5，坐下值为 3.2：
```swift ```swift
[0.0, 1.5, [0.0, 1.5,
3.2, 0.0] 3.2, 0.0]
``` ```
`Matrix`下标脚本的`getter`和`setter`中同时调用了下标脚本入参的`row`和`column`是否有效的判断。为了方便进行断言，`Matrix`包含了一个名为`indexIsValid`的成员方法，用来确认入参的`row`或`column`值是否会造成数组越界： `Matrix`下标脚本的`getter`和`setter`中同时调用了下标脚本入参的`row`和`column`是否有效的判断。为了方便进行断言，`Matrix`包含了一个名为`indexIsValid`的成员方法，用来确认入参的`row`或`column`值是否会造成数组越界：
```swift ```swift
func indexIsValidForRow(row: Int, column: Int) -> Bool { func indexIsValidForRow(row: Int, column: Int) -> Bool {
return row >= 0 && row < rows && column >= 0 && column < columns return row >= 0 && row < rows && column >= 0 && column < columns
} }
``` ```
断言在下标脚本越界时触发： 断言在下标脚本越界时触发：
```swift ```swift
let someValue = matrix[2, 2] let someValue = matrix[2, 2]
// 断言将会触发，因为 [2, 2] 已经超过了matrix的最大长度 // 断言将会触发，因为 [2, 2] 已经超过了matrix的最大长度
``` ```

540
source/chapter2/13_Inheritance.md
View File

@ -1,270 +1,270 @@
> 翻译：[Hawstein](https://github.com/Hawstein) > 翻译：[Hawstein](https://github.com/Hawstein)
> 校对：[menlongsheng](https://github.com/menlongsheng) > 校对：[menlongsheng](https://github.com/menlongsheng)
# 继承（Inheritance） # 继承（Inheritance）
------------------- -------------------
本页包含内容： 本页包含内容：
- [定义一个基类（Base class）](#defining_a_base_class) - [定义一个基类（Base class）](#defining_a_base_class)
- [子类生成（Subclassing）](#subclassing) - [子类生成（Subclassing）](#subclassing)
- [重写（Overriding）](#overriding) - [重写（Overriding）](#overriding)
- [防止重写](#preventing_overrides) - [防止重写](#preventing_overrides)
一个类可以*继承（inherit）*另一个类的方法（methods），属性（property）和其它特性。当一个类继承其它类时，继承类叫*子类（subclass）*，被继承类叫*超类（或父类，superclass）*。在 Swift 中，继承是区分「类」与其它类型的一个基本特征。 一个类可以*继承（inherit）*另一个类的方法（methods），属性（property）和其它特性。当一个类继承其它类时，继承类叫*子类（subclass）*，被继承类叫*超类（或父类，superclass）*。在 Swift 中，继承是区分「类」与其它类型的一个基本特征。
在 Swift 中，类可以调用和访问超类的方法，属性和下标脚本（subscripts），并且可以重写（override）这些方法，属性和下标脚本来优化或修改它们的行为。Swift 会检查你的重写定义在超类中是否有匹配的定义，以此确保你的重写行为是正确的。 在 Swift 中，类可以调用和访问超类的方法，属性和下标脚本（subscripts），并且可以重写（override）这些方法，属性和下标脚本来优化或修改它们的行为。Swift 会检查你的重写定义在超类中是否有匹配的定义，以此确保你的重写行为是正确的。
可以为类中继承来的属性添加属性观察器（property observer），这样一来，当属性值改变时，类就会被通知到。可以为任何属性添加属性观察器，无论它原本被定义为存储型属性（stored property）还是计算型属性（computed property）。 可以为类中继承来的属性添加属性观察器（property observer），这样一来，当属性值改变时，类就会被通知到。可以为任何属性添加属性观察器，无论它原本被定义为存储型属性（stored property）还是计算型属性（computed property）。
<a name="defining_a_base_class"></a> <a name="defining_a_base_class"></a>
## 定义一个基类（Base class） ## 定义一个基类（Base class）
不继承于其它类的类，称之为*基类（base calss）*。 不继承于其它类的类，称之为*基类（base calss）*。
> 注意： > 注意：
Swift 中的类并不是从一个通用的基类继承而来。如果你不为你定义的类指定一个超类的话，这个类就自动成为基类。 Swift 中的类并不是从一个通用的基类继承而来。如果你不为你定义的类指定一个超类的话，这个类就自动成为基类。
下面的例子定义了一个叫`Vehicle`的基类。这个基类声明了两个对所有车辆都通用的属性（`numberOfWheels`和`maxPassengers`）。这些属性在`description`方法中使用，这个方法返回一个`String`类型的，对车辆特征的描述： 下面的例子定义了一个叫`Vehicle`的基类。这个基类声明了两个对所有车辆都通用的属性（`numberOfWheels`和`maxPassengers`）。这些属性在`description`方法中使用，这个方法返回一个`String`类型的，对车辆特征的描述：
```swift ```swift
class Vehicle { class Vehicle {
var numberOfWheels: Int var numberOfWheels: Int
var maxPassengers: Int var maxPassengers: Int
func description() -> String { func description() -> String {
return "\(numberOfWheels) wheels; up to \(maxPassengers) passengers" return "\(numberOfWheels) wheels; up to \(maxPassengers) passengers"
} }
init() { init() {
numberOfWheels = 0 numberOfWheels = 0
maxPassengers = 1 maxPassengers = 1
} }
} }
``` ```
`Vehicle`类定义了*构造器（initializer）*来设置属性的值。构造器会在[构造过程](../chapter2/_14Initialization.html)一节中详细介绍，这里我们做一下简单介绍，以便于讲解子类中继承来的属性如何被修改。 `Vehicle`类定义了*构造器（initializer）*来设置属性的值。构造器会在[构造过程](../chapter2/_14Initialization.html)一节中详细介绍，这里我们做一下简单介绍，以便于讲解子类中继承来的属性如何被修改。
构造器用于创建某个类型的一个新实例。尽管构造器并不是方法，但在语法上，两者很相似。构造器的工作是准备新实例以供使用，并确保实例中的所有属性都拥有有效的初始化值。 构造器用于创建某个类型的一个新实例。尽管构造器并不是方法，但在语法上，两者很相似。构造器的工作是准备新实例以供使用，并确保实例中的所有属性都拥有有效的初始化值。
构造器的最简单形式就像一个没有参数的实例方法，使用`init`关键字： 构造器的最简单形式就像一个没有参数的实例方法，使用`init`关键字：
```swift ```swift
init() { init() {
// 执行构造过程 // 执行构造过程
} }
``` ```
如果要创建一个`Vehicle`类的新实例，使用*构造器*语法调用上面的初始化器，即类名后面跟一个空的小括号： 如果要创建一个`Vehicle`类的新实例，使用*构造器*语法调用上面的初始化器，即类名后面跟一个空的小括号：
```swift ```swift
let someVehicle = Vehicle() let someVehicle = Vehicle()
``` ```
这个`Vehicle`类的构造器为任意的一辆车设置一些初始化属性值（`numberOfWheels = 0 `和`maxPassengers = 1`）。 这个`Vehicle`类的构造器为任意的一辆车设置一些初始化属性值（`numberOfWheels = 0 `和`maxPassengers = 1`）。
`Vehicle`类定义了车辆的共同特性，但这个类本身并没太大用处。为了使它更为实用，你需要进一步细化它来描述更具体的车辆。 `Vehicle`类定义了车辆的共同特性，但这个类本身并没太大用处。为了使它更为实用，你需要进一步细化它来描述更具体的车辆。
<a name="subclassing"></a> <a name="subclassing"></a>
## 子类生成（Subclassing） ## 子类生成（Subclassing）
*子类生成（Subclassing）*指的是在一个已有类的基础上创建一个新的类。子类继承超类的特性，并且可以优化或改变它。你还可以为子类添加新的特性。 *子类生成（Subclassing）*指的是在一个已有类的基础上创建一个新的类。子类继承超类的特性，并且可以优化或改变它。你还可以为子类添加新的特性。
为了指明某个类的超类，将超类名写在子类名的后面，用冒号分隔： 为了指明某个类的超类，将超类名写在子类名的后面，用冒号分隔：
```swift ```swift
class SomeClass: SomeSuperclass { class SomeClass: SomeSuperclass {
// 类的定义 // 类的定义
} }
``` ```
下一个例子，定义一个更具体的车辆类叫`Bicycle`。这个新类是在 `Vehicle`类的基础上创建起来。因此你需要将`Vehicle`类放在 `Bicycle`类后面，用冒号分隔。 下一个例子，定义一个更具体的车辆类叫`Bicycle`。这个新类是在 `Vehicle`类的基础上创建起来。因此你需要将`Vehicle`类放在 `Bicycle`类后面，用冒号分隔。
我们可以将这读作： 我们可以将这读作：
“定义一个新的类叫`Bicycle `，它继承了`Vehicle`的特性”； “定义一个新的类叫`Bicycle `，它继承了`Vehicle`的特性”；
```swift ```swift
class Bicycle: Vehicle { class Bicycle: Vehicle {
init() { init() {
super.init() super.init()
numberOfWheels = 2 numberOfWheels = 2
} }
} }
``` ```
preview preview
`Bicycle`是`Vehicle`的子类，`Vehicle`是`Bicycle`的超类。新的`Bicycle`类自动获得`Vehicle`类的特性，比如 `maxPassengers`和`numberOfWheels`属性。你可以在子类中定制这些特性，或添加新的特性来更好地描述`Bicycle`类。 `Bicycle`是`Vehicle`的子类，`Vehicle`是`Bicycle`的超类。新的`Bicycle`类自动获得`Vehicle`类的特性，比如 `maxPassengers`和`numberOfWheels`属性。你可以在子类中定制这些特性，或添加新的特性来更好地描述`Bicycle`类。
`Bicycle`类定义了一个构造器来设置它定制的特性（自行车只有2个轮子）。`Bicycle`的构造器调用了它父类`Vehicle`的构造器 `super.init()`，以此确保在`Bicycle`类试图修改那些继承来的属性前`Vehicle`类已经初始化过它们了。 `Bicycle`类定义了一个构造器来设置它定制的特性（自行车只有2个轮子）。`Bicycle`的构造器调用了它父类`Vehicle`的构造器 `super.init()`，以此确保在`Bicycle`类试图修改那些继承来的属性前`Vehicle`类已经初始化过它们了。
> 注意： > 注意：
不像 Objective-C，在 Swift 中，初始化器默认是不继承的，见[初始化器的继承与重写](../chapter2/_14Initialization.html#initializer_inheritance_and_ overriding) 不像 Objective-C，在 Swift 中，初始化器默认是不继承的，见[初始化器的继承与重写](../chapter2/_14Initialization.html#initializer_inheritance_and_ overriding)
`Vehicle`类中`maxPassengers`的默认值对自行车来说已经是正确的，因此在`Bicycle`的构造器中并没有改变它。而`numberOfWheels`原来的值对自行车来说是不正确的，因此在初始化器中将它更改为 2。 `Vehicle`类中`maxPassengers`的默认值对自行车来说已经是正确的，因此在`Bicycle`的构造器中并没有改变它。而`numberOfWheels`原来的值对自行车来说是不正确的，因此在初始化器中将它更改为 2。
`Bicycle`不仅可以继承`Vehicle`的属性，还可以继承它的方法。如果你创建了一个`Bicycle`类的实例，你就可以调用它继承来的`description`方法，并且可以看到，它输出的属性值已经发生了变化： `Bicycle`不仅可以继承`Vehicle`的属性，还可以继承它的方法。如果你创建了一个`Bicycle`类的实例，你就可以调用它继承来的`description`方法，并且可以看到，它输出的属性值已经发生了变化：
```swift ```swift
let bicycle = Bicycle() let bicycle = Bicycle()
println("Bicycle: \(bicycle.description())") println("Bicycle: \(bicycle.description())")
// Bicycle: 2 wheels; up to 1 passengers // Bicycle: 2 wheels; up to 1 passengers
``` ```
子类还可以继续被其它类继承： 子类还可以继续被其它类继承：
```swift ```swift
class Tandem: Bicycle { class Tandem: Bicycle {
init() { init() {
super.init() super.init()
maxPassengers = 2 maxPassengers = 2
} }
} }
``` ```
上面的例子创建了`Bicycle`的一个子类：双人自行车（tandem）。`Tandem`从`Bicycle`继承了两个属性，而这两个属性是`Bicycle`从`Vehicle`继承而来的。`Tandem`并不修改轮子的数量，因为它仍是一辆自行车，有 2 个轮子。但它需要修改`maxPassengers`的值，因为双人自行车可以坐两个人。 上面的例子创建了`Bicycle`的一个子类：双人自行车（tandem）。`Tandem`从`Bicycle`继承了两个属性，而这两个属性是`Bicycle`从`Vehicle`继承而来的。`Tandem`并不修改轮子的数量，因为它仍是一辆自行车，有 2 个轮子。但它需要修改`maxPassengers`的值，因为双人自行车可以坐两个人。
> 注意： > 注意：
子类只允许修改从超类继承来的变量属性，而不能修改继承来的常量属性。 子类只允许修改从超类继承来的变量属性，而不能修改继承来的常量属性。
创建一个`Tandem`类的实例，打印它的描述，即可看到它的属性已被更新： 创建一个`Tandem`类的实例，打印它的描述，即可看到它的属性已被更新：
```swift ```swift
let tandem = Tandem() let tandem = Tandem()
println("Tandem: \(tandem.description())") println("Tandem: \(tandem.description())")
// Tandem: 2 wheels; up to 2 passengers // Tandem: 2 wheels; up to 2 passengers
``` ```
注意，`Tandem`类也继承了`description`方法。一个类的实例方法会被这个类的所有子类继承。 注意，`Tandem`类也继承了`description`方法。一个类的实例方法会被这个类的所有子类继承。
<a name="overriding"></a> <a name="overriding"></a>
## 重写（Overriding） ## 重写（Overriding）
子类可以为继承来的实例方法（instance method），类方法（class method），实例属性（instance property），或下标脚本（subscript）提供自己定制的实现（implementation）。我们把这种行为叫*重写（overriding）*。 子类可以为继承来的实例方法（instance method），类方法（class method），实例属性（instance property），或下标脚本（subscript）提供自己定制的实现（implementation）。我们把这种行为叫*重写（overriding）*。
如果要重写某个特性，你需要在重写定义的前面加上`override`关键字。这么做，你就表明了你是想提供一个重写版本，而非错误地提供了一个相同的定义。意外的重写行为可能会导致不可预知的错误，任何缺少`override`关键字的重写都会在编译时被诊断为错误。 如果要重写某个特性，你需要在重写定义的前面加上`override`关键字。这么做，你就表明了你是想提供一个重写版本，而非错误地提供了一个相同的定义。意外的重写行为可能会导致不可预知的错误，任何缺少`override`关键字的重写都会在编译时被诊断为错误。
`override`关键字会提醒 Swift 编译器去检查该类的超类（或其中一个父类）是否有匹配重写版本的声明。这个检查可以确保你的重写定义是正确的。 `override`关键字会提醒 Swift 编译器去检查该类的超类（或其中一个父类）是否有匹配重写版本的声明。这个检查可以确保你的重写定义是正确的。
### 访问超类的方法，属性及下标脚本 ### 访问超类的方法，属性及下标脚本
当你在子类中重写超类的方法，属性或下标脚本时，有时在你的重写版本中使用已经存在的超类实现会大有裨益。比如，你可以优化已有实现的行为，或在一个继承来的变量中存储一个修改过的值。 当你在子类中重写超类的方法，属性或下标脚本时，有时在你的重写版本中使用已经存在的超类实现会大有裨益。比如，你可以优化已有实现的行为，或在一个继承来的变量中存储一个修改过的值。
在合适的地方，你可以通过使用`super`前缀来访问超类版本的方法，属性或下标脚本： 在合适的地方，你可以通过使用`super`前缀来访问超类版本的方法，属性或下标脚本：
* 在方法`someMethod`的重写实现中，可以通过`super.someMethod()`来调用超类版本的`someMethod`方法。 * 在方法`someMethod`的重写实现中，可以通过`super.someMethod()`来调用超类版本的`someMethod`方法。
* 在属性`someProperty`的 getter 或 setter 的重写实现中，可以通过`super.someProperty`来访问超类版本的`someProperty`属性。 * 在属性`someProperty`的 getter 或 setter 的重写实现中，可以通过`super.someProperty`来访问超类版本的`someProperty`属性。
* 在下标脚本的重写实现中，可以通过`super[someIndex]`来访问超类版本中的相同下标脚本。 * 在下标脚本的重写实现中，可以通过`super[someIndex]`来访问超类版本中的相同下标脚本。
### 重写方法 ### 重写方法
在子类中，你可以重写继承来的实例方法或类方法，提供一个定制或替代的方法实现。 在子类中，你可以重写继承来的实例方法或类方法，提供一个定制或替代的方法实现。
下面的例子定义了`Vehicle`的一个新的子类，叫`Car`，它重写了从`Vehicle`类继承来的`description`方法： 下面的例子定义了`Vehicle`的一个新的子类，叫`Car`，它重写了从`Vehicle`类继承来的`description`方法：
```swift ```swift
class Car: Vehicle { class Car: Vehicle {
var speed: Double = 0.0 var speed: Double = 0.0
init() { init() {
super.init() super.init()
maxPassengers = 5 maxPassengers = 5
numberOfWheels = 4 numberOfWheels = 4
} }
override func description() -> String { override func description() -> String {
return super.description() + "; " return super.description() + "; "
+ "traveling at \(speed) mph" + "traveling at \(speed) mph"
} }
} }
``` ```
`Car`声明了一个新的存储型属性`speed`，它是`Double`类型的，默认值是`0.0`，表示“时速是0英里”。`Car`有自己的初始化器，它将乘客的最大数量设为5，轮子数量设为4。 `Car`声明了一个新的存储型属性`speed`，它是`Double`类型的，默认值是`0.0`，表示“时速是0英里”。`Car`有自己的初始化器，它将乘客的最大数量设为5，轮子数量设为4。
`Car`重写了继承来的`description`方法，它的声明与`Vehicle`中的`description`方法一致，声明前面加上了`override`关键字。 `Car`重写了继承来的`description`方法，它的声明与`Vehicle`中的`description`方法一致，声明前面加上了`override`关键字。
`Car`中的`description`方法并非完全自定义，而是通过`super.description`使用了超类`Vehicle`中的`description`方法，然后再追加一些额外的信息，比如汽车的当前速度。 `Car`中的`description`方法并非完全自定义，而是通过`super.description`使用了超类`Vehicle`中的`description`方法，然后再追加一些额外的信息，比如汽车的当前速度。
如果你创建一个`Car`的新实例，并打印`description`方法的输出，你就会发现描述信息已经发生了改变： 如果你创建一个`Car`的新实例，并打印`description`方法的输出，你就会发现描述信息已经发生了改变：
```swift ```swift
let car = Car() let car = Car()
println("Car: \(car.description())") println("Car: \(car.description())")
// Car: 4 wheels; up to 5 passengers; traveling at 0.0 mph // Car: 4 wheels; up to 5 passengers; traveling at 0.0 mph
``` ```
### 重写属性 ### 重写属性
你可以重写继承来的实例属性或类属性，提供自己定制的getter和setter，或添加属性观察器使重写的属性观察属性值什么时候发生改变。 你可以重写继承来的实例属性或类属性，提供自己定制的getter和setter，或添加属性观察器使重写的属性观察属性值什么时候发生改变。
#### 重写属性的Getters和Setters #### 重写属性的Getters和Setters
你可以提供定制的 getter（或 setter）来重写任意继承来的属性，无论继承来的属性是存储型的还是计算型的属性。子类并不知道继承来的属性是存储型的还是计算型的，它只知道继承来的属性会有一个名字和类型。你在重写一个属性时，必需将它的名字和类型都写出来。这样才能使编译器去检查你重写的属性是与超类中同名同类型的属性相匹配的。 你可以提供定制的 getter（或 setter）来重写任意继承来的属性，无论继承来的属性是存储型的还是计算型的属性。子类并不知道继承来的属性是存储型的还是计算型的，它只知道继承来的属性会有一个名字和类型。你在重写一个属性时，必需将它的名字和类型都写出来。这样才能使编译器去检查你重写的属性是与超类中同名同类型的属性相匹配的。
你可以将一个继承来的只读属性重写为一个读写属性，只需要你在重写版本的属性里提供 getter 和 setter 即可。但是，你不可以将一个继承来的读写属性重写为一个只读属性。 你可以将一个继承来的只读属性重写为一个读写属性，只需要你在重写版本的属性里提供 getter 和 setter 即可。但是，你不可以将一个继承来的读写属性重写为一个只读属性。
> 注意： > 注意：
如果你在重写属性中提供了 setter，那么你也一定要提供 getter。如果你不想在重写版本中的 getter 里修改继承来的属性值，你可以直接返回`super.someProperty`来返回继承来的值。正如下面的`SpeedLimitedCar`的例子所示。 如果你在重写属性中提供了 setter，那么你也一定要提供 getter。如果你不想在重写版本中的 getter 里修改继承来的属性值，你可以直接返回`super.someProperty`来返回继承来的值。正如下面的`SpeedLimitedCar`的例子所示。
以下的例子定义了一个新类，叫`SpeedLimitedCar`，它是`Car`的子类。类`SpeedLimitedCar`表示安装了限速装置的车，它的最高速度只能达到40mph。你可以通过重写继承来的`speed`属性来实现这个速度限制： 以下的例子定义了一个新类，叫`SpeedLimitedCar`，它是`Car`的子类。类`SpeedLimitedCar`表示安装了限速装置的车，它的最高速度只能达到40mph。你可以通过重写继承来的`speed`属性来实现这个速度限制：
```swift ```swift
class SpeedLimitedCar: Car { class SpeedLimitedCar: Car {
override var speed: Double { override var speed: Double {
get { get {
return super.speed return super.speed
} }
set { set {
super.speed = min(newValue, 40.0) super.speed = min(newValue, 40.0)
} }
} }
} }
``` ```
当你设置一个`SpeedLimitedCar`实例的`speed`属性时，属性setter的实现会去检查新值与限制值40mph的大小，它会将超类的`speed`设置为`newValue`和`40.0`中较小的那个。这两个值哪个较小由`min`函数决定，它是Swift标准库中的一个全局函数。`min`函数接收两个或更多的数，返回其中最小的那个。 当你设置一个`SpeedLimitedCar`实例的`speed`属性时，属性setter的实现会去检查新值与限制值40mph的大小，它会将超类的`speed`设置为`newValue`和`40.0`中较小的那个。这两个值哪个较小由`min`函数决定，它是Swift标准库中的一个全局函数。`min`函数接收两个或更多的数，返回其中最小的那个。
如果你尝试将`SpeedLimitedCar`实例的`speed`属性设置为一个大于40mph的数，然后打印`description`函数的输出，你会发现速度被限制在40mph： 如果你尝试将`SpeedLimitedCar`实例的`speed`属性设置为一个大于40mph的数，然后打印`description`函数的输出，你会发现速度被限制在40mph：
```swift ```swift
let limitedCar = SpeedLimitedCar() let limitedCar = SpeedLimitedCar()
limitedCar.speed = 60.0 limitedCar.speed = 60.0
println("SpeedLimitedCar: \(limitedCar.description())") println("SpeedLimitedCar: \(limitedCar.description())")
// SpeedLimitedCar: 4 wheels; up to 5 passengers; traveling at 40.0 mph // SpeedLimitedCar: 4 wheels; up to 5 passengers; traveling at 40.0 mph
``` ```
#### 重写属性观察器（Property Observer） #### 重写属性观察器（Property Observer）
你可以在属性重写中为一个继承来的属性添加属性观察器。这样一来，当继承来的属性值发生改变时，你就会被通知到，无论那个属性原本是如何实现的。关于属性观察器的更多内容，请看[属性观察器](../chapter2/_10Properties.html#property_observer)。 你可以在属性重写中为一个继承来的属性添加属性观察器。这样一来，当继承来的属性值发生改变时，你就会被通知到，无论那个属性原本是如何实现的。关于属性观察器的更多内容，请看[属性观察器](../chapter2/_10Properties.html#property_observer)。
> 注意： > 注意：
你不可以为继承来的常量存储型属性或继承来的只读计算型属性添加属性观察器。这些属性的值是不可以被设置的，所以，为它们提供`willSet`或`didSet`实现是不恰当。此外还要注意，你不可以同时提供重写的 setter 和重写的属性观察器。如果你想观察属性值的变化，并且你已经为那个属性提供了定制的 setter，那么你在 setter 中就可以观察到任何值变化了。 你不可以为继承来的常量存储型属性或继承来的只读计算型属性添加属性观察器。这些属性的值是不可以被设置的，所以，为它们提供`willSet`或`didSet`实现是不恰当。此外还要注意，你不可以同时提供重写的 setter 和重写的属性观察器。如果你想观察属性值的变化，并且你已经为那个属性提供了定制的 setter，那么你在 setter 中就可以观察到任何值变化了。
下面的例子定义了一个新类叫`AutomaticCar`，它是`Car`的子类。`AutomaticCar`表示自动挡汽车，它可以根据当前的速度自动选择合适的挡位。`AutomaticCar`也提供了定制的`description`方法，可以输出当前挡位。 下面的例子定义了一个新类叫`AutomaticCar`，它是`Car`的子类。`AutomaticCar`表示自动挡汽车，它可以根据当前的速度自动选择合适的挡位。`AutomaticCar`也提供了定制的`description`方法，可以输出当前挡位。
```swift ```swift
class AutomaticCar: Car { class AutomaticCar: Car {
var gear = 1 var gear = 1
override var speed: Double { override var speed: Double {
didSet { didSet {
gear = Int(speed / 10.0) + 1 gear = Int(speed / 10.0) + 1
} }
} }
override func description() -> String { override func description() -> String {
return super.description() + " in gear \(gear)" return super.description() + " in gear \(gear)"
} }
} }
``` ```
当你设置`AutomaticCar`的`speed`属性，属性的`didSet`观察器就会自动地设置`gear`属性，为新的速度选择一个合适的挡位。具体来说就是，属性观察器将新的速度值除以10，然后向下取得最接近的整数值，最后加1来得到档位`gear`的值。例如，速度为10.0时，挡位为1；速度为35.0时，挡位为4： 当你设置`AutomaticCar`的`speed`属性，属性的`didSet`观察器就会自动地设置`gear`属性，为新的速度选择一个合适的挡位。具体来说就是，属性观察器将新的速度值除以10，然后向下取得最接近的整数值，最后加1来得到档位`gear`的值。例如，速度为10.0时，挡位为1；速度为35.0时，挡位为4：
```swift ```swift
let automatic = AutomaticCar() let automatic = AutomaticCar()
automatic.speed = 35.0 automatic.speed = 35.0
println("AutomaticCar: \(automatic.description())") println("AutomaticCar: \(automatic.description())")
// AutomaticCar: 4 wheels; up to 5 passengers; traveling at 35.0 mph in gear 4 // AutomaticCar: 4 wheels; up to 5 passengers; traveling at 35.0 mph in gear 4
``` ```
<a name="preventing_overrides"></a> <a name="preventing_overrides"></a>
## 防止重写 ## 防止重写
你可以通过把方法，属性或下标脚本标记为*`final`*来防止它们被重写，只需要在声明关键字前加上`@final`特性即可。（例如：`@final var`, `@final func`, `@final class func`, 以及 `@final subscript`） 你可以通过把方法，属性或下标脚本标记为*`final`*来防止它们被重写，只需要在声明关键字前加上`@final`特性即可。（例如：`@final var`, `@final func`, `@final class func`, 以及 `@final subscript`）
如果你重写了`final`方法，属性或下标脚本，在编译时会报错。在扩展中，你添加到类里的方法，属性或下标脚本也可以在扩展的定义里标记为 final。 如果你重写了`final`方法，属性或下标脚本，在编译时会报错。在扩展中，你添加到类里的方法，属性或下标脚本也可以在扩展的定义里标记为 final。
你可以通过在关键字`class`前添加`@final`特性（`@final class`）来将整个类标记为 final 的，这样的类是不可被继承的，否则会报编译错误。 你可以通过在关键字`class`前添加`@final`特性（`@final class`）来将整个类标记为 final 的，这样的类是不可被继承的，否则会报编译错误。

1290
source/chapter2/14_Initialization.md
View File

File diff suppressed because it is too large Load Diff

216
source/chapter2/15_Deinitialization.md
View File

@ -1,108 +1,108 @@
> 翻译：[bruce0505](https://github.com/bruce0505) > 翻译：[bruce0505](https://github.com/bruce0505)
> 校对：[fd5788](https://github.com/fd5788) > 校对：[fd5788](https://github.com/fd5788)
# 析构过程（Deinitialization） # 析构过程（Deinitialization）
--------------------------- ---------------------------
本页包含内容： 本页包含内容：
- [析构过程原理](#how_deinitialization_works) - [析构过程原理](#how_deinitialization_works)
- [析构函数操作](#deinitializers_in_action) - [析构函数操作](#deinitializers_in_action)
在一个类的实例被释放之前，析构函数被立即调用。用关键字`deinit`来标示析构函数，类似于初始化函数用`init`来标示。析构函数只适用于类类型。 在一个类的实例被释放之前，析构函数被立即调用。用关键字`deinit`来标示析构函数，类似于初始化函数用`init`来标示。析构函数只适用于类类型。
<a name="how_deinitialization_works"></a> <a name="how_deinitialization_works"></a>
##析构过程原理 ##析构过程原理
Swift 会自动释放不再需要的实例以释放资源。如[自动引用计数](16_Automatic_Reference_Counting.html)那一章描述，Swift 通过_自动引用计数_（ARC）处理实例的内存管理。通常当你的实例被释放时不需要手动地去清理。但是，当使用自己的资源时，你可能需要进行一些额外的清理。例如，如果创建了一个自定义的类来打开一个文件，并写入一些数据，你可能需要在类实例被释放之前关闭该文件。 Swift 会自动释放不再需要的实例以释放资源。如[自动引用计数](16_Automatic_Reference_Counting.html)那一章描述，Swift 通过_自动引用计数_（ARC）处理实例的内存管理。通常当你的实例被释放时不需要手动地去清理。但是，当使用自己的资源时，你可能需要进行一些额外的清理。例如，如果创建了一个自定义的类来打开一个文件，并写入一些数据，你可能需要在类实例被释放之前关闭该文件。
在类的定义中，每个类最多只能有一个析构函数。析构函数不带任何参数，在写法上不带括号： 在类的定义中，每个类最多只能有一个析构函数。析构函数不带任何参数，在写法上不带括号：
```swift ```swift
deinit { deinit {
// 执行析构过程 // 执行析构过程
} }
``` ```
析构函数是在实例释放发生前一步被自动调用。不允许主动调用自己的析构函数。子类继承了父类的析构函数，并且在子类析构函数实现的最后，父类的析构函数被自动调用。即使子类没有提供自己的析构函数，父类的析构函数也总是被调用。 析构函数是在实例释放发生前一步被自动调用。不允许主动调用自己的析构函数。子类继承了父类的析构函数，并且在子类析构函数实现的最后，父类的析构函数被自动调用。即使子类没有提供自己的析构函数，父类的析构函数也总是被调用。
因为直到实例的析构函数被调用时，实例才会被释放，所以析构函数可以访问所有请求实例的属性，并且根据那些属性可以修改它的行为（比如查找一个需要被关闭的文件的名称）。 因为直到实例的析构函数被调用时，实例才会被释放，所以析构函数可以访问所有请求实例的属性，并且根据那些属性可以修改它的行为（比如查找一个需要被关闭的文件的名称）。
<a name="deinitializers_in_action"></a> <a name="deinitializers_in_action"></a>
##析构函数操作 ##析构函数操作
这里是一个析构函数操作的例子。这个例子是一个简单的游戏，定义了两种新类型，`Bank`和`Player`。`Bank`结构体管理一个虚拟货币的流通，在这个流通中`Bank`永远不可能拥有超过 10,000 的硬币。在这个游戏中有且只能有一个`Bank`存在，因此`Bank`由带有静态属性和静态方法的结构体实现，从而存储和管理其当前的状态。 这里是一个析构函数操作的例子。这个例子是一个简单的游戏，定义了两种新类型，`Bank`和`Player`。`Bank`结构体管理一个虚拟货币的流通，在这个流通中`Bank`永远不可能拥有超过 10,000 的硬币。在这个游戏中有且只能有一个`Bank`存在，因此`Bank`由带有静态属性和静态方法的结构体实现，从而存储和管理其当前的状态。
```swift ```swift
struct Bank { struct Bank {
static var coinsInBank = 10_000 static var coinsInBank = 10_000
static func vendCoins(var numberOfCoinsToVend: Int) -> Int { static func vendCoins(var numberOfCoinsToVend: Int) -> Int {
numberOfCoinsToVend = min(numberOfCoinsToVend, coinsInBank) numberOfCoinsToVend = min(numberOfCoinsToVend, coinsInBank)
coinsInBank -= numberOfCoinsToVend coinsInBank -= numberOfCoinsToVend
return numberOfCoinsToVend return numberOfCoinsToVend
} }
static func receiveCoins(coins: Int) { static func receiveCoins(coins: Int) {
coinsInBank += coins coinsInBank += coins
} }
} }
``` ```
`Bank`根据它的`coinsInBank`属性来跟踪当前它拥有的硬币数量。银行还提供两个方法——`vendCoins`和`receiveCoins`——用来处理硬币的分发和收集。 `Bank`根据它的`coinsInBank`属性来跟踪当前它拥有的硬币数量。银行还提供两个方法——`vendCoins`和`receiveCoins`——用来处理硬币的分发和收集。
`vendCoins`方法在 bank 分发硬币之前检查是否有足够的硬币。如果没有足够多的硬币，`Bank`返回一个比请求时小的数字(如果没有硬币留在 bank 中就返回 0)。`vendCoins`方法声明`numberOfCoinsToVend`为一个变量参数，这样就可以在方法体的内部修改数字，而不需要定义一个新的变量。`vendCoins`方法返回一个整型值，表明了提供的硬币的实际数目。 `vendCoins`方法在 bank 分发硬币之前检查是否有足够的硬币。如果没有足够多的硬币，`Bank`返回一个比请求时小的数字(如果没有硬币留在 bank 中就返回 0)。`vendCoins`方法声明`numberOfCoinsToVend`为一个变量参数，这样就可以在方法体的内部修改数字，而不需要定义一个新的变量。`vendCoins`方法返回一个整型值，表明了提供的硬币的实际数目。
`receiveCoins`方法只是将 bank 的硬币存储和接收到的硬币数目相加，再保存回 bank。 `receiveCoins`方法只是将 bank 的硬币存储和接收到的硬币数目相加，再保存回 bank。
`Player`类描述了游戏中的一个玩家。每一个 player 在任何时刻都有一定数量的硬币存储在他们的钱包中。这通过 player 的`coinsInPurse`属性来体现： `Player`类描述了游戏中的一个玩家。每一个 player 在任何时刻都有一定数量的硬币存储在他们的钱包中。这通过 player 的`coinsInPurse`属性来体现：
```swift ```swift
class Player { class Player {
var coinsInPurse: Int var coinsInPurse: Int
init(coins: Int) { init(coins: Int) {
coinsInPurse = Bank.vendCoins(coins) coinsInPurse = Bank.vendCoins(coins)
} }
func winCoins(coins: Int) { func winCoins(coins: Int) {
coinsInPurse += Bank.vendCoins(coins) coinsInPurse += Bank.vendCoins(coins)
} }
deinit { deinit {
Bank.receiveCoins(coinsInPurse) Bank.receiveCoins(coinsInPurse)
} }
} }
``` ```
每个`Player`实例都由一个指定数目硬币组成的启动额度初始化，这些硬币在 bank 初始化的过程中得到。如果没有足够的硬币可用，`Player`实例可能收到比指定数目少的硬币。 每个`Player`实例都由一个指定数目硬币组成的启动额度初始化，这些硬币在 bank 初始化的过程中得到。如果没有足够的硬币可用，`Player`实例可能收到比指定数目少的硬币。
`Player`类定义了一个`winCoins`方法，该方法从银行获取一定数量的硬币，并把它们添加到玩家的钱包。`Player`类还实现了一个析构函数，这个析构函数在`Player`实例释放前一步被调用。这里析构函数只是将玩家的所有硬币都返回给银行： `Player`类定义了一个`winCoins`方法，该方法从银行获取一定数量的硬币，并把它们添加到玩家的钱包。`Player`类还实现了一个析构函数，这个析构函数在`Player`实例释放前一步被调用。这里析构函数只是将玩家的所有硬币都返回给银行：
```swift ```swift
var playerOne: Player? = Player(coins: 100) var playerOne: Player? = Player(coins: 100)
println("A new player has joined the game with \(playerOne!.coinsInPurse) coins") println("A new player has joined the game with \(playerOne!.coinsInPurse) coins")
// 输出 "A new player has joined the game with 100 coins" // 输出 "A new player has joined the game with 100 coins"
println("There are now \(Bank.coinsInBank) coins left in the bank") println("There are now \(Bank.coinsInBank) coins left in the bank")
// 输出 "There are now 9900 coins left in the bank" // 输出 "There are now 9900 coins left in the bank"
``` ```
一个新的`Player`实例随着一个 100 个硬币（如果有）的请求而被创建。这`个Player`实例存储在一个名为`playerOne`的可选`Player`变量中。这里使用一个可选变量，是因为玩家可以随时离开游戏。设置为可选使得你可以跟踪当前是否有玩家在游戏中。 一个新的`Player`实例随着一个 100 个硬币（如果有）的请求而被创建。这`个Player`实例存储在一个名为`playerOne`的可选`Player`变量中。这里使用一个可选变量，是因为玩家可以随时离开游戏。设置为可选使得你可以跟踪当前是否有玩家在游戏中。
因为`playerOne`是可选的，所以由一个感叹号（`!`）来修饰，每当其`winCoins`方法被调用时，`coinsInPurse`属性被访问并打印出它的默认硬币数目。 因为`playerOne`是可选的，所以由一个感叹号（`!`）来修饰，每当其`winCoins`方法被调用时，`coinsInPurse`属性被访问并打印出它的默认硬币数目。
```swift ```swift
playerOne!.winCoins(2_000) playerOne!.winCoins(2_000)
println("PlayerOne won 2000 coins & now has \ (playerOne!.coinsInPurse) coins") println("PlayerOne won 2000 coins & now has \ (playerOne!.coinsInPurse) coins")
// 输出 "PlayerOne won 2000 coins & now has 2100 coins" // 输出 "PlayerOne won 2000 coins & now has 2100 coins"
println("The bank now only has \(Bank.coinsInBank) coins left") println("The bank now only has \(Bank.coinsInBank) coins left")
// 输出 "The bank now only has 7900 coins left" // 输出 "The bank now only has 7900 coins left"
``` ```
这里，player 已经赢得了 2,000 硬币。player 的钱包现在有 2,100 硬币，bank 只剩余 7,900 硬币。 这里，player 已经赢得了 2,000 硬币。player 的钱包现在有 2,100 硬币，bank 只剩余 7,900 硬币。
```swift ```swift
playerOne = nil playerOne = nil
println("PlayerOne has left the game") println("PlayerOne has left the game")
// 输出 "PlayerOne has left the game" // 输出 "PlayerOne has left the game"
println("The bank now has \(Bank.coinsInBank) coins") println("The bank now has \(Bank.coinsInBank) coins")
// 输出 "The bank now has 10000 coins" // 输出 "The bank now has 10000 coins"
``` ```
玩家现在已经离开了游戏。这表明是要将可选的`playerOne`变量设置为`nil`，意思是“没有`Player`实例”。当这种情况发生的时候，`playerOne`变量对`Player`实例的引用被破坏了。没有其它属性或者变量引用`Player`实例，因此为了清空它占用的内存从而释放它。在这发生前一步，其析构函数被自动调用，其硬币被返回到银行。 玩家现在已经离开了游戏。这表明是要将可选的`playerOne`变量设置为`nil`，意思是“没有`Player`实例”。当这种情况发生的时候，`playerOne`变量对`Player`实例的引用被破坏了。没有其它属性或者变量引用`Player`实例，因此为了清空它占用的内存从而释放它。在这发生前一步，其析构函数被自动调用，其硬币被返回到银行。

1110
source/chapter2/16_Automatic_Reference_Counting.md
View File

File diff suppressed because it is too large Load Diff

642
source/chapter2/17_Optional_Chaining.md
View File

@ -1,321 +1,321 @@
> 翻译：[Jasonbroker](https://github.com/Jasonbroker) > 翻译：[Jasonbroker](https://github.com/Jasonbroker)
> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai) > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
# Optional Chaining # Optional Chaining
----------------- -----------------
本页包含内容： 本页包含内容：
- [可选链可替代强制解析](#optional_chaining_as_an_alternative_to_forced_unwrapping) - [可选链可替代强制解析](#optional_chaining_as_an_alternative_to_forced_unwrapping)
- [为可选链定义模型类](#defining_model_classes_for_optional_chaining) - [为可选链定义模型类](#defining_model_classes_for_optional_chaining)
- [通过可选链调用属性](#calling_properties_through_optional_chaining) - [通过可选链调用属性](#calling_properties_through_optional_chaining)
- [通过可选链调用方法](#calling_methods_through_optional_chaining) - [通过可选链调用方法](#calling_methods_through_optional_chaining)
- [使用可选链调用子脚本](#calling_subscripts_through_optional_chaining) - [使用可选链调用子脚本](#calling_subscripts_through_optional_chaining)
- [连接多层链接](#linking_multiple_levels_of_chaining) - [连接多层链接](#linking_multiple_levels_of_chaining)
- [链接可选返回值的方法](#chaining_on_methods_with_optional_return_values) - [链接可选返回值的方法](#chaining_on_methods_with_optional_return_values)
可选链（Optional Chaining）是一种可以请求和调用属性、方法及子脚本的过程，它的可选性体现于请求或调用的目标当前可能为空（`nil`）。如果可选的目标有值，那么调用就会成功；相反，如果选择的目标为空（`nil`），则这种调用将返回空（`nil`）。多次请求或调用可以被链接在一起形成一个链，如果任何一个节点为空（`nil`）将导致整个链失效。 可选链（Optional Chaining）是一种可以请求和调用属性、方法及子脚本的过程，它的可选性体现于请求或调用的目标当前可能为空（`nil`）。如果可选的目标有值，那么调用就会成功；相反，如果选择的目标为空（`nil`），则这种调用将返回空（`nil`）。多次请求或调用可以被链接在一起形成一个链，如果任何一个节点为空（`nil`）将导致整个链失效。
> 注意： > 注意：
Swift 的可选链和 Objective-C 中的消息为空有些相像，但是 Swift 可以使用在任意类型中，并且失败与否可以被检测到。 Swift 的可选链和 Objective-C 中的消息为空有些相像，但是 Swift 可以使用在任意类型中，并且失败与否可以被检测到。
<a name="optional_chaining_as_an_alternative_to_forced_unwrapping"></a> <a name="optional_chaining_as_an_alternative_to_forced_unwrapping"></a>
## 可选链可替代强制解析 ## 可选链可替代强制解析
通过在想调用的属性、方法、或子脚本的可选值（`optional value`）（非空）后面放一个问号，可以定义一个可选链。这一点很像在可选值后面放一个叹号来强制拆得其封包内的值。它们的主要的区别在于当可选值为空时可选链即刻失败，然而一般的强制解析将会引发运行时错误。 通过在想调用的属性、方法、或子脚本的可选值（`optional value`）（非空）后面放一个问号，可以定义一个可选链。这一点很像在可选值后面放一个叹号来强制拆得其封包内的值。它们的主要的区别在于当可选值为空时可选链即刻失败，然而一般的强制解析将会引发运行时错误。
为了反映可选链可以调用空（`nil`），不论你调用的属性、方法、子脚本等返回的值是不是可选值，它的返回结果都是一个可选值。你可以利用这个返回值来检测你的可选链是否调用成功，有返回值即成功，返回nil则失败。 为了反映可选链可以调用空（`nil`），不论你调用的属性、方法、子脚本等返回的值是不是可选值，它的返回结果都是一个可选值。你可以利用这个返回值来检测你的可选链是否调用成功，有返回值即成功，返回nil则失败。
调用可选链的返回结果与原本的返回结果具有相同的类型，但是原本的返回结果被包装成了一个可选值，当可选链调用成功时，一个应该返回`Int`的属性将会返回`Int?`。 调用可选链的返回结果与原本的返回结果具有相同的类型，但是原本的返回结果被包装成了一个可选值，当可选链调用成功时，一个应该返回`Int`的属性将会返回`Int?`。
下面几段代码将解释可选链和强制解析的不同。 下面几段代码将解释可选链和强制解析的不同。
首先定义两个类`Person`和`Residence`。 首先定义两个类`Person`和`Residence`。
```swift ```swift
class Person { class Person {
var residence: Residence? var residence: Residence?
} }
class Residence { class Residence {
var numberOfRooms = 1 var numberOfRooms = 1
} }
``` ```
`Residence`具有一个`Int`类型的`numberOfRooms`，其值为 1。`Person`具有一个可选`residence`属性，它的类型是`Residence？`。 `Residence`具有一个`Int`类型的`numberOfRooms`，其值为 1。`Person`具有一个可选`residence`属性，它的类型是`Residence？`。
如果你创建一个新的`Person`实例，它的`residence`属性由于是被定义为可选型的，此属性将默认初始化为空： 如果你创建一个新的`Person`实例，它的`residence`属性由于是被定义为可选型的，此属性将默认初始化为空：
```swift ```swift
let john = Person() let john = Person()
``` ```
如果你想使用感叹号（`!`）强制解析获得这个人`residence`属性`numberOfRooms`属性值，将会引发运行时错误，因为这时没有可以供解析的`residence`值。 如果你想使用感叹号（`!`）强制解析获得这个人`residence`属性`numberOfRooms`属性值，将会引发运行时错误，因为这时没有可以供解析的`residence`值。
```swift ```swift
let roomCount = john.residence!.numberOfRooms let roomCount = john.residence!.numberOfRooms
//将导致运行时错误 //将导致运行时错误
``` ```
当`john.residence`不是`nil`时，会运行通过，且会将`roomCount` 设置为一个`int`类型的合理值。然而，如上所述，当`residence`为空时，这个代码将会导致运行时错误。 当`john.residence`不是`nil`时，会运行通过，且会将`roomCount` 设置为一个`int`类型的合理值。然而，如上所述，当`residence`为空时，这个代码将会导致运行时错误。
可选链提供了一种另一种获得`numberOfRooms`的方法。利用可选链，使用问号来代替原来`!`的位置： 可选链提供了一种另一种获得`numberOfRooms`的方法。利用可选链，使用问号来代替原来`!`的位置：
```swift ```swift
if let roomCount = john.residence?.numberOfRooms { if let roomCount = john.residence?.numberOfRooms {
println("John's residence has \(roomCount) room(s).") println("John's residence has \(roomCount) room(s).")
} else { } else {
println("Unable to retrieve the number of rooms.") println("Unable to retrieve the number of rooms.")
} }
// 打印 "Unable to retrieve the number of rooms. // 打印 "Unable to retrieve the number of rooms.
``` ```
这告诉 Swift 来链接可选`residence?`属性，如果`residence`存在则取回`numberOfRooms`的值。 这告诉 Swift 来链接可选`residence?`属性，如果`residence`存在则取回`numberOfRooms`的值。
因为这种尝试获得`numberOfRooms`的操作有可能失败，可选链会返回`Int?`类型值，或者称作“可选`Int`”。当`residence`是空的时候（上例），选择`Int`将会为空，因此会出先无法访问`numberOfRooms`的情况。 因为这种尝试获得`numberOfRooms`的操作有可能失败，可选链会返回`Int?`类型值，或者称作“可选`Int`”。当`residence`是空的时候（上例），选择`Int`将会为空，因此会出先无法访问`numberOfRooms`的情况。
要注意的是，即使numberOfRooms是非可选`Int`（`Int?`）时这一点也成立。只要是通过可选链的请求就意味着最后`numberOfRooms`总是返回一个`Int?`而不是`Int`。 要注意的是，即使numberOfRooms是非可选`Int`（`Int?`）时这一点也成立。只要是通过可选链的请求就意味着最后`numberOfRooms`总是返回一个`Int?`而不是`Int`。
你可以自己定义一个`Residence`实例给`john.residence`，这样它就不再为空了： 你可以自己定义一个`Residence`实例给`john.residence`，这样它就不再为空了：
```swift ```swift
john.residence = Residence() john.residence = Residence()
``` ```
`john.residence` 现在有了实际存在的实例而不是nil了。如果你想使用和前面一样的可选链来获得`numberOfRoooms`，它将返回一个包含默认值 1 的`Int?`： `john.residence` 现在有了实际存在的实例而不是nil了。如果你想使用和前面一样的可选链来获得`numberOfRoooms`，它将返回一个包含默认值 1 的`Int?`：
```swift ```swift
if let roomCount = john.residence?.numberOfRooms { if let roomCount = john.residence?.numberOfRooms {
println("John's residence has \(roomCount) room(s).") println("John's residence has \(roomCount) room(s).")
} else { } else {
println("Unable to retrieve the number of rooms.") println("Unable to retrieve the number of rooms.")
} }
// 打印 "John's residence has 1 room(s)"。 // 打印 "John's residence has 1 room(s)"。
``` ```
<a name="defining_model_classes_for_optional_chaining"></a> <a name="defining_model_classes_for_optional_chaining"></a>
##为可选链定义模型类 ##为可选链定义模型类
你可以使用可选链来多层调用属性，方法，和子脚本。这让你可以利用它们之间的复杂模型来获取更底层的属性，并检查是否可以成功获取此类底层属性。 你可以使用可选链来多层调用属性，方法，和子脚本。这让你可以利用它们之间的复杂模型来获取更底层的属性，并检查是否可以成功获取此类底层属性。
后面的代码定义了四个将在后面使用的模型类，其中包括多层可选链。这些类是由上面的`Person`和`Residence`模型通过添加一个`Room`和一个`Address`类拓展来。 后面的代码定义了四个将在后面使用的模型类，其中包括多层可选链。这些类是由上面的`Person`和`Residence`模型通过添加一个`Room`和一个`Address`类拓展来。
`Person`类定义与之前相同。 `Person`类定义与之前相同。
```swift ```swift
class Person { class Person {
var residence: Residence? var residence: Residence?
} }
``` ```
`Residence`类比之前复杂些。这次，它定义了一个变量 `rooms`，它被初始化为一个`Room[]`类型的空数组： `Residence`类比之前复杂些。这次，它定义了一个变量 `rooms`，它被初始化为一个`Room[]`类型的空数组：
```swift ```swift
class Residence { class Residence {
var rooms = Room[]() var rooms = Room[]()
var numberOfRooms: Int { var numberOfRooms: Int {
return rooms.count return rooms.count
} }
subscript(i: Int) -> Room { subscript(i: Int) -> Room {
return rooms[i] return rooms[i]
} }
func printNumberOfRooms() { func printNumberOfRooms() {
println("The number of rooms is \(numberOfRooms)") println("The number of rooms is \(numberOfRooms)")
} }
var address: Address? var address: Address?
} }
``` ```
因为`Residence`存储了一个`Room`实例的数组，它的`numberOfRooms`属性值不是一个固定的存储值，而是通过计算而来的。`numberOfRooms`属性值是由返回`rooms`数组的`count`属性值得到的。 因为`Residence`存储了一个`Room`实例的数组，它的`numberOfRooms`属性值不是一个固定的存储值，而是通过计算而来的。`numberOfRooms`属性值是由返回`rooms`数组的`count`属性值得到的。
为了能快速访问`rooms`数组，`Residence`定义了一个只读的子脚本，通过插入数组的元素角标就可以成功调用。如果该角标存在，子脚本则将该元素返回。 为了能快速访问`rooms`数组，`Residence`定义了一个只读的子脚本，通过插入数组的元素角标就可以成功调用。如果该角标存在，子脚本则将该元素返回。
`Residence`中也提供了一个`printNumberOfRooms`的方法，即简单的打印房间个数。 `Residence`中也提供了一个`printNumberOfRooms`的方法，即简单的打印房间个数。
最后，`Residence`定义了一个可选属性叫`address`（`address?`）。`Address`类的属性将在后面定义。 最后，`Residence`定义了一个可选属性叫`address`（`address?`）。`Address`类的属性将在后面定义。
用于`rooms`数组的`Room`类是一个很简单的类，它只有一个`name`属性和一个设定`room`名的初始化器。 用于`rooms`数组的`Room`类是一个很简单的类，它只有一个`name`属性和一个设定`room`名的初始化器。
```swift ```swift
class Room { class Room {
let name: String let name: String
init(name: String) { self.name = name } init(name: String) { self.name = name }
} }
``` ```
这个模型中的最终类叫做`Address`。它有三个类型是`String?`的可选属性。前面两个可选属性`buildingName`和 `buildingNumber`作为地址的一部分，是定义某个建筑物的两种方式。第三个属性`street`，用于命名地址的街道名： 这个模型中的最终类叫做`Address`。它有三个类型是`String?`的可选属性。前面两个可选属性`buildingName`和 `buildingNumber`作为地址的一部分，是定义某个建筑物的两种方式。第三个属性`street`，用于命名地址的街道名：
```swift ```swift
class Address { class Address {
var buildingName: String? var buildingName: String?
var buildingNumber: String? var buildingNumber: String?
var street: String? var street: String?
func buildingIdentifier() -> String? { func buildingIdentifier() -> String? {
if buildingName { if buildingName {
return buildingName return buildingName
} else if buildingNumber { } else if buildingNumber {
return buildingNumber return buildingNumber
} else { } else {
return nil return nil
} }
} }
} }
``` ```
`Address`类还提供了一个`buildingIdentifier`的方法，它的返回值类型为`String?`。这个方法检查`buildingName`和`buildingNumber`的属性，如果`buildingName`有值则将其返回，或者如果`buildingNumber`有值则将其返回，再或如果没有一个属性有值，返回空。 `Address`类还提供了一个`buildingIdentifier`的方法，它的返回值类型为`String?`。这个方法检查`buildingName`和`buildingNumber`的属性，如果`buildingName`有值则将其返回，或者如果`buildingNumber`有值则将其返回，再或如果没有一个属性有值，返回空。
<a name="calling_properties_through_optional_chaining"></a> <a name="calling_properties_through_optional_chaining"></a>
##通过可选链调用属性 ##通过可选链调用属性
正如上面“ [可选链可替代强制解析](#optional_chaining_as_an_alternative_to_forced_unwrapping)”中所述，你可以利用可选链的可选值获取属性，并且检查属性是否获取成功。然而，你不能使用可选链为属性赋值。 正如上面“ [可选链可替代强制解析](#optional_chaining_as_an_alternative_to_forced_unwrapping)”中所述，你可以利用可选链的可选值获取属性，并且检查属性是否获取成功。然而，你不能使用可选链为属性赋值。
使用上述定义的类来创建一个人实例，并再次尝试后去它的`numberOfRooms`属性： 使用上述定义的类来创建一个人实例，并再次尝试后去它的`numberOfRooms`属性：
```swift ```swift
let john = Person() let john = Person()
if let roomCount = john.residence?.numberOfRooms { if let roomCount = john.residence?.numberOfRooms {
println("John's residence has \(roomCount) room(s).") println("John's residence has \(roomCount) room(s).")
} else { } else {
println("Unable to retrieve the number of rooms.") println("Unable to retrieve the number of rooms.")
} }
// 打印 "Unable to retrieve the number of rooms。 // 打印 "Unable to retrieve the number of rooms。
``` ```
由于`john.residence`是空，所以这个可选链和之前一样失败了，但是没有运行时错误。 由于`john.residence`是空，所以这个可选链和之前一样失败了，但是没有运行时错误。
<a name="calling_methods_through_optional_chaining"></a> <a name="calling_methods_through_optional_chaining"></a>
##通过可选链调用方法 ##通过可选链调用方法
你可以使用可选链的来调用可选值的方法并检查方法调用是否成功。即使这个方法没有返回值，你依然可以使用可选链来达成这一目的。 你可以使用可选链的来调用可选值的方法并检查方法调用是否成功。即使这个方法没有返回值，你依然可以使用可选链来达成这一目的。
`Residence`的`printNumberOfRooms`方法会打印`numberOfRooms`的当前值。方法如下： `Residence`的`printNumberOfRooms`方法会打印`numberOfRooms`的当前值。方法如下：
```swift ```swift
func printNumberOfRooms(){ func printNumberOfRooms(){
println(“The number of rooms is \(numberOfRooms)”) println(“The number of rooms is \(numberOfRooms)”)
} }
``` ```
这个方法没有返回值。但是，没有返回值类型的函数和方法有一个隐式的返回值类型`Void`（参见Function Without Return Values）。 这个方法没有返回值。但是，没有返回值类型的函数和方法有一个隐式的返回值类型`Void`（参见Function Without Return Values）。
如果你利用可选链调用此方法，这个方法的返回值类型将是`Void?`，而不是`Void`，因为当通过可选链调用方法时返回值总是可选类型（optional type）。即使这个方法本身没有定义返回值，你也可以使用`if`语句来检查是否能成功调用`printNumberOfRooms`方法：如果方法通过可选链调用成功，`printNumberOfRooms`的隐式返回值将会是`Void`，如果没有成功，将返回`nil`： 如果你利用可选链调用此方法，这个方法的返回值类型将是`Void?`，而不是`Void`，因为当通过可选链调用方法时返回值总是可选类型（optional type）。即使这个方法本身没有定义返回值，你也可以使用`if`语句来检查是否能成功调用`printNumberOfRooms`方法：如果方法通过可选链调用成功，`printNumberOfRooms`的隐式返回值将会是`Void`，如果没有成功，将返回`nil`：
```swift ```swift
if john.residence?.printNumberOfRooms() { if john.residence?.printNumberOfRooms() {
println("It was possible to print the number of rooms.") println("It was possible to print the number of rooms.")
} else { } else {
println("It was not possible to print the number of rooms.") println("It was not possible to print the number of rooms.")
} }
// 打印 "It was not possible to print the number of rooms."。 // 打印 "It was not possible to print the number of rooms."。
``` ```
<a name="calling_subscripts_through_optional_chaining"></a> <a name="calling_subscripts_through_optional_chaining"></a>
##使用可选链调用子脚本 ##使用可选链调用子脚本
你可以使用可选链来尝试从子脚本获取值并检查子脚本的调用是否成功，然而，你不能通过可选链来设置子代码。 你可以使用可选链来尝试从子脚本获取值并检查子脚本的调用是否成功，然而，你不能通过可选链来设置子代码。
> 注意： > 注意：
当你使用可选链来获取子脚本的时候，你应该将问号放在子脚本括号的前面而不是后面。可选链的问号一般直接跟在表达语句的后面。 当你使用可选链来获取子脚本的时候，你应该将问号放在子脚本括号的前面而不是后面。可选链的问号一般直接跟在表达语句的后面。
下面这个例子用在`Residence`类中定义的子脚本来获取`john.residence`数组中第一个房间的名字。因为`john.residence`现在是`nil`，子脚本的调用失败了。 下面这个例子用在`Residence`类中定义的子脚本来获取`john.residence`数组中第一个房间的名字。因为`john.residence`现在是`nil`，子脚本的调用失败了。
```swift ```swift
if let firstRoomName = john.residence?[0].name { if let firstRoomName = john.residence?[0].name {
println("The first room name is \(firstRoomName).") println("The first room name is \(firstRoomName).")
} else { } else {
println("Unable to retrieve the first room name.") println("Unable to retrieve the first room name.")
} }
// 打印 "Unable to retrieve the first room name."。 // 打印 "Unable to retrieve the first room name."。
``` ```
在子代码调用中可选链的问号直接跟在`john.residence`的后面，在子脚本括号的前面，因为`john.residence`是可选链试图获得的可选值。 在子代码调用中可选链的问号直接跟在`john.residence`的后面，在子脚本括号的前面，因为`john.residence`是可选链试图获得的可选值。
如果你创建一个`Residence`实例给`john.residence`，且在他的`rooms`数组中有一个或多个`Room`实例，那么你可以使用可选链通过`Residence`子脚本来获取在`rooms`数组中的实例了： 如果你创建一个`Residence`实例给`john.residence`，且在他的`rooms`数组中有一个或多个`Room`实例，那么你可以使用可选链通过`Residence`子脚本来获取在`rooms`数组中的实例了：
```swift ```swift
let johnsHouse = Residence() let johnsHouse = Residence()
johnsHouse.rooms += Room(name: "Living Room") johnsHouse.rooms += Room(name: "Living Room")
johnsHouse.rooms += Room(name: "Kitchen") johnsHouse.rooms += Room(name: "Kitchen")
john.residence = johnsHouse john.residence = johnsHouse
if let firstRoomName = john.residence?[0].name { if let firstRoomName = john.residence?[0].name {
println("The first room name is \(firstRoomName).") println("The first room name is \(firstRoomName).")
} else { } else {
println("Unable to retrieve the first room name.") println("Unable to retrieve the first room name.")
} }
// 打印 "The first room name is Living Room."。 // 打印 "The first room name is Living Room."。
``` ```
<a name="linking_multiple_levels_of_chaining"></a> <a name="linking_multiple_levels_of_chaining"></a>
##连接多层链接 ##连接多层链接
你可以将多层可选链连接在一起，可以掘取模型内更下层的属性方法和子脚本。然而多层可选链不能再添加比已经返回的可选值更多的层。 你可以将多层可选链连接在一起，可以掘取模型内更下层的属性方法和子脚本。然而多层可选链不能再添加比已经返回的可选值更多的层。
也就是说： 也就是说：
如果你试图获得的类型不是可选类型，由于使用了可选链它将变成可选类型。 如果你试图获得的类型不是可选类型，由于使用了可选链它将变成可选类型。
如果你试图获得的类型已经是可选类型，由于可选链它也不会提高可选性。 如果你试图获得的类型已经是可选类型，由于可选链它也不会提高可选性。
因此： 因此：
如果你试图通过可选链获得`Int`值，不论使用了多少层链接返回的总是`Int?`。 如果你试图通过可选链获得`Int`值，不论使用了多少层链接返回的总是`Int?`。
相似的，如果你试图通过可选链获得`Int?`值，不论使用了多少层链接返回的总是`Int?`。 相似的，如果你试图通过可选链获得`Int?`值，不论使用了多少层链接返回的总是`Int?`。
下面的例子试图获取`john`的`residence`属性里的`address`的`street`属性。这里使用了两层可选链来联系`residence`和`address`属性，它们两者都是可选类型： 下面的例子试图获取`john`的`residence`属性里的`address`的`street`属性。这里使用了两层可选链来联系`residence`和`address`属性，它们两者都是可选类型：
```swift ```swift
if let johnsStreet = john.residence?.address?.street { if let johnsStreet = john.residence?.address?.street {
println("John's street name is \(johnsStreet).") println("John's street name is \(johnsStreet).")
} else { } else {
println("Unable to retrieve the address.") println("Unable to retrieve the address.")
} }
// 打印 "Unable to retrieve the address.”。 // 打印 "Unable to retrieve the address.”。
``` ```
`john.residence`的值现在包含一个`Residence`实例，然而`john.residence.address`现在是`nil`，因此`john.residence?.address?.street`调用失败。 `john.residence`的值现在包含一个`Residence`实例，然而`john.residence.address`现在是`nil`，因此`john.residence?.address?.street`调用失败。
从上面的例子发现，你试图获得`street`属性值。这个属性的类型是`String?`。因此尽管在可选类型属性前使用了两层可选链，`john.residence?.address?.street`的返回值类型也是`String?`。 从上面的例子发现，你试图获得`street`属性值。这个属性的类型是`String?`。因此尽管在可选类型属性前使用了两层可选链，`john.residence?.address?.street`的返回值类型也是`String?`。
如果你为`Address`设定一个实例来作为`john.residence.address`的值，并为`address`的`street`属性设定一个实际值，你可以通过多层可选链来得到这个属性值。 如果你为`Address`设定一个实例来作为`john.residence.address`的值，并为`address`的`street`属性设定一个实际值，你可以通过多层可选链来得到这个属性值。
```swift ```swift
let johnsAddress = Address() let johnsAddress = Address()
johnsAddress.buildingName = "The Larches" johnsAddress.buildingName = "The Larches"
johnsAddress.street = "Laurel Street" johnsAddress.street = "Laurel Street"
john.residence!.address = johnsAddress john.residence!.address = johnsAddress
``` ```
```swift ```swift
if let johnsStreet = john.residence?.address?.street { if let johnsStreet = john.residence?.address?.street {
println("John's street name is \(johnsStreet).") println("John's street name is \(johnsStreet).")
} else { } else {
println("Unable to retrieve the address.") println("Unable to retrieve the address.")
} }
// 打印 "John's street name is Laurel Street."。 // 打印 "John's street name is Laurel Street."。
``` ```
值得注意的是，“`!`”符号在给`john.residence.address`分配`address`实例时的使用。`john.residence`属性是一个可选类型，因此你需要在它获取`address`属性之前使用`!`解析以获得它的实际值。 值得注意的是，“`!`”符号在给`john.residence.address`分配`address`实例时的使用。`john.residence`属性是一个可选类型，因此你需要在它获取`address`属性之前使用`!`解析以获得它的实际值。
<a name="chaining_on_methods_with_optional_return_values"></a> <a name="chaining_on_methods_with_optional_return_values"></a>
##链接可选返回值的方法 ##链接可选返回值的方法
前面的例子解释了如何通过可选链来获得可选类型属性值。你也可以通过可选链调用一个返回可选类型值的方法并按需链接该方法的返回值。 前面的例子解释了如何通过可选链来获得可选类型属性值。你也可以通过可选链调用一个返回可选类型值的方法并按需链接该方法的返回值。
下面的例子通过可选链调用了`Address`类中的`buildingIdentifier` 方法。这个方法的返回值类型是`String?`。如上所述，这个方法在可选链调用后最终的返回值类型依然是`String?`： 下面的例子通过可选链调用了`Address`类中的`buildingIdentifier` 方法。这个方法的返回值类型是`String?`。如上所述，这个方法在可选链调用后最终的返回值类型依然是`String?`：
```swift ```swift
if let buildingIdentifier = john.residence?.address?.buildingIdentifier() { if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
println("John's building identifier is \(buildingIdentifier).") println("John's building identifier is \(buildingIdentifier).")
} }
// 打印 "John's building identifier is The Larches."。 // 打印 "John's building identifier is The Larches."。
``` ```
如果你还想进一步对方法返回值执行可选链，将可选链问号符放在方法括号的后面： 如果你还想进一步对方法返回值执行可选链，将可选链问号符放在方法括号的后面：
```swift ```swift
if let upper = john.residence?.address?.buildingIdentifier()?.uppercaseString { if let upper = john.residence?.address?.buildingIdentifier()?.uppercaseString {
println("John's uppercase building identifier is \(upper).") println("John's uppercase building identifier is \(upper).")
} }
// 打印 "John's uppercase building identifier is THE LARCHES."。 // 打印 "John's uppercase building identifier is THE LARCHES."。
``` ```
> 注意： > 注意：
在上面的例子中，你将可选链问号符放在括号后面是因为你想要链接的可选值是`buildingIdentifier`方法的返回值，不是`buildingIdentifier`方法本身。 在上面的例子中，你将可选链问号符放在括号后面是因为你想要链接的可选值是`buildingIdentifier`方法的返回值，不是`buildingIdentifier`方法本身。

504
source/chapter2/18_Type_Casting.md
View File

@ -1,253 +1,253 @@
> 翻译：[xiehurricane](https://github.com/xiehurricane) > 翻译：[xiehurricane](https://github.com/xiehurricane)
> 校对：[happyming](https://github.com/happyming) > 校对：[happyming](https://github.com/happyming)
# 类型检查（Type Casting） # 类型检查（Type Casting）
----------------- -----------------
本页包含内容： 本页包含内容：
- [定义一个类层次作为例子](#defining_a_class_hierarchy_for_type_casting) - [定义一个类层次作为例子](#defining_a_class_hierarchy_for_type_casting)
- [检查类型](#checking_type) - [检查类型](#checking_type)
- [向下转型（Downcasting）](#downcasting) - [向下转型（Downcasting）](#downcasting)
- [`Any`和`AnyObject`的类型检查](#type_casting_for_any_and_anyobject) - [`Any`和`AnyObject`的类型检查](#type_casting_for_any_and_anyobject)
_类型检查_是一种检查类实例的方式，并且或者也是让实例作为它的父类或者子类的一种方式。 _类型检查_是一种检查类实例的方式，并且或者也是让实例作为它的父类或者子类的一种方式。
类型检查在 Swift 中使用`is` 和 `as`操作符实现。这两个操作符提供了一种简单达意的方式去检查值的类型或者转换它的类型。 类型检查在 Swift 中使用`is` 和 `as`操作符实现。这两个操作符提供了一种简单达意的方式去检查值的类型或者转换它的类型。
你也可以用来检查一个类是否实现了某个协议，就像在 [Checking for Protocol Conformance](Protocols.html#//apple_ref/doc/uid/TP40014097-CH25-XID_363)部分讲述的一样。 你也可以用来检查一个类是否实现了某个协议，就像在 [Checking for Protocol Conformance](Protocols.html#//apple_ref/doc/uid/TP40014097-CH25-XID_363)部分讲述的一样。
<a name="defining_a_class_hierarchy_for_type_casting"></a> <a name="defining_a_class_hierarchy_for_type_casting"></a>
## 定义一个类层次作为例子 ## 定义一个类层次作为例子
你可以将它用在类和子类的层次结构上，检查特定类实例的类型并且转换这个类实例的类型成为这个层次结构中的其他类型。这下面的三个代码段定义了一个类层次和一个包含了几个这些类实例的数组，作为类型检查的例子。 你可以将它用在类和子类的层次结构上，检查特定类实例的类型并且转换这个类实例的类型成为这个层次结构中的其他类型。这下面的三个代码段定义了一个类层次和一个包含了几个这些类实例的数组，作为类型检查的例子。
第一个代码片段定义了一个新的基础类`MediaItem`。这个类为任何出现在数字媒体库的媒体项提供基础功能。特别的，它声明了一个 `String` 类型的 `name` 属性，和一个`init name`初始化器。（它假定所有的媒体项都有个名称。） 第一个代码片段定义了一个新的基础类`MediaItem`。这个类为任何出现在数字媒体库的媒体项提供基础功能。特别的，它声明了一个 `String` 类型的 `name` 属性，和一个`init name`初始化器。（它假定所有的媒体项都有个名称。）
```swift ```swift
class MediaItem { class MediaItem {
var name: String var name: String
init(name: String) { init(name: String) {
self.name = name self.name = name
} }
} }
``` ```
下一个代码段定义了 `MediaItem` 的两个子类。第一个子类`Movie`，在父类（或者说基类）的基础上增加了一个 `director`（导演） 属性，和相应的初始化器。第二个类在父类的基础上增加了一个 `artist`（艺术家） 属性，和相应的初始化器： 下一个代码段定义了 `MediaItem` 的两个子类。第一个子类`Movie`，在父类（或者说基类）的基础上增加了一个 `director`（导演） 属性，和相应的初始化器。第二个类在父类的基础上增加了一个 `artist`（艺术家） 属性，和相应的初始化器：
```swift ```swift
class Movie: MediaItem { class Movie: MediaItem {
var director: String var director: String
init(name: String, director: String) { init(name: String, director: String) {
self.director = director self.director = director
super.init(name: name) super.init(name: name)
} }
} }
class Song: MediaItem { class Song: MediaItem {
var artist: String var artist: String
init(name: String, artist: String) { init(name: String, artist: String) {
self.artist = artist self.artist = artist
super.init(name: name) super.init(name: name)
} }
} }
``` ```
最后一个代码段创建了一个数组常量 `library`，包含两个`Movie`实例和三个`Song`实例。`library`的类型是在它被初始化时根据它数组中所包含的内容推断来的。Swift 的类型检测器能够演绎出`Movie` 和 `Song` 有共同的父类 `MediaItem` ，所以它推断出 `MediaItem[]` 类作为 `library` 的类型。 最后一个代码段创建了一个数组常量 `library`，包含两个`Movie`实例和三个`Song`实例。`library`的类型是在它被初始化时根据它数组中所包含的内容推断来的。Swift 的类型检测器能够演绎出`Movie` 和 `Song` 有共同的父类 `MediaItem` ，所以它推断出 `MediaItem[]` 类作为 `library` 的类型。
```swift ```swift
let library = [ let library = [
Movie(name: "Casablanca", director: "Michael Curtiz"), Movie(name: "Casablanca", director: "Michael Curtiz"),
Song(name: "Blue Suede Shoes", artist: "Elvis Presley"), Song(name: "Blue Suede Shoes", artist: "Elvis Presley"),
Movie(name: "Citizen Kane", director: "Orson Welles"), Movie(name: "Citizen Kane", director: "Orson Welles"),
Song(name: "The One And Only", artist: "Chesney Hawkes"), Song(name: "The One And Only", artist: "Chesney Hawkes"),
Song(name: "Never Gonna Give You Up", artist: "Rick Astley") Song(name: "Never Gonna Give You Up", artist: "Rick Astley")
] ]
// the type of "library" is inferred to be MediaItem[] // the type of "library" is inferred to be MediaItem[]
``` ```
在幕后`library` 里存储的媒体项依然是 `Movie` 和 `Song` 类型的，但是，若你迭代它，取出的实例会是 `MediaItem` 类型的，而不是 `Movie` 和 `Song` 类型的。为了让它们作为它们本来的类型工作，你需要检查它们的类型或者向下转换它们的类型到其它类型，就像下面描述的一样。 在幕后`library` 里存储的媒体项依然是 `Movie` 和 `Song` 类型的，但是，若你迭代它，取出的实例会是 `MediaItem` 类型的，而不是 `Movie` 和 `Song` 类型的。为了让它们作为它们本来的类型工作，你需要检查它们的类型或者向下转换它们的类型到其它类型，就像下面描述的一样。
<a name="checking_type"></a> <a name="checking_type"></a>
## 检查类型（Checking Type） ## 检查类型（Checking Type）
用类型检查操作符(`is`)来检查一个实例是否属于特定子类型。若实例属于那个子类型，类型检查操作符返回 `true` ，否则返回 `false` 。 用类型检查操作符(`is`)来检查一个实例是否属于特定子类型。若实例属于那个子类型，类型检查操作符返回 `true` ，否则返回 `false` 。
下面的例子定义了两个变量，`movieCount` 和 `songCount`，用来计算数组`library` 中 `Movie` 和 `Song` 类型的实例数量。 下面的例子定义了两个变量，`movieCount` 和 `songCount`，用来计算数组`library` 中 `Movie` 和 `Song` 类型的实例数量。
```swift ```swift
var movieCount = 0 var movieCount = 0
var songCount = 0 var songCount = 0
for item in library { for item in library {
if item is Movie { if item is Movie {
++movieCount ++movieCount
} else if item is Song { } else if item is Song {
++songCount ++songCount
} }
} }
println("Media library contains \(movieCount) movies and \(songCount) songs") println("Media library contains \(movieCount) movies and \(songCount) songs")
// prints "Media library contains 2 movies and 3 songs" // prints "Media library contains 2 movies and 3 songs"
``` ```
示例迭代了数组 `library` 中的所有项。每一次， `for`-`in` 循环设置 示例迭代了数组 `library` 中的所有项。每一次， `for`-`in` 循环设置
`item` 为数组中的下一个 `MediaItem`。 `item` 为数组中的下一个 `MediaItem`。
若当前 `MediaItem` 是一个 `Movie` 类型的实例， `item is Movie` 返回 若当前 `MediaItem` 是一个 `Movie` 类型的实例， `item is Movie` 返回
`true`，相反返回 `false`。同样的，`item is `true`，相反返回 `false`。同样的，`item is
Song`检查item是否为`Song`类型的实例。在循环结束后，`movieCount` 和 `songCount`的值就是被找到属于各自的类型的实例数量。 Song`检查item是否为`Song`类型的实例。在循环结束后，`movieCount` 和 `songCount`的值就是被找到属于各自的类型的实例数量。
<a name="downcasting"></a> <a name="downcasting"></a>
## 向下转型（Downcasting） ## 向下转型（Downcasting）
某类型的一个常量或变量可能在幕后实际上属于一个子类。你可以相信，上面就是这种情况。你可以尝试向下转到它的子类型，用类型检查操作符(`as`) 某类型的一个常量或变量可能在幕后实际上属于一个子类。你可以相信，上面就是这种情况。你可以尝试向下转到它的子类型，用类型检查操作符(`as`)
因为向下转型可能会失败，类型转型操作符带有两种不同形式。可选形式（ optional form） `as?` 返回一个你试图下转成的类型的可选值（optional value）。强制形式 `as` 把试图向下转型和强制解包（force-unwraps）结果作为一个混合动作。 因为向下转型可能会失败，类型转型操作符带有两种不同形式。可选形式（ optional form） `as?` 返回一个你试图下转成的类型的可选值（optional value）。强制形式 `as` 把试图向下转型和强制解包（force-unwraps）结果作为一个混合动作。
当你不确定向下转型可以成功时，用类型检查的可选形式(`as?`)。可选形式的类型检查总是返回一个可选值（optional value），并且若下转是不可能的，可选值将是 `nil` 。这使你能够检查向下转型是否成功。 当你不确定向下转型可以成功时，用类型检查的可选形式(`as?`)。可选形式的类型检查总是返回一个可选值（optional value），并且若下转是不可能的，可选值将是 `nil` 。这使你能够检查向下转型是否成功。
只有你可以确定向下转型一定会成功时，才使用强制形式。当你试图向下转型为一个不正确的类型时，强制形式的类型检查会触发一个运行时错误。 只有你可以确定向下转型一定会成功时，才使用强制形式。当你试图向下转型为一个不正确的类型时，强制形式的类型检查会触发一个运行时错误。
下面的例子，迭代了`library`里的每一个 `MediaItem` ，并打印出适当的描述。要这样做，`item`需要真正作为`Movie` 或 `Song`的类型来使用。不仅仅是作为 `MediaItem`。为了能够使用`Movie` 或 `Song`的 `director` 或 `artist`属性，这是必要的。 下面的例子，迭代了`library`里的每一个 `MediaItem` ，并打印出适当的描述。要这样做，`item`需要真正作为`Movie` 或 `Song`的类型来使用。不仅仅是作为 `MediaItem`。为了能够使用`Movie` 或 `Song`的 `director` 或 `artist`属性，这是必要的。
在这个示例中，数组中的每一个`item`可能是 `Movie` 或 `Song`。 事前你不知道每个`item`的真实类型，所以这里使用可选形式的类型检查 （`as?`）去检查循环里的每次下转。 在这个示例中，数组中的每一个`item`可能是 `Movie` 或 `Song`。 事前你不知道每个`item`的真实类型，所以这里使用可选形式的类型检查 （`as?`）去检查循环里的每次下转。
```swift ```swift
for item in library { for item in library {
if let movie = item as? Movie { if let movie = item as? Movie {
println("Movie: '\(movie.name)', dir. \(movie.director)") println("Movie: '\(movie.name)', dir. \(movie.director)")
} else if let song = item as? Song { } else if let song = item as? Song {
println("Song: '\(song.name)', by \(song.artist)") println("Song: '\(song.name)', by \(song.artist)")
} }
} }
// Movie: 'Casablanca', dir. Michael Curtiz // Movie: 'Casablanca', dir. Michael Curtiz
// Song: 'Blue Suede Shoes', by Elvis Presley // Song: 'Blue Suede Shoes', by Elvis Presley
// Movie: 'Citizen Kane', dir. Orson Welles // Movie: 'Citizen Kane', dir. Orson Welles
// Song: 'The One And Only', by Chesney Hawkes // Song: 'The One And Only', by Chesney Hawkes
// Song: 'Never Gonna Give You Up', by Rick Astley // Song: 'Never Gonna Give You Up', by Rick Astley
``` ```
示例首先试图将 `item` 下转为 `Movie`。因为 `item` 是一个 `MediaItem` 示例首先试图将 `item` 下转为 `Movie`。因为 `item` 是一个 `MediaItem`
类型的实例，它可能是一个`Movie`；同样，它可能是一个 `Song`，或者仅仅是基类 类型的实例，它可能是一个`Movie`；同样，它可能是一个 `Song`，或者仅仅是基类
`MediaItem`。因为不确定，`as?`形式在试图下转时将返还一个可选值。 `item as Movie` 的返回值是`Movie?`类型或 “optional `Movie`”。 `MediaItem`。因为不确定，`as?`形式在试图下转时将返还一个可选值。 `item as Movie` 的返回值是`Movie?`类型或 “optional `Movie`”。
当向下转型为 `Movie` 应用在两个 `Song` 当向下转型为 `Movie` 应用在两个 `Song`
实例时将会失败。为了处理这种情况，上面的例子使用了可选绑定（optional binding）来检查可选 `Movie`真的包含一个值（这个是为了判断下转是否成功。）可选绑定是这样写的“`if let movie = item as? Movie`”，可以这样解读： 实例时将会失败。为了处理这种情况，上面的例子使用了可选绑定（optional binding）来检查可选 `Movie`真的包含一个值（这个是为了判断下转是否成功。）可选绑定是这样写的“`if let movie = item as? Movie`”，可以这样解读：
“尝试将 `item` 转为 `Movie`类型。若成功，设置一个新的临时常量 `movie` 来存储返回的可选`Movie`” “尝试将 `item` 转为 `Movie`类型。若成功，设置一个新的临时常量 `movie` 来存储返回的可选`Movie`”
若向下转型成功，然后`movie`的属性将用于打印一个`Movie`实例的描述，包括它的导演的名字`director`。当`Song`被找到时，一个相近的原理被用来检测 `Song` 实例和打印它的描述。 若向下转型成功，然后`movie`的属性将用于打印一个`Movie`实例的描述，包括它的导演的名字`director`。当`Song`被找到时，一个相近的原理被用来检测 `Song` 实例和打印它的描述。
> 注意： > 注意：
转换没有真的改变实例或它的值。潜在的根本的实例保持不变；只是简单地把它作为它被转换成的类来使用。 转换没有真的改变实例或它的值。潜在的根本的实例保持不变；只是简单地把它作为它被转换成的类来使用。
<a name="type_casting_for_any_and_anyobject"></a> <a name="type_casting_for_any_and_anyobject"></a>
## `Any`和`AnyObject`的类型检查 ## `Any`和`AnyObject`的类型检查
Swift为不确定类型提供了两种特殊类型别名： Swift为不确定类型提供了两种特殊类型别名：
* `AnyObject`可以代表任何class类型的实例。 * `AnyObject`可以代表任何class类型的实例。
* `Any`可以表示任何类型，除了方法类型（function types）。 * `Any`可以表示任何类型，除了方法类型（function types）。
> 注意： > 注意：
只有当你明确的需要它的行为和功能时才使用`Any`和`AnyObject`。在你的代码里使用你期望的明确的类型总是更好的。 只有当你明确的需要它的行为和功能时才使用`Any`和`AnyObject`。在你的代码里使用你期望的明确的类型总是更好的。
### `AnyObject`类型 ### `AnyObject`类型
当需要在工作中使用 Cocoa 当需要在工作中使用 Cocoa
APIs，它一般接收一个`AnyObject[]`类型的数组，或者说“一个任何对象类型的数组”。这是因为 Objective-C 没有明确的类型化数组。但是，你常常可以确定包含在仅从你知道的 API 信息提供的这样一个数组中的对象的类型。 APIs，它一般接收一个`AnyObject[]`类型的数组，或者说“一个任何对象类型的数组”。这是因为 Objective-C 没有明确的类型化数组。但是，你常常可以确定包含在仅从你知道的 API 信息提供的这样一个数组中的对象的类型。
在这些情况下，你可以使用强制形式的类型检查(`as`)来下转在数组中的每一项到比 `AnyObject` 更明确的类型，不需要可选解析（optional unwrapping）。 在这些情况下，你可以使用强制形式的类型检查(`as`)来下转在数组中的每一项到比 `AnyObject` 更明确的类型，不需要可选解析（optional unwrapping）。
下面的示例定义了一个 `AnyObject[]` 类型的数组并填入三个`Movie`类型的实例： 下面的示例定义了一个 `AnyObject[]` 类型的数组并填入三个`Movie`类型的实例：
```swift ```swift
let someObjects: AnyObject[] = [ let someObjects: AnyObject[] = [
Movie(name: "2001: A Space Odyssey", director: "Stanley Kubrick"), Movie(name: "2001: A Space Odyssey", director: "Stanley Kubrick"),
Movie(name: "Moon", director: "Duncan Jones"), Movie(name: "Moon", director: "Duncan Jones"),
Movie(name: "Alien", director: "Ridley Scott") Movie(name: "Alien", director: "Ridley Scott")
] ]
``` ```
因为知道这个数组只包含 `Movie` 实例，你可以直接用(`as`)下转并解包到不可选的`Movie`类型（ps：其实就是我们常用的正常类型，这里是为了和可选类型相对比）。 因为知道这个数组只包含 `Movie` 实例，你可以直接用(`as`)下转并解包到不可选的`Movie`类型（ps：其实就是我们常用的正常类型，这里是为了和可选类型相对比）。
```swift ```swift
for object in someObjects { for object in someObjects {
let movie = object as Movie let movie = object as Movie
println("Movie: '\(movie.name)', dir. \(movie.director)") println("Movie: '\(movie.name)', dir. \(movie.director)")
} }
// Movie: '2001: A Space Odyssey', dir. Stanley Kubrick // Movie: '2001: A Space Odyssey', dir. Stanley Kubrick
// Movie: 'Moon', dir. Duncan Jones // Movie: 'Moon', dir. Duncan Jones
// Movie: 'Alien', dir. Ridley Scott // Movie: 'Alien', dir. Ridley Scott
``` ```
为了变为一个更短的形式，下转`someObjects`数组为`Movie[]`类型来代替下转每一项方式。 为了变为一个更短的形式，下转`someObjects`数组为`Movie[]`类型来代替下转每一项方式。
```swift ```swift
for movie in someObjects as Movie[] { for movie in someObjects as Movie[] {
println("Movie: '\(movie.name)', dir. \(movie.director)") println("Movie: '\(movie.name)', dir. \(movie.director)")
} }
// Movie: '2001: A Space Odyssey', dir. Stanley Kubrick // Movie: '2001: A Space Odyssey', dir. Stanley Kubrick
// Movie: 'Moon', dir. Duncan Jones // Movie: 'Moon', dir. Duncan Jones
// Movie: 'Alien', dir. Ridley Scott // Movie: 'Alien', dir. Ridley Scott
``` ```
### `Any`类型 ### `Any`类型
这里有个示例，使用 `Any` 类型来和混合的不同类型一起工作，包括非`class`类型。它创建了一个可以存储`Any`类型的数组 `things`。 这里有个示例，使用 `Any` 类型来和混合的不同类型一起工作，包括非`class`类型。它创建了一个可以存储`Any`类型的数组 `things`。
```swift ```swift
var things = Any[]() var things = Any[]()
things.append(0) things.append(0)
things.append(0.0) things.append(0.0)
things.append(42) things.append(42)
things.append(3.14159) things.append(3.14159)
things.append("hello") things.append("hello")
things.append((3.0, 5.0)) things.append((3.0, 5.0))
things.append(Movie(name: "Ghostbusters", director: "Ivan Reitman")) things.append(Movie(name: "Ghostbusters", director: "Ivan Reitman"))
``` ```
`things` 数组包含两个 `Int` 值，2个 `Double` 值，1个 `String` 值，一个元组 `(Double, Double)` ，Ivan Reitman 导演的电影“Ghostbusters”。 `things` 数组包含两个 `Int` 值，2个 `Double` 值，1个 `String` 值，一个元组 `(Double, Double)` ，Ivan Reitman 导演的电影“Ghostbusters”。
你可以在 `switch` `cases`里用`is` 和 `as` 操作符来发觉只知道是 `Any` 或 `AnyObject`的常量或变量的类型。 下面的示例迭代 `things`数组中的每一项的并用`switch`语句查找每一项的类型。这几种`switch`语句的情形绑定它们匹配的值到一个规定类型的常量，让它们可以打印它们的值： 你可以在 `switch` `cases`里用`is` 和 `as` 操作符来发觉只知道是 `Any` 或 `AnyObject`的常量或变量的类型。 下面的示例迭代 `things`数组中的每一项的并用`switch`语句查找每一项的类型。这几种`switch`语句的情形绑定它们匹配的值到一个规定类型的常量，让它们可以打印它们的值：
```swift ```swift
for thing in things { for thing in things {
switch thing { switch thing {
case 0 as Int: case 0 as Int:
println("zero as an Int") println("zero as an Int")
case 0 as Double: case 0 as Double:
println("zero as a Double") println("zero as a Double")
case let someInt as Int: case let someInt as Int:
println("an integer value of \(someInt)") println("an integer value of \(someInt)")
case let someDouble as Double where someDouble > 0: case let someDouble as Double where someDouble > 0:
println("a positive double value of \(someDouble)") println("a positive double value of \(someDouble)")
case is Double: case is Double:
println("some other double value that I don't want to print") println("some other double value that I don't want to print")
case let someString as String: case let someString as String:
println("a string value of \"\(someString)\"") println("a string value of \"\(someString)\"")
case let (x, y) as (Double, Double): case let (x, y) as (Double, Double):
println("an (x, y) point at \(x), \(y)") println("an (x, y) point at \(x), \(y)")
case let movie as Movie: case let movie as Movie:
println("a movie called '\(movie.name)', dir. \(movie.director)") println("a movie called '\(movie.name)', dir. \(movie.director)")
default: default:
println("something else") println("something else")
} }
} }
// zero as an Int // zero as an Int
// zero as a Double // zero as a Double
// an integer value of 42 // an integer value of 42
// a positive double value of 3.14159 // a positive double value of 3.14159
// a string value of "hello" // a string value of "hello"
// an (x, y) point at 3.0, 5.0 // an (x, y) point at 3.0, 5.0
// a movie called 'Ghostbusters', dir. Ivan Reitman // a movie called 'Ghostbusters', dir. Ivan Reitman
``` ```
> 注意： > 注意：
在一个switch语句的case中使用强制形式的类型检查操作符（as, 而不是 as?）来检查和转换到一个明确的类型。在 switch case 语句的内容中这种检查总是安全的。 在一个switch语句的case中使用强制形式的类型检查操作符（as, 而不是 as?）来检查和转换到一个明确的类型。在 switch case 语句的内容中这种检查总是安全的。

192
source/chapter2/19_Nested_Types.md
View File

@ -1,97 +1,97 @@
> 翻译：[Lin-H](https://github.com/Lin-H) > 翻译：[Lin-H](https://github.com/Lin-H)
> 校对：[shinyzhu](https://github.com/shinyzhu) > 校对：[shinyzhu](https://github.com/shinyzhu)
# 类型嵌套 # 类型嵌套
----------------- -----------------
本页包含内容： 本页包含内容：
- [类型嵌套实例](#nested_types_in_action) - [类型嵌套实例](#nested_types_in_action)
- [类型嵌套的引用](#referring_to_nested_types) - [类型嵌套的引用](#referring_to_nested_types)
枚举类型常被用于实现特定类或结构体的功能。也能够在有多种变量类型的环境中，方便地定义通用类或结构体来使用，为了实现这种功能，Swift允许你定义类型嵌套，可以在枚举类型、类和结构体中定义支持嵌套的类型。 枚举类型常被用于实现特定类或结构体的功能。也能够在有多种变量类型的环境中，方便地定义通用类或结构体来使用，为了实现这种功能，Swift允许你定义类型嵌套，可以在枚举类型、类和结构体中定义支持嵌套的类型。
要在一个类型中嵌套另一个类型，将需要嵌套的类型的定义写在被嵌套类型的区域{}内，而且可以根据需要定义多级嵌套。 要在一个类型中嵌套另一个类型，将需要嵌套的类型的定义写在被嵌套类型的区域{}内，而且可以根据需要定义多级嵌套。
<a name="nested_types_in_action"></a> <a name="nested_types_in_action"></a>
##类型嵌套实例 ##类型嵌套实例
下面这个例子定义了一个结构体`BlackjackCard`(二十一点)，用来模拟`BlackjackCard`中的扑克牌点数。`BlackjackCard`结构体包含2个嵌套定义的枚举类型`Suit` 和 `Rank`。 下面这个例子定义了一个结构体`BlackjackCard`(二十一点)，用来模拟`BlackjackCard`中的扑克牌点数。`BlackjackCard`结构体包含2个嵌套定义的枚举类型`Suit` 和 `Rank`。
在`BlackjackCard`规则中，`Ace`牌可以表示1或者11，`Ace`牌的这一特征用一个嵌套在枚举型`Rank`的结构体`Values`来表示。 在`BlackjackCard`规则中，`Ace`牌可以表示1或者11，`Ace`牌的这一特征用一个嵌套在枚举型`Rank`的结构体`Values`来表示。
```swift ```swift
struct BlackjackCard { struct BlackjackCard {
// 嵌套定义枚举型Suit // 嵌套定义枚举型Suit
enum Suit: Character { enum Suit: Character {
case Spades = "♠", Hearts = "♡", Diamonds = "♢", Clubs = "♣" case Spades = "♠", Hearts = "♡", Diamonds = "♢", Clubs = "♣"
} }
// 嵌套定义枚举型Rank // 嵌套定义枚举型Rank
enum Rank: Int { enum Rank: Int {
case Two = 2, Three, Four, Five, Six, Seven, Eight, Nine, Ten case Two = 2, Three, Four, Five, Six, Seven, Eight, Nine, Ten
case Jack, Queen, King, Ace case Jack, Queen, King, Ace
struct Values { struct Values {
let first: Int, second: Int? let first: Int, second: Int?
} }
var values: Values { var values: Values {
switch self { switch self {
case .Ace: case .Ace:
return Values(first: 1, second: 11) return Values(first: 1, second: 11)
case .Jack, .Queen, .King: case .Jack, .Queen, .King:
return Values(first: 10, second: nil) return Values(first: 10, second: nil)
default: default:
return Values(first: self.toRaw(), second: nil) return Values(first: self.toRaw(), second: nil)
} }
} }
} }
// BlackjackCard 的属性和方法 // BlackjackCard 的属性和方法
let rank: Rank, suit: Suit let rank: Rank, suit: Suit
var description: String { var description: String {
var output = "suit is \(suit.toRaw())," var output = "suit is \(suit.toRaw()),"
output += " value is \(rank.values.first)" output += " value is \(rank.values.first)"
if let second = rank.values.second { if let second = rank.values.second {
output += " or \(second)" output += " or \(second)"
} }
return output return output
} }
} }
``` ```
枚举型的`Suit`用来描述扑克牌的四种花色，并分别用一个`Character`类型的值代表花色符号。 枚举型的`Suit`用来描述扑克牌的四种花色，并分别用一个`Character`类型的值代表花色符号。
枚举型的`Rank`用来描述扑克牌从`Ace`~10,`J`,`Q`,`K`,13张牌，并分别用一个`Int`类型的值表示牌的面值。(这个`Int`类型的值不适用于`Ace`,`J`,`Q`,`K`的牌)。 枚举型的`Rank`用来描述扑克牌从`Ace`~10,`J`,`Q`,`K`,13张牌，并分别用一个`Int`类型的值表示牌的面值。(这个`Int`类型的值不适用于`Ace`,`J`,`Q`,`K`的牌)。
如上文所提到的，枚举型`Rank`在自己内部定义了一个嵌套结构体`Values`。这个结构体包含两个变量，只有`Ace`有两个数值，其余牌都只有一个数值。结构体`Values`中定义的两个属性： 如上文所提到的，枚举型`Rank`在自己内部定义了一个嵌套结构体`Values`。这个结构体包含两个变量，只有`Ace`有两个数值，其余牌都只有一个数值。结构体`Values`中定义的两个属性：
`first`, 为` Int` `first`, 为` Int`
`second`, 为 `Int?`, 或 “optional `Int`” `second`, 为 `Int?`, 或 “optional `Int`”
`Rank`定义了一个计算属性`values`，这个计算属性会根据牌的面值，用适当的数值去初始化`Values`实例，并赋值给`values`。对于`J`,`Q`,`K`,`Ace`会使用特殊数值，对于数字面值的牌使用`Int`类型的值。 `Rank`定义了一个计算属性`values`，这个计算属性会根据牌的面值，用适当的数值去初始化`Values`实例，并赋值给`values`。对于`J`,`Q`,`K`,`Ace`会使用特殊数值，对于数字面值的牌使用`Int`类型的值。
`BlackjackCard`结构体自身有两个属性—`rank`与`suit`，也同样定义了一个计算属性`description`，`description`属性用`rank`和`suit`的中内容来构建对这张扑克牌名字和数值的描述，并用可选类型`second`来检查是否存在第二个值，若存在，则在原有的描述中增加对第二数值的描述。 `BlackjackCard`结构体自身有两个属性—`rank`与`suit`，也同样定义了一个计算属性`description`，`description`属性用`rank`和`suit`的中内容来构建对这张扑克牌名字和数值的描述，并用可选类型`second`来检查是否存在第二个值，若存在，则在原有的描述中增加对第二数值的描述。
因为`BlackjackCard`是一个没有自定义构造函数的结构体，在[Memberwise Initializers for Structure Types](https://github.com/CocoaChina-editors/Welcome-to-Swift/blob/master/The%20Swift%20Programming%20Language/02Language%20Guide/14Initialization.md)中知道结构体有默认的成员构造函数，所以你可以用默认的`initializer`去初始化新的常量`theAceOfSpades`: 因为`BlackjackCard`是一个没有自定义构造函数的结构体，在[Memberwise Initializers for Structure Types](https://github.com/CocoaChina-editors/Welcome-to-Swift/blob/master/The%20Swift%20Programming%20Language/02Language%20Guide/14Initialization.md)中知道结构体有默认的成员构造函数，所以你可以用默认的`initializer`去初始化新的常量`theAceOfSpades`:
```swift ```swift
let theAceOfSpades = BlackjackCard(rank: .Ace, suit: .Spades) let theAceOfSpades = BlackjackCard(rank: .Ace, suit: .Spades)
println("theAceOfSpades: \(theAceOfSpades.description)") println("theAceOfSpades: \(theAceOfSpades.description)")
// 打印出 "theAceOfSpades: suit is ♠, value is 1 or 11" // 打印出 "theAceOfSpades: suit is ♠, value is 1 or 11"
``` ```
尽管`Rank`和`Suit`嵌套在`BlackjackCard`中，但仍可被引用，所以在初始化实例时能够通过枚举类型中的成员名称单独引用。在上面的例子中`description`属性能正确得输出对`Ace`牌有1和11两个值。 尽管`Rank`和`Suit`嵌套在`BlackjackCard`中，但仍可被引用，所以在初始化实例时能够通过枚举类型中的成员名称单独引用。在上面的例子中`description`属性能正确得输出对`Ace`牌有1和11两个值。
<a name="referring_to_nested_types"></a> <a name="referring_to_nested_types"></a>
##类型嵌套的引用 ##类型嵌套的引用
在外部对嵌套类型的引用，以被嵌套类型的名字为前缀，加上所要引用的属性名： 在外部对嵌套类型的引用，以被嵌套类型的名字为前缀，加上所要引用的属性名：
```swift ```swift
let heartsSymbol = BlackjackCard.Suit.Hearts.toRaw() let heartsSymbol = BlackjackCard.Suit.Hearts.toRaw()
// 红心的符号 为 "♡" // 红心的符号 为 "♡"
``` ```
对于上面这个例子，这样可以使`Suit`, `Rank`, 和 `Values`的名字尽可能的短，因为它们的名字会自然的由被定义的上下文来限定。 对于上面这个例子，这样可以使`Suit`, `Rank`, 和 `Values`的名字尽可能的短，因为它们的名字会自然的由被定义的上下文来限定。
preview preview

596
source/chapter2/20_Extensions.md
View File

@ -1,298 +1,298 @@
> 翻译：[lyuka](https://github.com/lyuka) > 翻译：[lyuka](https://github.com/lyuka)
> 校对：[Hawstein](https://github.com/Hawstein) > 校对：[Hawstein](https://github.com/Hawstein)
#扩展（Extensions） #扩展（Extensions）
---- ----
本页包含内容： 本页包含内容：
- [扩展语法](#extension_syntax) - [扩展语法](#extension_syntax)
- [计算型属性](#computed_properties) - [计算型属性](#computed_properties)
- [构造器](#initializers) - [构造器](#initializers)
- [方法](#methods) - [方法](#methods)
- [下标](#subscripts) - [下标](#subscripts)
- [嵌套类型](#nested_types) - [嵌套类型](#nested_types)
*扩展*就是向一个已有的类、结构体或枚举类型添加新功能（functionality）。这包括在没有权限获取原始源代码的情况下扩展类型的能力（即*逆向建模*）。扩展和 Objective-C 中的分类（categories）类似。（不过与Objective-C不同的是，Swift 的扩展没有名字。） *扩展*就是向一个已有的类、结构体或枚举类型添加新功能（functionality）。这包括在没有权限获取原始源代码的情况下扩展类型的能力（即*逆向建模*）。扩展和 Objective-C 中的分类（categories）类似。（不过与Objective-C不同的是，Swift 的扩展没有名字。）
Swift 中的扩展可以： Swift 中的扩展可以：
- 添加计算型属性和计算静态属性 - 添加计算型属性和计算静态属性
- 定义实例方法和类型方法 - 定义实例方法和类型方法
- 提供新的构造器 - 提供新的构造器
- 定义下标 - 定义下标
- 定义和使用新的嵌套类型 - 定义和使用新的嵌套类型
- 使一个已有类型符合某个协议 - 使一个已有类型符合某个协议
>注意： >注意：
如果你定义了一个扩展向一个已有类型添加新功能，那么这个新功能对该类型的所有已有实例中都是可用的，即使它们是在你的这个扩展的前面定义的。 如果你定义了一个扩展向一个已有类型添加新功能，那么这个新功能对该类型的所有已有实例中都是可用的，即使它们是在你的这个扩展的前面定义的。
<a name="extension_syntax"></a> <a name="extension_syntax"></a>
## 扩展语法（Extension Syntax） ## 扩展语法（Extension Syntax）
声明一个扩展使用关键字`extension`： 声明一个扩展使用关键字`extension`：
```swift ```swift
extension SomeType { extension SomeType {
// 加到SomeType的新功能写到这里 // 加到SomeType的新功能写到这里
} }
``` ```
一个扩展可以扩展一个已有类型，使其能够适配一个或多个协议（protocol）。当这种情况发生时，协议的名字应该完全按照类或结构体的名字的方式进行书写： 一个扩展可以扩展一个已有类型，使其能够适配一个或多个协议（protocol）。当这种情况发生时，协议的名字应该完全按照类或结构体的名字的方式进行书写：
```swift ```swift
extension SomeType: SomeProtocol, AnotherProctocol { extension SomeType: SomeProtocol, AnotherProctocol {
// 协议实现写到这里 // 协议实现写到这里
} }
``` ```
按照这种方式添加的协议遵循者（protocol conformance）被称之为[在扩展中添加协议遵循者](21_Protocols.html#adding_protocol_conformance_with_an_extension) 按照这种方式添加的协议遵循者（protocol conformance）被称之为[在扩展中添加协议遵循者](21_Protocols.html#adding_protocol_conformance_with_an_extension)
<a name="computed_properties"></a> <a name="computed_properties"></a>
## 计算型属性（Computed Properties） ## 计算型属性（Computed Properties）
扩展可以向已有类型添加计算型实例属性和计算型类型属性。下面的例子向 Swift 的内建`Double`类型添加了5个计算型实例属性，从而提供与距离单位协作的基本支持。 扩展可以向已有类型添加计算型实例属性和计算型类型属性。下面的例子向 Swift 的内建`Double`类型添加了5个计算型实例属性，从而提供与距离单位协作的基本支持。
```swift ```swift
extension Double { extension Double {
var km: Double { return self * 1_000.0 } var km: Double { return self * 1_000.0 }
var m : Double { return self } var m : Double { return self }
var cm: Double { return self / 100.0 } var cm: Double { return self / 100.0 }
var mm: Double { return self / 1_000.0 } var mm: Double { return self / 1_000.0 }
var ft: Double { return self / 3.28084 } var ft: Double { return self / 3.28084 }
} }
let oneInch = 25.4.mm let oneInch = 25.4.mm
println("One inch is \(oneInch) meters") println("One inch is \(oneInch) meters")
// 打印输出："One inch is 0.0254 meters" // 打印输出："One inch is 0.0254 meters"
let threeFeet = 3.ft let threeFeet = 3.ft
println("Three feet is \(threeFeet) meters") println("Three feet is \(threeFeet) meters")
// 打印输出："Three feet is 0.914399970739201 meters" // 打印输出："Three feet is 0.914399970739201 meters"
``` ```
这些计算属性表达的含义是把一个`Double`型的值看作是某单位下的长度值。即使它们被实现为计算型属性，但这些属性仍可以接一个带有dot语法的浮点型字面值，而这恰恰是使用这些浮点型字面量实现距离转换的方式。 这些计算属性表达的含义是把一个`Double`型的值看作是某单位下的长度值。即使它们被实现为计算型属性，但这些属性仍可以接一个带有dot语法的浮点型字面值，而这恰恰是使用这些浮点型字面量实现距离转换的方式。
在上述例子中，一个`Double`型的值`1.0`被用来表示“1米”。这就是为什么`m`计算型属性返回`self`——表达式`1.m`被认为是计算`1.0`的`Double`值。 在上述例子中，一个`Double`型的值`1.0`被用来表示“1米”。这就是为什么`m`计算型属性返回`self`——表达式`1.m`被认为是计算`1.0`的`Double`值。
其它单位则需要一些转换来表示在米下测量的值。1千米等于1,000米，所以`km`计算型属性要把值乘以`1_000.00`来转化成单位米下的数值。类似地，1米有3.28024英尺，所以`ft`计算型属性要把对应的`Double`值除以`3.28024`来实现英尺到米的单位换算。 其它单位则需要一些转换来表示在米下测量的值。1千米等于1,000米，所以`km`计算型属性要把值乘以`1_000.00`来转化成单位米下的数值。类似地，1米有3.28024英尺，所以`ft`计算型属性要把对应的`Double`值除以`3.28024`来实现英尺到米的单位换算。
这些属性是只读的计算型属性，所有从简考虑它们不用`get`关键字表示。它们的返回值是`Double`型，而且可以用于所有接受`Double`的数学计算中： 这些属性是只读的计算型属性，所有从简考虑它们不用`get`关键字表示。它们的返回值是`Double`型，而且可以用于所有接受`Double`的数学计算中：
```swift ```swift
let aMarathon = 42.km + 195.m let aMarathon = 42.km + 195.m
println("A marathon is \(aMarathon) meters long") println("A marathon is \(aMarathon) meters long")
// 打印输出："A marathon is 42495.0 meters long" // 打印输出："A marathon is 42495.0 meters long"
``` ```
>注意： >注意：
扩展可以添加新的计算属性，但是不可以添加存储属性，也不可以向已有属性添加属性观测器(property observers)。 扩展可以添加新的计算属性，但是不可以添加存储属性，也不可以向已有属性添加属性观测器(property observers)。
<a name="initializers"></a> <a name="initializers"></a>
## 构造器（Initializers） ## 构造器（Initializers）
扩展可以向已有类型添加新的构造器。这可以让你扩展其它类型，将你自己的定制类型作为构造器参数，或者提供该类型的原始实现中没有包含的额外初始化选项。 扩展可以向已有类型添加新的构造器。这可以让你扩展其它类型，将你自己的定制类型作为构造器参数，或者提供该类型的原始实现中没有包含的额外初始化选项。
扩展能向类中添加新的便利构造器，但是它们不能向类中添加新的指定构造器或析构函数。指定构造器和析构函数必须总是由原始的类实现来提供。 扩展能向类中添加新的便利构造器，但是它们不能向类中添加新的指定构造器或析构函数。指定构造器和析构函数必须总是由原始的类实现来提供。
> 注意： > 注意：
如果你使用扩展向一个值类型添加一个构造器，该构造器向所有的存储属性提供默认值，而且没有定义任何定制构造器（custom initializers），那么对于来自你的扩展构造器中的值类型，你可以调用默认构造器(default initializers)和逐一成员构造器(memberwise initializers)。 如果你使用扩展向一个值类型添加一个构造器，该构造器向所有的存储属性提供默认值，而且没有定义任何定制构造器（custom initializers），那么对于来自你的扩展构造器中的值类型，你可以调用默认构造器(default initializers)和逐一成员构造器(memberwise initializers)。
正如在值类型的构造器授权中描述的，如果你已经把构造器写成值类型原始实现的一部分，上述规则不再适用。 正如在值类型的构造器授权中描述的，如果你已经把构造器写成值类型原始实现的一部分，上述规则不再适用。
下面的例子定义了一个用于描述几何矩形的定制结构体`Rect`。这个例子同时定义了两个辅助结构体`Size`和`Point`，它们都把`0.0`作为所有属性的默认值： 下面的例子定义了一个用于描述几何矩形的定制结构体`Rect`。这个例子同时定义了两个辅助结构体`Size`和`Point`，它们都把`0.0`作为所有属性的默认值：
```swift ```swift
struct Size { struct Size {
var width = 0.0, height = 0.0 var width = 0.0, height = 0.0
} }
struct Point { struct Point {
var x = 0.0, y = 0.0 var x = 0.0, y = 0.0
} }
struct Rect { struct Rect {
var origin = Point() var origin = Point()
var size = Size() var size = Size()
} }
``` ```
因为结构体`Rect`提供了其所有属性的默认值，所以正如默认构造器中描述的，它可以自动接受一个默认的构造器和一个成员级构造器。这些构造器可以用于构造新的`Rect`实例： 因为结构体`Rect`提供了其所有属性的默认值，所以正如默认构造器中描述的，它可以自动接受一个默认的构造器和一个成员级构造器。这些构造器可以用于构造新的`Rect`实例：
```swift ```swift
let defaultRect = Rect() let defaultRect = Rect()
let memberwiseRect = Rect(origin: Point(x: 2.0, y: 2.0), let memberwiseRect = Rect(origin: Point(x: 2.0, y: 2.0),
size: Size(width: 5.0, height: 5.0)) size: Size(width: 5.0, height: 5.0))
``` ```
你可以提供一个额外的使用特殊中心点和大小的构造器来扩展`Rect`结构体： 你可以提供一个额外的使用特殊中心点和大小的构造器来扩展`Rect`结构体：
```swift ```swift
extension Rect { extension Rect {
init(center: Point, size: Size) { init(center: Point, size: Size) {
let originX = center.x - (size.width / 2) let originX = center.x - (size.width / 2)
let originY = center.y - (size.height / 2) let originY = center.y - (size.height / 2)
self.init(origin: Point(x: originX, y: originY), size: size) self.init(origin: Point(x: originX, y: originY), size: size)
} }
} }
``` ```
这个新的构造器首先根据提供的`center`和`size`值计算一个合适的原点。然后调用该结构体自动的成员构造器`init(origin:size:)`，该构造器将新的原点和大小存到了合适的属性中： 这个新的构造器首先根据提供的`center`和`size`值计算一个合适的原点。然后调用该结构体自动的成员构造器`init(origin:size:)`，该构造器将新的原点和大小存到了合适的属性中：
```swift ```swift
let centerRect = Rect(center: Point(x: 4.0, y: 4.0), let centerRect = Rect(center: Point(x: 4.0, y: 4.0),
size: Size(width: 3.0, height: 3.0)) size: Size(width: 3.0, height: 3.0))
// centerRect的原点是 (2.5, 2.5)，大小是 (3.0, 3.0) // centerRect的原点是 (2.5, 2.5)，大小是 (3.0, 3.0)
``` ```
>注意： >注意：
如果你使用扩展提供了一个新的构造器，你依旧有责任保证构造过程能够让所有实例完全初始化。 如果你使用扩展提供了一个新的构造器，你依旧有责任保证构造过程能够让所有实例完全初始化。
<a name="methods"></a> <a name="methods"></a>
## 方法（Methods） ## 方法（Methods）
扩展可以向已有类型添加新的实例方法和类型方法。下面的例子向`Int`类型添加一个名为`repetitions`的新实例方法： 扩展可以向已有类型添加新的实例方法和类型方法。下面的例子向`Int`类型添加一个名为`repetitions`的新实例方法：
```swift ```swift
extension Int { extension Int {
func repetitions(task: () -> ()) { func repetitions(task: () -> ()) {
for i in 0..self { for i in 0..self {
task() task()
} }
} }
} }
``` ```
这个`repetitions`方法使用了一个`() -> ()`类型的单参数（single argument），表明函数没有参数而且没有返回值。 这个`repetitions`方法使用了一个`() -> ()`类型的单参数（single argument），表明函数没有参数而且没有返回值。
定义该扩展之后，你就可以对任意整数调用`repetitions`方法,实现的功能则是多次执行某任务： 定义该扩展之后，你就可以对任意整数调用`repetitions`方法,实现的功能则是多次执行某任务：
```swift ```swift
3.repetitions({ 3.repetitions({
println("Hello!") println("Hello!")
}) })
// Hello! // Hello!
// Hello! // Hello!
// Hello! // Hello!
``` ```
可以使用 trailing 闭包使调用更加简洁： 可以使用 trailing 闭包使调用更加简洁：
```swift ```swift
3.repetitions{ 3.repetitions{
println("Goodbye!") println("Goodbye!")
} }
// Goodbye! // Goodbye!
// Goodbye! // Goodbye!
// Goodbye! // Goodbye!
``` ```
<a name="mutating_instance_methods"></a> <a name="mutating_instance_methods"></a>
### 修改实例方法（Mutating Instance Methods） ### 修改实例方法（Mutating Instance Methods）
通过扩展添加的实例方法也可以修改该实例本身。结构体和枚举类型中修改`self`或其属性的方法必须将该实例方法标注为`mutating`，正如来自原始实现的修改方法一样。 通过扩展添加的实例方法也可以修改该实例本身。结构体和枚举类型中修改`self`或其属性的方法必须将该实例方法标注为`mutating`，正如来自原始实现的修改方法一样。
下面的例子向Swift的`Int`类型添加了一个新的名为`square`的修改方法，来实现一个原始值的平方计算： 下面的例子向Swift的`Int`类型添加了一个新的名为`square`的修改方法，来实现一个原始值的平方计算：
```swift ```swift
extension Int { extension Int {
mutating func square() { mutating func square() {
self = self * self self = self * self
} }
} }
var someInt = 3 var someInt = 3
someInt.square() someInt.square()
// someInt 现在值是 9 // someInt 现在值是 9
``` ```
<a name="subscripts"></a> <a name="subscripts"></a>
## 下标（Subscripts） ## 下标（Subscripts）
扩展可以向一个已有类型添加新下标。这个例子向Swift内建类型`Int`添加了一个整型下标。该下标`[n]`返回十进制数字从右向左数的第n个数字 扩展可以向一个已有类型添加新下标。这个例子向Swift内建类型`Int`添加了一个整型下标。该下标`[n]`返回十进制数字从右向左数的第n个数字
- 123456789[0]返回9 - 123456789[0]返回9
- 123456789[1]返回8 - 123456789[1]返回8
...等等 ...等等
```swift ```swift
extension Int { extension Int {
subscript(digitIndex: Int) -> Int { subscript(digitIndex: Int) -> Int {
var decimalBase = 1 var decimalBase = 1
for _ in 1...digitIndex { for _ in 1...digitIndex {
decimalBase *= 10 decimalBase *= 10
} }
return (self / decimalBase) % 10 return (self / decimalBase) % 10
} }
} }
746381295[0] 746381295[0]
// returns 5 // returns 5
746381295[1] 746381295[1]
// returns 9 // returns 9
746381295[2] 746381295[2]
// returns 2 // returns 2
746381295[8] 746381295[8]
// returns 7 // returns 7
``` ```
如果该`Int`值没有足够的位数，即下标越界，那么上述实现的下标会返回0，因为它会在数字左边自动补0： 如果该`Int`值没有足够的位数，即下标越界，那么上述实现的下标会返回0，因为它会在数字左边自动补0：
```swift ```swift
746381295[9] 746381295[9]
//returns 0, 即等同于： //returns 0, 即等同于：
0746381295[9] 0746381295[9]
``` ```
<a name="nested_types"></a> <a name="nested_types"></a>
## 嵌套类型（Nested Types） ## 嵌套类型（Nested Types）
扩展可以向已有的类、结构体和枚举添加新的嵌套类型： 扩展可以向已有的类、结构体和枚举添加新的嵌套类型：
```swift ```swift
extension Character { extension Character {
enum Kind { enum Kind {
case Vowel, Consonant, Other case Vowel, Consonant, Other
} }
var kind: Kind { var kind: Kind {
switch String(self).lowercaseString { switch String(self).lowercaseString {
case "a", "e", "i", "o", "u": case "a", "e", "i", "o", "u":
return .Vowel return .Vowel
case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m", case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
"n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z": "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
return .Consonant return .Consonant
default: default:
return .Other return .Other
} }
} }
} }
``` ```
该例子向`Character`添加了新的嵌套枚举。这个名为`Kind`的枚举表示特定字符的类型。具体来说，就是表示一个标准的拉丁脚本中的字符是元音还是辅音（不考虑口语和地方变种），或者是其它类型。 该例子向`Character`添加了新的嵌套枚举。这个名为`Kind`的枚举表示特定字符的类型。具体来说，就是表示一个标准的拉丁脚本中的字符是元音还是辅音（不考虑口语和地方变种），或者是其它类型。
这个类子还向`Character`添加了一个新的计算实例属性，即`kind`，用来返回合适的`Kind`枚举成员。 这个类子还向`Character`添加了一个新的计算实例属性，即`kind`，用来返回合适的`Kind`枚举成员。
现在，这个嵌套枚举可以和一个`Character`值联合使用了： 现在，这个嵌套枚举可以和一个`Character`值联合使用了：
```swift ```swift
func printLetterKinds(word: String) { func printLetterKinds(word: String) {
println("'\\(word)' is made up of the following kinds of letters:") println("'\\(word)' is made up of the following kinds of letters:")
for character in word { for character in word {
switch character.kind { switch character.kind {
case .Vowel: case .Vowel:
print("vowel ") print("vowel ")
case .Consonant: case .Consonant:
print("consonant ") print("consonant ")
case .Other: case .Other:
print("other ") print("other ")
} }
} }
print("\n") print("\n")
} }
printLetterKinds("Hello") printLetterKinds("Hello")
// 'Hello' is made up of the following kinds of letters: // 'Hello' is made up of the following kinds of letters:
// consonant vowel consonant consonant vowel // consonant vowel consonant consonant vowel
``` ```
函数`printLetterKinds`的输入是一个`String`值并对其字符进行迭代。在每次迭代过程中，考虑当前字符的`kind`计算属性，并打印出合适的类别描述。所以`printLetterKinds`就可以用来打印一个完整单词中所有字母的类型，正如上述单词`"hello"`所展示的。 函数`printLetterKinds`的输入是一个`String`值并对其字符进行迭代。在每次迭代过程中，考虑当前字符的`kind`计算属性，并打印出合适的类别描述。所以`printLetterKinds`就可以用来打印一个完整单词中所有字母的类型，正如上述单词`"hello"`所展示的。
>注意： >注意：
由于已知`character.kind`是`Character.Kind`型，所以`Character.Kind`中的所有成员值都可以使用`switch`语句里的形式简写，比如使用 `.Vowel`代替`Character.Kind.Vowel` 由于已知`character.kind`是`Character.Kind`型，所以`Character.Kind`中的所有成员值都可以使用`switch`语句里的形式简写，比如使用 `.Vowel`代替`Character.Kind.Vowel`

1440
source/chapter2/21_Protocols.md
View File

File diff suppressed because it is too large Load Diff

1036
source/chapter2/22_Generics.md
View File

File diff suppressed because it is too large Load Diff

976
source/chapter2/23_Advanced_Operators.md
View File

@ -1,488 +1,488 @@
> 翻译：[xielingwang](https://github.com/xielingwang) > 翻译：[xielingwang](https://github.com/xielingwang)
> 校对：[numbbbbb](https://github.com/numbbbbb) > 校对：[numbbbbb](https://github.com/numbbbbb)
# 高级运算符 # 高级运算符
----------------- -----------------
本页内容包括： 本页内容包括：
- [位运算符](#bitwise_operators) - [位运算符](#bitwise_operators)
- [溢出运算符](#overflow_operators) - [溢出运算符](#overflow_operators)
- [优先级和结合性(Precedence and Associativity)](#precedence_and_associativity) - [优先级和结合性(Precedence and Associativity)](#precedence_and_associativity)
- [运算符函数(Operator Functions)](#operator_functions) - [运算符函数(Operator Functions)](#operator_functions)
- [自定义运算符](#custom_operators) - [自定义运算符](#custom_operators)
除了[基本操作符](02_Basic_Operators.html)中所讲的运算符，Swift还有许多复杂的高级运算符，包括了C语和Objective-C中的位运算符和移位运算。 除了[基本操作符](02_Basic_Operators.html)中所讲的运算符，Swift还有许多复杂的高级运算符，包括了C语和Objective-C中的位运算符和移位运算。
不同于C语言中的数值计算，Swift的数值计算默认是不可溢出的。溢出行为会被捕获并报告为错误。你是故意的？好吧，你可以使用Swift为你准备的另一套默认允许溢出的数值运算符，如可溢出加`&+`。所有允许溢出的运算符都是以`&`开始的。 不同于C语言中的数值计算，Swift的数值计算默认是不可溢出的。溢出行为会被捕获并报告为错误。你是故意的？好吧，你可以使用Swift为你准备的另一套默认允许溢出的数值运算符，如可溢出加`&+`。所有允许溢出的运算符都是以`&`开始的。
自定义的结构，类和枚举，是否可以使用标准的运算符来定义操作？当然可以！在Swift中，你可以为你创建的所有类型定制运算符的操作。 自定义的结构，类和枚举，是否可以使用标准的运算符来定义操作？当然可以！在Swift中，你可以为你创建的所有类型定制运算符的操作。
可定制的运算符并不限于那些预设的运算符，自定义有个性的中置，前置，后置及赋值运算符，当然还有优先级和结合性。这些运算符的实现可以运用预设的运算符，也可以运用之前定制的运算符。 可定制的运算符并不限于那些预设的运算符，自定义有个性的中置，前置，后置及赋值运算符，当然还有优先级和结合性。这些运算符的实现可以运用预设的运算符，也可以运用之前定制的运算符。
<a name="bitwise_operators"></a> <a name="bitwise_operators"></a>
## 位运算符 ## 位运算符
位操作符通常在诸如图像处理和创建设备驱动等底层开发中使用，使用它可以单独操作数据结构中原始数据的比特位。在使用一个自定义的协议进行通信的时候，运用位运算符来对原始数据进行编码和解码也是非常有效的。 位操作符通常在诸如图像处理和创建设备驱动等底层开发中使用，使用它可以单独操作数据结构中原始数据的比特位。在使用一个自定义的协议进行通信的时候，运用位运算符来对原始数据进行编码和解码也是非常有效的。
Swift支持如下所有C语言的位运算符： Swift支持如下所有C语言的位运算符：
### 按位取反运算符 ### 按位取反运算符
按位取反运算符`~`对一个操作数的每一位都取反。 按位取反运算符`~`对一个操作数的每一位都取反。
![Art/bitwiseNOT_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitwiseNOT_2x.png "Art/bitwiseNOT_2x.png") ![Art/bitwiseNOT_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitwiseNOT_2x.png "Art/bitwiseNOT_2x.png")
这个运算符是前置的，所以请不加任何空格地写着操作数之前。 这个运算符是前置的，所以请不加任何空格地写着操作数之前。
```swift ```swift
let initialBits: UInt8 = 0b00001111 let initialBits: UInt8 = 0b00001111
let invertedBits = ~initialBits // 等于 0b11110000 let invertedBits = ~initialBits // 等于 0b11110000
``` ```
`UInt8`是8位无符整型，可以存储0~255之间的任意数。这个例子初始化一个整型为二进制值`00001111`(前4位为`0`，后4位为`1`)，它的十进制值为`15`。 `UInt8`是8位无符整型，可以存储0~255之间的任意数。这个例子初始化一个整型为二进制值`00001111`(前4位为`0`，后4位为`1`)，它的十进制值为`15`。
使用按位取反运算`~`对`initialBits`操作，然后赋值给`invertedBits`这个新常量。这个新常量的值等于所有位都取反的`initialBits`，即`1`变成`0`，`0`变成`1`，变成了`11110000`，十进制值为`240`。 使用按位取反运算`~`对`initialBits`操作，然后赋值给`invertedBits`这个新常量。这个新常量的值等于所有位都取反的`initialBits`，即`1`变成`0`，`0`变成`1`，变成了`11110000`，十进制值为`240`。
### 按位与运算符 ### 按位与运算符
按位与运算符对两个数进行操作，然后返回一个新的数，这个数的每个位都需要两个输入数的同一位都为1时才为1。 按位与运算符对两个数进行操作，然后返回一个新的数，这个数的每个位都需要两个输入数的同一位都为1时才为1。
![Art/bitwiseAND_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitwiseAND_2x.png "Art/bitwiseAND_2x.png") ![Art/bitwiseAND_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitwiseAND_2x.png "Art/bitwiseAND_2x.png")
以下代码，`firstSixBits`和`lastSixBits`中间4个位都为1。对它俩进行按位与运算后，就得到了`00111100`，即十进制的`60`。 以下代码，`firstSixBits`和`lastSixBits`中间4个位都为1。对它俩进行按位与运算后，就得到了`00111100`，即十进制的`60`。
```swift ```swift
let firstSixBits: UInt8 = 0b11111100 let firstSixBits: UInt8 = 0b11111100
let lastSixBits: UInt8 = 0b00111111 let lastSixBits: UInt8 = 0b00111111
let middleFourBits = firstSixBits & lastSixBits // 等于 00111100 let middleFourBits = firstSixBits & lastSixBits // 等于 00111100
``` ```
### 按位或运算 ### 按位或运算
按位或运算符`|`比较两个数，然后返回一个新的数，这个数的每一位设置1的条件是两个输入数的同一位都不为0(即任意一个为1，或都为1)。 按位或运算符`|`比较两个数，然后返回一个新的数，这个数的每一位设置1的条件是两个输入数的同一位都不为0(即任意一个为1，或都为1)。
![Art/bitwiseOR_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitwiseOR_2x.png "Art/bitwiseOR_2x.png") ![Art/bitwiseOR_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitwiseOR_2x.png "Art/bitwiseOR_2x.png")
如下代码，`someBits`和`moreBits`在不同位上有`1`。按位或运行的结果是`11111110`，即十进制的`254`。 如下代码，`someBits`和`moreBits`在不同位上有`1`。按位或运行的结果是`11111110`，即十进制的`254`。
```swift ```swift
let someBits: UInt8 = 0b10110010 let someBits: UInt8 = 0b10110010
let moreBits: UInt8 = 0b01011110 let moreBits: UInt8 = 0b01011110
let combinedbits = someBits | moreBits // 等于 11111110 let combinedbits = someBits | moreBits // 等于 11111110
``` ```
### 按位异或运算符 ### 按位异或运算符
按位异或运算符`^`比较两个数，然后返回一个数，这个数的每个位设为`1`的条件是两个输入数的同一位不同，如果相同就设为`0`。 按位异或运算符`^`比较两个数，然后返回一个数，这个数的每个位设为`1`的条件是两个输入数的同一位不同，如果相同就设为`0`。
![Art/bitwiseXOR_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitwiseXOR_2x.png "Art/bitwiseXOR_2x.png") ![Art/bitwiseXOR_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitwiseXOR_2x.png "Art/bitwiseXOR_2x.png")
以下代码，`firstBits`和`otherBits`都有一个`1`跟另一个数不同的。所以按位异或的结果是把它这些位置为`1`，其他都置为`0`。 以下代码，`firstBits`和`otherBits`都有一个`1`跟另一个数不同的。所以按位异或的结果是把它这些位置为`1`，其他都置为`0`。
```swift ```swift
let firstBits: UInt8 = 0b00010100 let firstBits: UInt8 = 0b00010100
let otherBits: UInt8 = 0b00000101 let otherBits: UInt8 = 0b00000101
let outputBits = firstBits ^ otherBits // 等于 00010001 let outputBits = firstBits ^ otherBits // 等于 00010001
``` ```
### 按位左移/右移运算符 ### 按位左移/右移运算符
左移运算符`<<`和右移运算符`>>`会把一个数的所有比特位按以下定义的规则向左或向右移动指定位数。 左移运算符`<<`和右移运算符`>>`会把一个数的所有比特位按以下定义的规则向左或向右移动指定位数。
按位左移和按位右移的效果相当把一个整数乘于或除于一个因子为`2`的整数。向左移动一个整型的比特位相当于把这个数乘于`2`，向右移一位就是除于`2`。 按位左移和按位右移的效果相当把一个整数乘于或除于一个因子为`2`的整数。向左移动一个整型的比特位相当于把这个数乘于`2`，向右移一位就是除于`2`。
#### 无符整型的移位操作 #### 无符整型的移位操作
对无符整型的移位的效果如下： 对无符整型的移位的效果如下：
已经存在的比特位向左或向右移动指定的位数。被移出整型存储边界的的位数直接抛弃，移动留下的空白位用零`0`来填充。这种方法称为逻辑移位。 已经存在的比特位向左或向右移动指定的位数。被移出整型存储边界的的位数直接抛弃，移动留下的空白位用零`0`来填充。这种方法称为逻辑移位。
以下这张把展示了 `11111111 << 1`(`11111111`向左移1位)，和 `11111111 >> 1`(`11111111`向右移1位)。蓝色的是被移位的，灰色是被抛弃的，橙色的`0`是被填充进来的。 以下这张把展示了 `11111111 << 1`(`11111111`向左移1位)，和 `11111111 >> 1`(`11111111`向右移1位)。蓝色的是被移位的，灰色是被抛弃的，橙色的`0`是被填充进来的。
![Art/bitshiftUnsigned_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitshiftUnsigned_2x.png "Art/bitshiftUnsigned_2x.png") ![Art/bitshiftUnsigned_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitshiftUnsigned_2x.png "Art/bitshiftUnsigned_2x.png")
```swift ```swift
let shiftBits: UInt8 = 4 // 即二进制的00000100 let shiftBits: UInt8 = 4 // 即二进制的00000100
shiftBits << 1 // 00001000 shiftBits << 1 // 00001000
shiftBits << 2 // 00010000 shiftBits << 2 // 00010000
shiftBits << 5 // 10000000 shiftBits << 5 // 10000000
shiftBits << 6 // 00000000 shiftBits << 6 // 00000000
shiftBits >> 2 // 00000001 shiftBits >> 2 // 00000001
``` ```
你可以使用移位操作进行其他数据类型的编码和解码。 你可以使用移位操作进行其他数据类型的编码和解码。
```swift ```swift
let pink: UInt32 = 0xCC6699 let pink: UInt32 = 0xCC6699
let redComponent = (pink & 0xFF0000) >> 16 // redComponent 是 0xCC, 即 204 let redComponent = (pink & 0xFF0000) >> 16 // redComponent 是 0xCC, 即 204
let greenComponent = (pink & 0x00FF00) >> 8 // greenComponent 是 0x66, 即 102 let greenComponent = (pink & 0x00FF00) >> 8 // greenComponent 是 0x66, 即 102
let blueComponent = pink & 0x0000FF // blueComponent 是 0x99, 即 153 let blueComponent = pink & 0x0000FF // blueComponent 是 0x99, 即 153
``` ```
这个例子使用了一个`UInt32`的命名为`pink`的常量来存储层叠样式表`CSS`中粉色的颜色值，`CSS`颜色`#CC6699`在Swift用十六进制`0xCC6699`来表示。然后使用按位与(&)和按位右移就可以从这个颜色值中解析出红(CC)，绿(66)，蓝(99)三个部分。 这个例子使用了一个`UInt32`的命名为`pink`的常量来存储层叠样式表`CSS`中粉色的颜色值，`CSS`颜色`#CC6699`在Swift用十六进制`0xCC6699`来表示。然后使用按位与(&)和按位右移就可以从这个颜色值中解析出红(CC)，绿(66)，蓝(99)三个部分。
对`0xCC6699`和`0xFF0000`进行按位与`&`操作就可以得到红色部分。`0xFF0000`中的`0`了遮盖了`OxCC6699`的第二和第三个字节，这样`6699`被忽略了，只留下`0xCC0000`。 对`0xCC6699`和`0xFF0000`进行按位与`&`操作就可以得到红色部分。`0xFF0000`中的`0`了遮盖了`OxCC6699`的第二和第三个字节，这样`6699`被忽略了，只留下`0xCC0000`。
然后，按向右移动16位，即 `>> 16`。十六进制中每两个字符是8比特位，所以移动16位的结果是把`0xCC0000`变成`0x0000CC`。这和`0xCC`是相等的，都是十进制的`204`。 然后，按向右移动16位，即 `>> 16`。十六进制中每两个字符是8比特位，所以移动16位的结果是把`0xCC0000`变成`0x0000CC`。这和`0xCC`是相等的，都是十进制的`204`。
同样的，绿色部分来自于`0xCC6699`和`0x00FF00`的按位操作得到`0x006600`。然后向右移动8們，得到`0x66`，即十进制的`102`。 同样的，绿色部分来自于`0xCC6699`和`0x00FF00`的按位操作得到`0x006600`。然后向右移动8們，得到`0x66`，即十进制的`102`。
最后，蓝色部分对`0xCC6699`和`0x0000FF`进行按位与运算，得到`0x000099`，无需向右移位了，所以结果就是`0x99`，即十进制的`153`。 最后，蓝色部分对`0xCC6699`和`0x0000FF`进行按位与运算，得到`0x000099`，无需向右移位了，所以结果就是`0x99`，即十进制的`153`。
#### 有符整型的移位操作 #### 有符整型的移位操作
有符整型的移位操作相对复杂得多，因为正负号也是用二进制位表示的。(这里举的例子虽然都是8位的，但它的原理是通用的。) 有符整型的移位操作相对复杂得多，因为正负号也是用二进制位表示的。(这里举的例子虽然都是8位的，但它的原理是通用的。)
有符整型通过第1个比特位(称为符号位)来表达这个整数是正数还是负数。`0`代表正数，`1`代表负数。 有符整型通过第1个比特位(称为符号位)来表达这个整数是正数还是负数。`0`代表正数，`1`代表负数。
其余的比特位(称为数值位)存储其实值。有符正整数和无符正整数在计算机里的存储结果是一样的，下来我们来看`+4`内部的二进制结构。 其余的比特位(称为数值位)存储其实值。有符正整数和无符正整数在计算机里的存储结果是一样的，下来我们来看`+4`内部的二进制结构。
![Art/bitshiftSignedFour_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitshiftSignedFour_2x.png "Art/bitshiftSignedFour_2x.png") ![Art/bitshiftSignedFour_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitshiftSignedFour_2x.png "Art/bitshiftSignedFour_2x.png")
符号位为`0`，代表正数，另外7比特位二进制表示的实际值就刚好是`4`。 符号位为`0`，代表正数，另外7比特位二进制表示的实际值就刚好是`4`。
负数呢，跟正数不同。负数存储的是2的n次方减去它的绝对值，n为数值位的位数。一个8比特的数有7个数值位，所以是2的7次方，即128。 负数呢，跟正数不同。负数存储的是2的n次方减去它的绝对值，n为数值位的位数。一个8比特的数有7个数值位，所以是2的7次方，即128。
我们来看`-4`存储的二进制结构。 我们来看`-4`存储的二进制结构。
![Art/bitshiftSignedMinusFour_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitshiftSignedMinusFour_2x.png "Art/bitshiftSignedMinusFour_2x.png") ![Art/bitshiftSignedMinusFour_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitshiftSignedMinusFour_2x.png "Art/bitshiftSignedMinusFour_2x.png")
现在符号位为`1`，代表负数，7个数值位要表达的二进制值是124，即128 - 4。 现在符号位为`1`，代表负数，7个数值位要表达的二进制值是124，即128 - 4。
![Art/bitshiftSignedMinusFourValue_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitshiftSignedMinusFourValue_2x.png "Art/bitshiftSignedMinusFourValue_2x.png") ![Art/bitshiftSignedMinusFourValue_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitshiftSignedMinusFourValue_2x.png "Art/bitshiftSignedMinusFourValue_2x.png")
负数的编码方式称为二进制补码表示。这种表示方式看起来很奇怪，但它有几个优点。 负数的编码方式称为二进制补码表示。这种表示方式看起来很奇怪，但它有几个优点。
首先，只需要对全部8个比特位(包括符号)做标准的二进制加法就可以完成 `-1 + -4` 的操作，忽略加法过程产生的超过8个比特位表达的任何信息。 首先，只需要对全部8个比特位(包括符号)做标准的二进制加法就可以完成 `-1 + -4` 的操作，忽略加法过程产生的超过8个比特位表达的任何信息。
![Art/bitshiftSignedAddition_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitshiftSignedAddition_2x.png "Art/bitshiftSignedAddition_2x.png") ![Art/bitshiftSignedAddition_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitshiftSignedAddition_2x.png "Art/bitshiftSignedAddition_2x.png")
第二，由于使用二进制补码表示，我们可以和正数一样对负数进行按位左移右移的，同样也是左移1位时乘于`2`，右移1位时除于`2`。要达到此目的，对有符整型的右移有一个特别的要求： 第二，由于使用二进制补码表示，我们可以和正数一样对负数进行按位左移右移的，同样也是左移1位时乘于`2`，右移1位时除于`2`。要达到此目的，对有符整型的右移有一个特别的要求：
对有符整型按位右移时，使用符号位(正数为`0`，负数为`1`)填充空白位。 对有符整型按位右移时，使用符号位(正数为`0`，负数为`1`)填充空白位。
![Art/bitshiftSigned_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitshiftSigned_2x.png "Art/bitshiftSigned_2x.png") ![Art/bitshiftSigned_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitshiftSigned_2x.png "Art/bitshiftSigned_2x.png")
这就确保了在右移的过程中，有符整型的符号不会发生变化。这称为算术移位。 这就确保了在右移的过程中，有符整型的符号不会发生变化。这称为算术移位。
正因为正数和负数特殊的存储方式，向右移位使它接近于`0`。移位过程中保持符号会不变，负数在接近`0`的过程中一直是负数。 正因为正数和负数特殊的存储方式，向右移位使它接近于`0`。移位过程中保持符号会不变，负数在接近`0`的过程中一直是负数。
<a name="overflow_operators"></a> <a name="overflow_operators"></a>
## 溢出运算符 ## 溢出运算符
默认情况下，当你往一个整型常量或变量赋于一个它不能承载的大数时，Swift不会让你这么干的，它会报错。这样，在操作过大或过小的数的时候就很安全了。 默认情况下，当你往一个整型常量或变量赋于一个它不能承载的大数时，Swift不会让你这么干的，它会报错。这样，在操作过大或过小的数的时候就很安全了。
例如，`Int16`整型能承载的整数范围是`-32768`到`32767`，如果给它赋上超过这个范围的数，就会报错： 例如，`Int16`整型能承载的整数范围是`-32768`到`32767`，如果给它赋上超过这个范围的数，就会报错：
```swift ```swift
var potentialOverflow = Int16.max var potentialOverflow = Int16.max
// potentialOverflow 等于 32767, 这是 Int16 能承载的最大整数 // potentialOverflow 等于 32767, 这是 Int16 能承载的最大整数
potentialOverflow += 1 potentialOverflow += 1
// 噢, 出错了 // 噢, 出错了
``` ```
对过大或过小的数值进行错误处理让你的数值边界条件更灵活。 对过大或过小的数值进行错误处理让你的数值边界条件更灵活。
当然，你有意在溢出时对有效位进行截断，你可采用溢出运算，而非错误处理。Swfit为整型计算提供了5个`&`符号开头的溢出运算符。 当然，你有意在溢出时对有效位进行截断，你可采用溢出运算，而非错误处理。Swfit为整型计算提供了5个`&`符号开头的溢出运算符。
- 溢出加法 `&+` - 溢出加法 `&+`
- 溢出减法 `&-` - 溢出减法 `&-`
- 溢出乘法 `&*` - 溢出乘法 `&*`
- 溢出除法 `&/` - 溢出除法 `&/`
- 溢出求余 `&%` - 溢出求余 `&%`
### 值的上溢出 ### 值的上溢出
下面例子使用了溢出加法`&+`来解剖的无符整数的上溢出 下面例子使用了溢出加法`&+`来解剖的无符整数的上溢出
```swift ```swift
var willOverflow = UInt8.max var willOverflow = UInt8.max
// willOverflow 等于UInt8的最大整数 255 // willOverflow 等于UInt8的最大整数 255
willOverflow = willOverflow &+ 1 willOverflow = willOverflow &+ 1
// 这时候 willOverflow 等于 0 // 这时候 willOverflow 等于 0
``` ```
`willOverflow`用`Int8`所能承载的最大值`255`(二进制`11111111`)，然后用`&+`加1。然后`UInt8`就无法表达这个新值的二进制了，也就导致了这个新值上溢出了，大家可以看下图。溢出后，新值在`UInt8`的承载范围内的那部分是`00000000`，也就是`0`。 `willOverflow`用`Int8`所能承载的最大值`255`(二进制`11111111`)，然后用`&+`加1。然后`UInt8`就无法表达这个新值的二进制了，也就导致了这个新值上溢出了，大家可以看下图。溢出后，新值在`UInt8`的承载范围内的那部分是`00000000`，也就是`0`。
![Art/overflowAddition_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/overflowAddition_2x.png "Art/overflowAddition_2x.png") ![Art/overflowAddition_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/overflowAddition_2x.png "Art/overflowAddition_2x.png")
### 值的下溢出 ### 值的下溢出
数值也有可能因为太小而越界。举个例子： 数值也有可能因为太小而越界。举个例子：
`UInt8`的最小值是`0`(二进制为`00000000`)。使用`&-`进行溢出减1，就会得到二进制的`11111111`即十进制的`255`。 `UInt8`的最小值是`0`(二进制为`00000000`)。使用`&-`进行溢出减1，就会得到二进制的`11111111`即十进制的`255`。
![Art/overflowUnsignedSubtraction_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/overflowUnsignedSubtraction_2x.png "Art/overflowUnsignedSubtraction_2x.png") ![Art/overflowUnsignedSubtraction_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/overflowUnsignedSubtraction_2x.png "Art/overflowUnsignedSubtraction_2x.png")
Swift代码是这样的: Swift代码是这样的:
```swift ```swift
var willUnderflow = UInt8.min var willUnderflow = UInt8.min
// willUnderflow 等于UInt8的最小值0 // willUnderflow 等于UInt8的最小值0
willUnderflow = willUnderflow &- 1 willUnderflow = willUnderflow &- 1
// 此时 willUnderflow 等于 255 // 此时 willUnderflow 等于 255
``` ```
有符整型也有类似的下溢出，有符整型所有的减法也都是对包括在符号位在内的二进制数进行二进制减法的，这在 "按位左移/右移运算符" 一节提到过。最小的有符整数是`-128`，即二进制的`10000000`。用溢出减法减去去1后，变成了`01111111`，即UInt8所能承载的最大整数`127`。 有符整型也有类似的下溢出，有符整型所有的减法也都是对包括在符号位在内的二进制数进行二进制减法的，这在 "按位左移/右移运算符" 一节提到过。最小的有符整数是`-128`，即二进制的`10000000`。用溢出减法减去去1后，变成了`01111111`，即UInt8所能承载的最大整数`127`。
![Art/overflowSignedSubtraction_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/overflowSignedSubtraction_2x.png "Art/overflowSignedSubtraction_2x.png") ![Art/overflowSignedSubtraction_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/overflowSignedSubtraction_2x.png "Art/overflowSignedSubtraction_2x.png")
来看看Swift代码： 来看看Swift代码：
```swift ```swift
var signedUnderflow = Int8.min var signedUnderflow = Int8.min
// signedUnderflow 等于最小的有符整数 -128 // signedUnderflow 等于最小的有符整数 -128
signedUnderflow = signedUnderflow &- 1 signedUnderflow = signedUnderflow &- 1
// 如今 signedUnderflow 等于 127 // 如今 signedUnderflow 等于 127
``` ```
### 除零溢出 ### 除零溢出
一个数除于0 `i / 0`，或者对0求余数 `i % 0`，就会产生一个错误。 一个数除于0 `i / 0`，或者对0求余数 `i % 0`，就会产生一个错误。
```swift ```swift
let x = 1 let x = 1
let y = x / 0 let y = x / 0
``` ```
使用它们对应的可溢出的版本的运算符`&/`和`&%`进行除0操作时就会得到`0`值。 使用它们对应的可溢出的版本的运算符`&/`和`&%`进行除0操作时就会得到`0`值。
```swift ```swift
let x = 1 let x = 1
let y = x &/ 0 let y = x &/ 0
// y 等于 0 // y 等于 0
``` ```
<a name="precedence_and_associativity"></a> <a name="precedence_and_associativity"></a>
## 优先级和结合性 ## 优先级和结合性
运算符的优先级使得一些运算符优先于其他运算符，高优先级的运算符会先被计算。 运算符的优先级使得一些运算符优先于其他运算符，高优先级的运算符会先被计算。
结合性定义相同优先级的运算符在一起时是怎么组合或关联的，是和左边的一组呢，还是和右边的一组。意思就是，到底是和左边的表达式结合呢，还是和右边的表达式结合？ 结合性定义相同优先级的运算符在一起时是怎么组合或关联的，是和左边的一组呢，还是和右边的一组。意思就是，到底是和左边的表达式结合呢，还是和右边的表达式结合？
在混合表达式中，运算符的优先级和结合性是非常重要的。举个例子，为什么下列表达式的结果为`4`？ 在混合表达式中，运算符的优先级和结合性是非常重要的。举个例子，为什么下列表达式的结果为`4`？
```swift ```swift
2 + 3 * 4 % 5 2 + 3 * 4 % 5
// 结果是 4 // 结果是 4
``` ```
如果严格地从左计算到右，计算过程会是这样： 如果严格地从左计算到右，计算过程会是这样：
- 2 plus 3 equals 5; - 2 plus 3 equals 5;
- 2 + 3 = 5 - 2 + 3 = 5
- 5 times 4 equals 20; - 5 times 4 equals 20;
- 5 * 4 = 20 - 5 * 4 = 20
- 20 remainder 5 equals 0 - 20 remainder 5 equals 0
- 20 / 5 = 4 余 0 - 20 / 5 = 4 余 0
但是正确答案是`4`而不是`0`。优先级高的运算符要先计算，在Swift和C语言中，都是先乘除后加减的。所以，执行完乘法和求余运算才能执行加减运算。 但是正确答案是`4`而不是`0`。优先级高的运算符要先计算，在Swift和C语言中，都是先乘除后加减的。所以，执行完乘法和求余运算才能执行加减运算。
乘法和求余拥有相同的优先级，在运算过程中，我们还需要结合性，乘法和求余运算都是左结合的。这相当于在表达式中有隐藏的括号让运算从左开始。 乘法和求余拥有相同的优先级，在运算过程中，我们还需要结合性，乘法和求余运算都是左结合的。这相当于在表达式中有隐藏的括号让运算从左开始。
```swift ```swift
2 + ((3 * 4) % 5) 2 + ((3 * 4) % 5)
``` ```
(3 * 4) is 12, so this is equivalent to: (3 * 4) is 12, so this is equivalent to:
3 * 4 = 12，所以这相当于： 3 * 4 = 12，所以这相当于：
```swift ```swift
2 + (12 % 5) 2 + (12 % 5)
``` ```
(12 % 5) is 2, so this is equivalent to: (12 % 5) is 2, so this is equivalent to:
12 % 5 = 2，所这又相当于 12 % 5 = 2，所这又相当于
```swift ```swift
2 + 2 2 + 2
``` ```
计算结果为 4。 计算结果为 4。
查阅Swift运算符的优先级和结合性的完整列表，请看[表达式](../chapter3/04_Expressions.html)。 查阅Swift运算符的优先级和结合性的完整列表，请看[表达式](../chapter3/04_Expressions.html)。
> 注意： > 注意：
Swift的运算符较C语言和Objective-C来得更简单和保守，这意味着跟基于C的语言可能不一样。所以，在移植已有代码到Swift时，注意去确保代码按你想的那样去执行。 Swift的运算符较C语言和Objective-C来得更简单和保守，这意味着跟基于C的语言可能不一样。所以，在移植已有代码到Swift时，注意去确保代码按你想的那样去执行。
<a name="operator_functions"></a> <a name="operator_functions"></a>
## 运算符函数 ## 运算符函数
让已有的运算符也可以对自定义的类和结构进行运算，这称为运算符重载。 让已有的运算符也可以对自定义的类和结构进行运算，这称为运算符重载。
这个例子展示了如何用`+`让一个自定义的结构做加法。算术运算符`+`是一个两目运算符，因为它有两个操作数，而且它必须出现在两个操作数之间。 这个例子展示了如何用`+`让一个自定义的结构做加法。算术运算符`+`是一个两目运算符，因为它有两个操作数，而且它必须出现在两个操作数之间。
例子中定义了一个名为`Vector2D`的二维坐标向量 `(x，y)` 的结构，然后定义了让两个`Vector2D`的对象相加的运算符函数。 例子中定义了一个名为`Vector2D`的二维坐标向量 `(x，y)` 的结构，然后定义了让两个`Vector2D`的对象相加的运算符函数。
```swift ```swift
struct Vector2D { struct Vector2D {
var x = 0.0, y = 0.0 var x = 0.0, y = 0.0
} }
@infix func + (left: Vector2D, right: Vector2D) -> Vector2D { @infix func + (left: Vector2D, right: Vector2D) -> Vector2D {
return Vector2D(x: left.x + right.x, y: left.y + right.y) return Vector2D(x: left.x + right.x, y: left.y + right.y)
} }
``` ```
该运算符函数定义了一个全局的`+`函数，这个函数需要两个`Vector2D`类型的参数，返回值也是`Vector2D`类型。需要定义和实现一个中置运算的时候，在关键字`func`之前写上属性 `@infix` 就可以了。 该运算符函数定义了一个全局的`+`函数，这个函数需要两个`Vector2D`类型的参数，返回值也是`Vector2D`类型。需要定义和实现一个中置运算的时候，在关键字`func`之前写上属性 `@infix` 就可以了。
在这个代码实现中，参数被命名为了`left`和`right`，代表`+`左边和右边的两个`Vector2D`对象。函数返回了一个新的`Vector2D`的对象，这个对象的`x`和`y`分别等于两个参数对象的`x`和`y`的和。 在这个代码实现中，参数被命名为了`left`和`right`，代表`+`左边和右边的两个`Vector2D`对象。函数返回了一个新的`Vector2D`的对象，这个对象的`x`和`y`分别等于两个参数对象的`x`和`y`的和。
这个函数是全局的，而不是`Vector2D`结构的成员方法，所以任意两个`Vector2D`对象都可以使用这个中置运算符。 这个函数是全局的，而不是`Vector2D`结构的成员方法，所以任意两个`Vector2D`对象都可以使用这个中置运算符。
```swift ```swift
let vector = Vector2D(x: 3.0, y: 1.0) let vector = Vector2D(x: 3.0, y: 1.0)
let anotherVector = Vector2D(x: 2.0, y: 4.0) let anotherVector = Vector2D(x: 2.0, y: 4.0)
let combinedVector = vector + anotherVector let combinedVector = vector + anotherVector
// combinedVector 是一个新的Vector2D, 值为 (5.0, 5.0) // combinedVector 是一个新的Vector2D, 值为 (5.0, 5.0)
``` ```
这个例子实现两个向量 `(3.0，1.0)` 和 `(2.0，4.0)` 相加，得到向量 `(5.0，5.0)` 的过程。如下图示： 这个例子实现两个向量 `(3.0，1.0)` 和 `(2.0，4.0)` 相加，得到向量 `(5.0，5.0)` 的过程。如下图示：
![Art/vectorAddition_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/vectorAddition_2x.png "Art/vectorAddition_2x.png") ![Art/vectorAddition_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/vectorAddition_2x.png "Art/vectorAddition_2x.png")
### 前置和后置运算符 ### 前置和后置运算符
上个例子演示了一个双目中置运算符的自定义实现，同样我们也可以玩标准单目运算符的实现。单目运算符只有一个操作数，在操作数之前就是前置的，如`-a`; 在操作数之后就是后置的，如`i++`。 上个例子演示了一个双目中置运算符的自定义实现，同样我们也可以玩标准单目运算符的实现。单目运算符只有一个操作数，在操作数之前就是前置的，如`-a`; 在操作数之后就是后置的，如`i++`。
实现一个前置或后置运算符时，在定义该运算符的时候于关键字`func`之前标注 `@prefix` 或 `@postfix` 属性。 实现一个前置或后置运算符时，在定义该运算符的时候于关键字`func`之前标注 `@prefix` 或 `@postfix` 属性。
```swift ```swift
@prefix func - (vector: Vector2D) -> Vector2D { @prefix func - (vector: Vector2D) -> Vector2D {
return Vector2D(x: -vector.x, y: -vector.y) return Vector2D(x: -vector.x, y: -vector.y)
} }
``` ```
这段代码为`Vector2D`类型提供了单目减运算`-a`，`@prefix`属性表明这是个前置运算符。 这段代码为`Vector2D`类型提供了单目减运算`-a`，`@prefix`属性表明这是个前置运算符。
对于数值，单目减运算符可以把正数变负数，把负数变正数。对于`Vector2D`，单目减运算将其`x`和`y`都进进行单目减运算。 对于数值，单目减运算符可以把正数变负数，把负数变正数。对于`Vector2D`，单目减运算将其`x`和`y`都进进行单目减运算。
```swift ```swift
let positive = Vector2D(x: 3.0, y: 4.0) let positive = Vector2D(x: 3.0, y: 4.0)
let negative = -positive let negative = -positive
// negative 为 (-3.0, -4.0) // negative 为 (-3.0, -4.0)
let alsoPositive = -negative let alsoPositive = -negative
// alsoPositive 为 (3.0, 4.0) // alsoPositive 为 (3.0, 4.0)
``` ```
### 组合赋值运算符 ### 组合赋值运算符
组合赋值是其他运算符和赋值运算符一起执行的运算。如`+=`把加运算和赋值运算组合成一个操作。实现一个组合赋值符号需要使用`@assignment`属性，还需要把运算符的左参数设置成`inout`，因为这个参数会在运算符函数内直接修改它的值。 组合赋值是其他运算符和赋值运算符一起执行的运算。如`+=`把加运算和赋值运算组合成一个操作。实现一个组合赋值符号需要使用`@assignment`属性，还需要把运算符的左参数设置成`inout`，因为这个参数会在运算符函数内直接修改它的值。
```swift ```swift
@assignment func += (inout left: Vector2D, right: Vector2D) { @assignment func += (inout left: Vector2D, right: Vector2D) {
left = left + right left = left + right
} }
``` ```
因为加法运算在之前定义过了，这里无需重新定义。所以，加赋运算符函数使用已经存在的高级加法运算符函数来执行左值加右值的运算。 因为加法运算在之前定义过了，这里无需重新定义。所以，加赋运算符函数使用已经存在的高级加法运算符函数来执行左值加右值的运算。
```swift ```swift
var original = Vector2D(x: 1.0, y: 2.0) var original = Vector2D(x: 1.0, y: 2.0)
let vectorToAdd = Vector2D(x: 3.0, y: 4.0) let vectorToAdd = Vector2D(x: 3.0, y: 4.0)
original += vectorToAdd original += vectorToAdd
// original 现在为 (4.0, 6.0) // original 现在为 (4.0, 6.0)
``` ```
你可以将 `@assignment` 属性和 `@prefix` 或 `@postfix` 属性起来组合，实现一个`Vector2D`的前置运算符。 你可以将 `@assignment` 属性和 `@prefix` 或 `@postfix` 属性起来组合，实现一个`Vector2D`的前置运算符。
```swift ```swift
@prefix @assignment func ++ (inout vector: Vector2D) -> Vector2D { @prefix @assignment func ++ (inout vector: Vector2D) -> Vector2D {
vector += Vector2D(x: 1.0, y: 1.0) vector += Vector2D(x: 1.0, y: 1.0)
return vector return vector
} }
``` ```
这个前置使用了已经定义好的高级加赋运算，将自己加上一个值为 `(1.0，1.0)` 的对象然后赋给自己，然后再将自己返回。 这个前置使用了已经定义好的高级加赋运算，将自己加上一个值为 `(1.0，1.0)` 的对象然后赋给自己，然后再将自己返回。
```swift ```swift
var toIncrement = Vector2D(x: 3.0, y: 4.0) var toIncrement = Vector2D(x: 3.0, y: 4.0)
let afterIncrement = ++toIncrement let afterIncrement = ++toIncrement
// toIncrement 现在是 (4.0, 5.0) // toIncrement 现在是 (4.0, 5.0)
// afterIncrement 现在也是 (4.0, 5.0) // afterIncrement 现在也是 (4.0, 5.0)
``` ```
>注意： >注意：
默认的赋值符是不可重载的。只有组合赋值符可以重载。三目条件运算符 `a？b：c` 也是不可重载。 默认的赋值符是不可重载的。只有组合赋值符可以重载。三目条件运算符 `a？b：c` 也是不可重载。
### 比较运算符 ### 比较运算符
Swift无所知道自定义类型是否相等或不等，因为等于或者不等于由你的代码说了算了。所以自定义的类和结构要使用比较符`==`或`!=`就需要重载。 Swift无所知道自定义类型是否相等或不等，因为等于或者不等于由你的代码说了算了。所以自定义的类和结构要使用比较符`==`或`!=`就需要重载。
定义相等运算符函数跟定义其他中置运算符雷同： 定义相等运算符函数跟定义其他中置运算符雷同：
```swift ```swift
@infix func == (left: Vector2D, right: Vector2D) -> Bool { @infix func == (left: Vector2D, right: Vector2D) -> Bool {
return (left.x == right.x) && (left.y == right.y) return (left.x == right.x) && (left.y == right.y)
} }
@infix func != (left: Vector2D, right: Vector2D) -> Bool { @infix func != (left: Vector2D, right: Vector2D) -> Bool {
return !(left == right) return !(left == right)
} }
``` ```
上述代码实现了相等运算符`==`来判断两个`Vector2D`对象是否有相等的值，相等的概念就是它们有相同的`x`值和相同的`y`值，我们就用这个逻辑来实现。接着使用`==`的结果实现了不相等运算符`!=`。 上述代码实现了相等运算符`==`来判断两个`Vector2D`对象是否有相等的值，相等的概念就是它们有相同的`x`值和相同的`y`值，我们就用这个逻辑来实现。接着使用`==`的结果实现了不相等运算符`!=`。
现在我们可以使用这两个运算符来判断两个`Vector2D`对象是否相等。 现在我们可以使用这两个运算符来判断两个`Vector2D`对象是否相等。
```swift ```swift
let twoThree = Vector2D(x: 2.0, y: 3.0) let twoThree = Vector2D(x: 2.0, y: 3.0)
let anotherTwoThree = Vector2D(x: 2.0, y: 3.0) let anotherTwoThree = Vector2D(x: 2.0, y: 3.0)
if twoThree == anotherTwoThree { if twoThree == anotherTwoThree {
println("这两个向量是相等的.") println("这两个向量是相等的.")
} }
// prints "这两个向量是相等的." // prints "这两个向量是相等的."
``` ```
### 自定义运算符 ### 自定义运算符
标准的运算符不够玩，那你可以声明一些个性的运算符，但个性的运算符只能使用这些字符 `/ = - + * % < >！& | ^。~`。 标准的运算符不够玩，那你可以声明一些个性的运算符，但个性的运算符只能使用这些字符 `/ = - + * % < >！& | ^。~`。
新的运算符声明需在全局域使用`operator`关键字声明，可以声明为前置，中置或后置的。 新的运算符声明需在全局域使用`operator`关键字声明，可以声明为前置，中置或后置的。
```swift ```swift
operator prefix +++ {} operator prefix +++ {}
``` ```
这段代码定义了一个新的前置运算符叫`+++`，此前Swift并不存在这个运算符。此处为了演示，我们让`+++`对`Vector2D`对象的操作定义为 `双自增` 这样一个独有的操作，这个操作使用了之前定义的加赋运算实现了自已加上自己然后返回的运算。 这段代码定义了一个新的前置运算符叫`+++`，此前Swift并不存在这个运算符。此处为了演示，我们让`+++`对`Vector2D`对象的操作定义为 `双自增` 这样一个独有的操作，这个操作使用了之前定义的加赋运算实现了自已加上自己然后返回的运算。
```swift ```swift
@prefix @assignment func +++ (inout vector: Vector2D) -> Vector2D { @prefix @assignment func +++ (inout vector: Vector2D) -> Vector2D {
vector += vector vector += vector
return vector return vector
} }
``` ```
`Vector2D` 的 `+++` 的实现和 `++` 的实现很接近, 唯一不同的前者是加自己, 后者是加值为 `(1.0, 1.0)` 的向量. `Vector2D` 的 `+++` 的实现和 `++` 的实现很接近, 唯一不同的前者是加自己, 后者是加值为 `(1.0, 1.0)` 的向量.
```swift ```swift
var toBeDoubled = Vector2D(x: 1.0, y: 4.0) var toBeDoubled = Vector2D(x: 1.0, y: 4.0)
let afterDoubling = +++toBeDoubled let afterDoubling = +++toBeDoubled
// toBeDoubled 现在是 (2.0, 8.0) // toBeDoubled 现在是 (2.0, 8.0)
// afterDoubling 现在也是 (2.0, 8.0) // afterDoubling 现在也是 (2.0, 8.0)
``` ```
### 自定义中置运算符的优先级和结合性 ### 自定义中置运算符的优先级和结合性
可以为自定义的中置运算符指定优先级和结合性。可以回头看看[优先级和结合性](#PrecedenceandAssociativity)解释这两个因素是如何影响多种中置运算符混合的表达式的计算的。 可以为自定义的中置运算符指定优先级和结合性。可以回头看看[优先级和结合性](#PrecedenceandAssociativity)解释这两个因素是如何影响多种中置运算符混合的表达式的计算的。
结合性(associativity)的值可取的值有`left`，`right`和`none`。左结合运算符跟其他优先级相同的左结合运算符写在一起时，会跟左边的操作数结合。同理，右结合运算符会跟右边的操作数结合。而非结合运算符不能跟其他相同优先级的运算符写在一起。 结合性(associativity)的值可取的值有`left`，`right`和`none`。左结合运算符跟其他优先级相同的左结合运算符写在一起时，会跟左边的操作数结合。同理，右结合运算符会跟右边的操作数结合。而非结合运算符不能跟其他相同优先级的运算符写在一起。
结合性(associativity)的值默认为`none`，优先级(precedence)默认为`100`。 结合性(associativity)的值默认为`none`，优先级(precedence)默认为`100`。
以下例子定义了一个新的中置符`+-`，是左结合的`left`，优先级为`140`。 以下例子定义了一个新的中置符`+-`，是左结合的`left`，优先级为`140`。
```swift ```swift
operator infix +- { associativity left precedence 140 } operator infix +- { associativity left precedence 140 }
func +- (left: Vector2D, right: Vector2D) -> Vector2D { func +- (left: Vector2D, right: Vector2D) -> Vector2D {
return Vector2D(x: left.x + right.x, y: left.y - right.y) return Vector2D(x: left.x + right.x, y: left.y - right.y)
} }
let firstVector = Vector2D(x: 1.0, y: 2.0) let firstVector = Vector2D(x: 1.0, y: 2.0)
let secondVector = Vector2D(x: 3.0, y: 4.0) let secondVector = Vector2D(x: 3.0, y: 4.0)
let plusMinusVector = firstVector +- secondVector let plusMinusVector = firstVector +- secondVector
// plusMinusVector 此时的值为 (4.0, -2.0) // plusMinusVector 此时的值为 (4.0, -2.0)
``` ```
这个运算符把两个向量的`x`相加，把向量的`y`相减。因为他实际是属于加减运算，所以让它保持了和加法一样的结合性和优先级(`left`和`140`)。查阅完整的Swift默认结合性和优先级的设置，请移步[表达式](../chapter3/04_Expressions.html); 这个运算符把两个向量的`x`相加，把向量的`y`相减。因为他实际是属于加减运算，所以让它保持了和加法一样的结合性和优先级(`left`和`140`)。查阅完整的Swift默认结合性和优先级的设置，请移步[表达式](../chapter3/04_Expressions.html);

6
source/chapter2/chapter2.md
View File

@ -1,3 +1,3 @@
# Swift 教程 # Swift 教程
本章介绍了 Swift 的各种特性及其使用方法，是全书的核心部分。 本章介绍了 Swift 的各种特性及其使用方法，是全书的核心部分。

2
source/chapter3/01_About_the_Language_Reference.md
View File

@ -1,4 +1,4 @@
> 翻译：[dabing1022](https://github.com/dabing1022) > 翻译：[dabing1022](https://github.com/dabing1022)
> 校对：[numbbbbb](https://github.com/numbbbbb) > 校对：[numbbbbb](https://github.com/numbbbbb)

474
source/chapter3/02_Lexical_Structure.md
View File

@ -1,237 +1,237 @@
> 翻译：[superkam](https://github.com/superkam) > 翻译：[superkam](https://github.com/superkam)
> 校对：[numbbbbb](https://github.com/numbbbbb) > 校对：[numbbbbb](https://github.com/numbbbbb)
# 词法结构 # 词法结构
----------------- -----------------
本页包含内容： 本页包含内容：
- [空白与注释（*Whitespace and Comments*）](#whitespace_and_comments) - [空白与注释（*Whitespace and Comments*）](#whitespace_and_comments)
- [标识符（*Identifiers*）](#identifiers) - [标识符（*Identifiers*）](#identifiers)
- [关键字（*Keywords*）](#keywords) - [关键字（*Keywords*）](#keywords)
- [字面量（*Literals*）](#literals) - [字面量（*Literals*）](#literals)
- [运算符（*Operators*）](#operators) - [运算符（*Operators*）](#operators)
Swift 的“词法结构（*lexical structure*）”描述了如何在该语言中用字符序列构建合法标记，组成该语言中最底层的代码块，并在之后的章节中用于描述语言的其他部分。 Swift 的“词法结构（*lexical structure*）”描述了如何在该语言中用字符序列构建合法标记，组成该语言中最底层的代码块，并在之后的章节中用于描述语言的其他部分。
通常，标记在随后介绍的语法约束下，由 Swift 源文件的输入文本中提取可能的最长子串生成。这种方法称为“最长匹配项（*longest match*）”，或者“最大适合”（*maximal munch*）。 通常，标记在随后介绍的语法约束下，由 Swift 源文件的输入文本中提取可能的最长子串生成。这种方法称为“最长匹配项（*longest match*）”，或者“最大适合”（*maximal munch*）。
<a name="whitespace_and_comments"></a> <a name="whitespace_and_comments"></a>
## 空白与注释 ## 空白与注释
空白（*whitespace*）有两个用途：分隔源文件中的标记和区分运算符属于前缀还是后缀，（参见 [运算符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/doc/uid/TP40014097-CH30-XID_871)）在其他情况下则会被忽略。以下的字符会被当作空白：空格（*space*）（U+0020）、换行符（*line feed*）（U+000A）、回车符（*carriage return*）（U+000D）、水平 tab（*horizontal tab*）（U+0009）、垂直 tab（*vertical tab*）（U+000B）、换页符（*form feed*）（U+000C）以及空（*null*）（U+0000）。 空白（*whitespace*）有两个用途：分隔源文件中的标记和区分运算符属于前缀还是后缀，（参见 [运算符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/doc/uid/TP40014097-CH30-XID_871)）在其他情况下则会被忽略。以下的字符会被当作空白：空格（*space*）（U+0020）、换行符（*line feed*）（U+000A）、回车符（*carriage return*）（U+000D）、水平 tab（*horizontal tab*）（U+0009）、垂直 tab（*vertical tab*）（U+000B）、换页符（*form feed*）（U+000C）以及空（*null*）（U+0000）。
注释（*comments*）被编译器当作空白处理。单行注释由 `//` 开始直到该行结束。多行注释由 `/*` 开始，以 `*/` 结束。可以嵌套注释，但注意注释标记必须匹配。 注释（*comments*）被编译器当作空白处理。单行注释由 `//` 开始直到该行结束。多行注释由 `/*` 开始，以 `*/` 结束。可以嵌套注释，但注意注释标记必须匹配。
<a name="identifiers"></a> <a name="identifiers"></a>
## 标识符 ## 标识符
标识符（*identifiers*）可以由以下的字符开始：大写或小写的字母 `A` 到 `Z`、下划线 `_`、基本多语言面（*Basic Multilingual Plane*）中的 Unicode 非组合字符以及基本多语言面以外的非专用区（*Private Use Area*）字符。首字符之后，标识符允许使用数字和 Unicode 字符组合。 标识符（*identifiers*）可以由以下的字符开始：大写或小写的字母 `A` 到 `Z`、下划线 `_`、基本多语言面（*Basic Multilingual Plane*）中的 Unicode 非组合字符以及基本多语言面以外的非专用区（*Private Use Area*）字符。首字符之后，标识符允许使用数字和 Unicode 字符组合。
使用保留字（*reserved word*）作为标识符，需要在其前后增加反引号 <code>\`</code>。例如，<code>class</code> 不是合法的标识符，但可以使用 <code>\`class\`</code>。反引号不属于标识符的一部分，<code>\`x\`</code> 和 `x` 表示同一标识符。 使用保留字（*reserved word*）作为标识符，需要在其前后增加反引号 <code>\`</code>。例如，<code>class</code> 不是合法的标识符，但可以使用 <code>\`class\`</code>。反引号不属于标识符的一部分，<code>\`x\`</code> 和 `x` 表示同一标识符。
闭包（*closure*）中如果没有明确指定参数名称，参数将被隐式命名为 <code>$0</code>、<code>$1</code>、<code>$2</code>... 这些命名在闭包作用域内是合法的标识符。 闭包（*closure*）中如果没有明确指定参数名称，参数将被隐式命名为 <code>$0</code>、<code>$1</code>、<code>$2</code>... 这些命名在闭包作用域内是合法的标识符。
> 标识符语法 > 标识符语法
> *标识符* → [*标识符头(Head)*](LexicalStructure.html#identifier_head) [*标识符字符列表*](LexicalStructure.html#identifier_characters) _可选_ > *标识符* → [*标识符头(Head)*](LexicalStructure.html#identifier_head) [*标识符字符列表*](LexicalStructure.html#identifier_characters) _可选_
> *标识符* → **`** [*标识符头(Head)*](LexicalStructure.html#identifier_head) [*标识符字符列表*](LexicalStructure.html#identifier_characters) _可选_ **`** > *标识符* → **`** [*标识符头(Head)*](LexicalStructure.html#identifier_head) [*标识符字符列表*](LexicalStructure.html#identifier_characters) _可选_ **`**
> *标识符* → [*隐式参数名*](LexicalStructure.html#implicit_parameter_name) > *标识符* → [*隐式参数名*](LexicalStructure.html#implicit_parameter_name)
> *标识符列表* → [*标识符*](LexicalStructure.html#identifier) | [*标识符*](LexicalStructure.html#identifier) **,** [*标识符列表*](LexicalStructure.html#identifier_list) > *标识符列表* → [*标识符*](LexicalStructure.html#identifier) | [*标识符*](LexicalStructure.html#identifier) **,** [*标识符列表*](LexicalStructure.html#identifier_list)
> *标识符头(Head)* → Upper- or lowercase letter A through Z > *标识符头(Head)* → Upper- or lowercase letter A through Z
> *标识符头(Head)* → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, or U+00B7–U+00BA > *标识符头(Head)* → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, or U+00B7–U+00BA
> *标识符头(Head)* → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, or U+00F8–U+00FF > *标识符头(Head)* → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, or U+00F8–U+00FF
> *标识符头(Head)* → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, or U+180F–U+1DBF > *标识符头(Head)* → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, or U+180F–U+1DBF
> *标识符头(Head)* → U+1E00–U+1FFF > *标识符头(Head)* → U+1E00–U+1FFF
> *标识符头(Head)* → U+200B–U+200D, U+202A–U+202E, U+203F–U+2040, U+2054, or U+2060–U+206F > *标识符头(Head)* → U+200B–U+200D, U+202A–U+202E, U+203F–U+2040, U+2054, or U+2060–U+206F
> *标识符头(Head)* → U+2070–U+20CF, U+2100–U+218F, U+2460–U+24FF, or U+2776–U+2793 > *标识符头(Head)* → U+2070–U+20CF, U+2100–U+218F, U+2460–U+24FF, or U+2776–U+2793
> *标识符头(Head)* → U+2C00–U+2DFF or U+2E80–U+2FFF > *标识符头(Head)* → U+2C00–U+2DFF or U+2E80–U+2FFF
> *标识符头(Head)* → U+3004–U+3007, U+3021–U+302F, U+3031–U+303F, or U+3040–U+D7FF > *标识符头(Head)* → U+3004–U+3007, U+3021–U+302F, U+3031–U+303F, or U+3040–U+D7FF
> *标识符头(Head)* → U+F900–U+FD3D, U+FD40–U+FDCF, U+FDF0–U+FE1F, or U+FE30–U+FE44 > *标识符头(Head)* → U+F900–U+FD3D, U+FD40–U+FDCF, U+FDF0–U+FE1F, or U+FE30–U+FE44
> *标识符头(Head)* → U+FE47–U+FFFD > *标识符头(Head)* → U+FE47–U+FFFD
> *标识符头(Head)* → U+10000–U+1FFFD, U+20000–U+2FFFD, U+30000–U+3FFFD, or U+40000–U+4FFFD > *标识符头(Head)* → U+10000–U+1FFFD, U+20000–U+2FFFD, U+30000–U+3FFFD, or U+40000–U+4FFFD
> *标识符头(Head)* → U+50000–U+5FFFD, U+60000–U+6FFFD, U+70000–U+7FFFD, or U+80000–U+8FFFD > *标识符头(Head)* → U+50000–U+5FFFD, U+60000–U+6FFFD, U+70000–U+7FFFD, or U+80000–U+8FFFD
> *标识符头(Head)* → U+90000–U+9FFFD, U+A0000–U+AFFFD, U+B0000–U+BFFFD, or U+C0000–U+CFFFD > *标识符头(Head)* → U+90000–U+9FFFD, U+A0000–U+AFFFD, U+B0000–U+BFFFD, or U+C0000–U+CFFFD
> *标识符头(Head)* → U+D0000–U+DFFFD or U+E0000–U+EFFFD > *标识符头(Head)* → U+D0000–U+DFFFD or U+E0000–U+EFFFD
> *标识符字符* → 数值 0 到 9 > *标识符字符* → 数值 0 到 9
> *标识符字符* → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F > *标识符字符* → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F
> *标识符字符* → [*标识符头(Head)*](LexicalStructure.html#identifier_head) > *标识符字符* → [*标识符头(Head)*](LexicalStructure.html#identifier_head)
> *标识符字符列表* → [*标识符字符*](LexicalStructure.html#identifier_character) [*标识符字符列表*](LexicalStructure.html#identifier_characters) _可选_ > *标识符字符列表* → [*标识符字符*](LexicalStructure.html#identifier_character) [*标识符字符列表*](LexicalStructure.html#identifier_characters) _可选_
> *隐式参数名* → **$** [*十进制数字列表*](LexicalStructure.html#decimal_digits) > *隐式参数名* → **$** [*十进制数字列表*](LexicalStructure.html#decimal_digits)
<a name="keywords"></a> <a name="keywords"></a>
## 关键字 ## 关键字
被保留的关键字（*keywords*）不允许用作标识符，除非被反引号转义，参见 [标识符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/doc/uid/TP40014097-CH30-XID_796)。 被保留的关键字（*keywords*）不允许用作标识符，除非被反引号转义，参见 [标识符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/doc/uid/TP40014097-CH30-XID_796)。
* **用作声明的关键字：** *class*、*deinit*、*enum*、*extension*、*func*、*import*、*init*、*let*、*protocol*、*static*、*struct*、*subscript*、*typealias*、*var* * **用作声明的关键字：** *class*、*deinit*、*enum*、*extension*、*func*、*import*、*init*、*let*、*protocol*、*static*、*struct*、*subscript*、*typealias*、*var*
* **用作语句的关键字：** *break*、*case*、*continue*、*default*、*do*、*else*、*fallthrough*、*if*、*in*、*for*、*return*、*switch*、*where*、*while* * **用作语句的关键字：** *break*、*case*、*continue*、*default*、*do*、*else*、*fallthrough*、*if*、*in*、*for*、*return*、*switch*、*where*、*while*
* **用作表达和类型的关键字：** *as*、*dynamicType*、*is*、*new*、*super*、*self*、*Self*、*Type*、*\_\_COLUMN\_\_*、*\_\_FILE\_\_*、*\_\_FUNCTION\_\_*、*\_\_LINE\_\_* * **用作表达和类型的关键字：** *as*、*dynamicType*、*is*、*new*、*super*、*self*、*Self*、*Type*、*\_\_COLUMN\_\_*、*\_\_FILE\_\_*、*\_\_FUNCTION\_\_*、*\_\_LINE\_\_*
* **特定上下文中被保留的关键字：** *associativity*、*didSet*、*get*、*infix*、*inout*、*left*、*mutating*、*none*、*nonmutating*、*operator*、*override*、*postfix*、*precedence*、*prefix*、*right*、*set*、*unowned*、*unowned(safe)*、*unowned(unsafe)*、*weak*、*willSet*，这些关键字在特定上下文之外可以被用于标识符。 * **特定上下文中被保留的关键字：** *associativity*、*didSet*、*get*、*infix*、*inout*、*left*、*mutating*、*none*、*nonmutating*、*operator*、*override*、*postfix*、*precedence*、*prefix*、*right*、*set*、*unowned*、*unowned(safe)*、*unowned(unsafe)*、*weak*、*willSet*，这些关键字在特定上下文之外可以被用于标识符。
<a name="literals"></a> <a name="literals"></a>
## 字面量 ## 字面量
字面值表示整型、浮点型数字或文本类型的值，举例如下： 字面值表示整型、浮点型数字或文本类型的值，举例如下：
```swift ```swift
42 // 整型字面量 42 // 整型字面量
3.14159 // 浮点型字面量 3.14159 // 浮点型字面量
"Hello, world!" // 文本型字面量 "Hello, world!" // 文本型字面量
``` ```
> 字面量语法 > 字面量语法
> *字面量* → [*整型字面量*](LexicalStructure.html#integer_literal) | [*浮点数字面量*](LexicalStructure.html#floating_point_literal) | [*字符串字面量*](LexicalStructure.html#string_literal) > *字面量* → [*整型字面量*](LexicalStructure.html#integer_literal) | [*浮点数字面量*](LexicalStructure.html#floating_point_literal) | [*字符串字面量*](LexicalStructure.html#string_literal)
### 整型字面量 ### 整型字面量
整型字面量（*integer literals*）表示未指定精度整型数的值。整型字面量默认用十进制表示，可以加前缀来指定其他的进制，二进制字面量加 `0b`，八进制字面量加 `0o`，十六进制字面量加 `0x`。 整型字面量（*integer literals*）表示未指定精度整型数的值。整型字面量默认用十进制表示，可以加前缀来指定其他的进制，二进制字面量加 `0b`，八进制字面量加 `0o`，十六进制字面量加 `0x`。
十进制字面量包含数字 `0` 至 `9`。二进制字面量只包含 `0` 或 `1`，八进制字面量包含数字 `0` 至 `7`，十六进制字面量包含数字 `0` 至 `9` 以及字母 `A` 至 `F` （大小写均可）。 十进制字面量包含数字 `0` 至 `9`。二进制字面量只包含 `0` 或 `1`，八进制字面量包含数字 `0` 至 `7`，十六进制字面量包含数字 `0` 至 `9` 以及字母 `A` 至 `F` （大小写均可）。
负整数的字面量在数字前加减号 `-`，比如 `-42`。 负整数的字面量在数字前加减号 `-`，比如 `-42`。
允许使用下划线 `_` 来增加数字的可读性，下划线不会影响字面量的值。整型字面量也可以在数字前加 `0`，同样不会影响字面量的值。 允许使用下划线 `_` 来增加数字的可读性，下划线不会影响字面量的值。整型字面量也可以在数字前加 `0`，同样不会影响字面量的值。
```swift ```swift
1000_000 // 等于 1000000 1000_000 // 等于 1000000
005 // 等于 5 005 // 等于 5
``` ```
除非特殊指定，整型字面量的默认类型为 Swift 标准库类型中的 `Int`。Swift 标准库还定义了其他不同长度以及是否带符号的整数类型，请参考 [整数类型](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-XID_411)。 除非特殊指定，整型字面量的默认类型为 Swift 标准库类型中的 `Int`。Swift 标准库还定义了其他不同长度以及是否带符号的整数类型，请参考 [整数类型](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-XID_411)。
> 整型字面量语法 > 整型字面量语法
> *整型字面量* → [*二进制字面量*](LexicalStructure.html#binary_literal) > *整型字面量* → [*二进制字面量*](LexicalStructure.html#binary_literal)
> *整型字面量* → [*八进制字面量*](LexicalStructure.html#octal_literal) > *整型字面量* → [*八进制字面量*](LexicalStructure.html#octal_literal)
> *整型字面量* → [*十进制字面量*](LexicalStructure.html#decimal_literal) > *整型字面量* → [*十进制字面量*](LexicalStructure.html#decimal_literal)
> *整型字面量* → [*十六进制字面量*](LexicalStructure.html#hexadecimal_literal) > *整型字面量* → [*十六进制字面量*](LexicalStructure.html#hexadecimal_literal)
> *二进制字面量* → **0b** [*二进制数字*](LexicalStructure.html#binary_digit) [*二进制字面量字符列表*](LexicalStructure.html#binary_literal_characters) _可选_ > *二进制字面量* → **0b** [*二进制数字*](LexicalStructure.html#binary_digit) [*二进制字面量字符列表*](LexicalStructure.html#binary_literal_characters) _可选_
> *二进制数字* → 数值 0 到 1 > *二进制数字* → 数值 0 到 1
> *二进制字面量字符* → [*二进制数字*](LexicalStructure.html#binary_digit) | **_** > *二进制字面量字符* → [*二进制数字*](LexicalStructure.html#binary_digit) | **_**
> *二进制字面量字符列表* → [*二进制字面量字符*](LexicalStructure.html#binary_literal_character) [*二进制字面量字符列表*](LexicalStructure.html#binary_literal_characters) _可选_ > *二进制字面量字符列表* → [*二进制字面量字符*](LexicalStructure.html#binary_literal_character) [*二进制字面量字符列表*](LexicalStructure.html#binary_literal_characters) _可选_
> *八进制字面量* → **0o** [*八进字数字*](LexicalStructure.html#octal_digit) [*八进制字符列表*](LexicalStructure.html#octal_literal_characters) _可选_ > *八进制字面量* → **0o** [*八进字数字*](LexicalStructure.html#octal_digit) [*八进制字符列表*](LexicalStructure.html#octal_literal_characters) _可选_
> *八进字数字* → 数值 0 到 7 > *八进字数字* → 数值 0 到 7
> *八进制字符* → [*八进字数字*](LexicalStructure.html#octal_digit) | **_** > *八进制字符* → [*八进字数字*](LexicalStructure.html#octal_digit) | **_**
> *八进制字符列表* → [*八进制字符*](LexicalStructure.html#octal_literal_character) [*八进制字符列表*](LexicalStructure.html#octal_literal_characters) _可选_ > *八进制字符列表* → [*八进制字符*](LexicalStructure.html#octal_literal_character) [*八进制字符列表*](LexicalStructure.html#octal_literal_characters) _可选_
> *十进制字面量* → [*十进制数字*](LexicalStructure.html#decimal_digit) [*十进制字符列表*](LexicalStructure.html#decimal_literal_characters) _可选_ > *十进制字面量* → [*十进制数字*](LexicalStructure.html#decimal_digit) [*十进制字符列表*](LexicalStructure.html#decimal_literal_characters) _可选_
> *十进制数字* → 数值 0 到 9 > *十进制数字* → 数值 0 到 9
> *十进制数字列表* → [*十进制数字*](LexicalStructure.html#decimal_digit) [*十进制数字列表*](LexicalStructure.html#decimal_digits) _可选_ > *十进制数字列表* → [*十进制数字*](LexicalStructure.html#decimal_digit) [*十进制数字列表*](LexicalStructure.html#decimal_digits) _可选_
> *十进制字符* → [*十进制数字*](LexicalStructure.html#decimal_digit) | **_** > *十进制字符* → [*十进制数字*](LexicalStructure.html#decimal_digit) | **_**
> *十进制字符列表* → [*十进制字符*](LexicalStructure.html#decimal_literal_character) [*十进制字符列表*](LexicalStructure.html#decimal_literal_characters) _可选_ > *十进制字符列表* → [*十进制字符*](LexicalStructure.html#decimal_literal_character) [*十进制字符列表*](LexicalStructure.html#decimal_literal_characters) _可选_
> *十六进制字面量* → **0x** [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制字面量字符列表*](LexicalStructure.html#hexadecimal_literal_characters) _可选_ > *十六进制字面量* → **0x** [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制字面量字符列表*](LexicalStructure.html#hexadecimal_literal_characters) _可选_
> *十六进制数字* → 数值 0 到 9, a through f, or A through F > *十六进制数字* → 数值 0 到 9, a through f, or A through F
> *十六进制字符* → [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) | **_** > *十六进制字符* → [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) | **_**
> *十六进制字面量字符列表* → [*十六进制字符*](LexicalStructure.html#hexadecimal_literal_character) [*十六进制字面量字符列表*](LexicalStructure.html#hexadecimal_literal_characters) _可选_ > *十六进制字面量字符列表* → [*十六进制字符*](LexicalStructure.html#hexadecimal_literal_character) [*十六进制字面量字符列表*](LexicalStructure.html#hexadecimal_literal_characters) _可选_
### 浮点型字面量 ### 浮点型字面量
浮点型字面量（*floating-point literals*）表示未指定精度浮点数的值。 浮点型字面量（*floating-point literals*）表示未指定精度浮点数的值。
浮点型字面量默认用十进制表示（无前缀），也可以用十六进制表示（加前缀 `0x`）。 浮点型字面量默认用十进制表示（无前缀），也可以用十六进制表示（加前缀 `0x`）。
十进制浮点型字面量（*decimal floating-point literals*）由十进制数字串后跟小数部分或指数部分（或两者皆有）组成。十进制小数部分由小数点 `.` 后跟十进制数字串组成。指数部分由大写或小写字母 `e` 后跟十进制数字串组成，这串数字表示 `e` 之前的数量乘以 10 的几次方。例如：`1.25e2` 表示 `1.25 ⨉ 10^2`，也就是 `125.0`；同样，`1.25e－2` 表示 `1.25 ⨉ 10^－2`，也就是 `0.0125`。 十进制浮点型字面量（*decimal floating-point literals*）由十进制数字串后跟小数部分或指数部分（或两者皆有）组成。十进制小数部分由小数点 `.` 后跟十进制数字串组成。指数部分由大写或小写字母 `e` 后跟十进制数字串组成，这串数字表示 `e` 之前的数量乘以 10 的几次方。例如：`1.25e2` 表示 `1.25 ⨉ 10^2`，也就是 `125.0`；同样，`1.25e－2` 表示 `1.25 ⨉ 10^－2`，也就是 `0.0125`。
十六进制浮点型字面量（*hexadecimal floating-point literals*）由前缀 `0x` 后跟可选的十六进制小数部分以及十六进制指数部分组成。十六进制小数部分由小数点后跟十六进制数字串组成。指数部分由大写或小写字母 `p` 后跟十进制数字串组成，这串数字表示 `p` 之前的数量乘以 2 的几次方。例如：`0xFp2` 表示 `15 ⨉ 2^2`，也就是 `60`；同样，`0xFp-2` 表示 `15 ⨉ 2^-2`，也就是 `3.75`。 十六进制浮点型字面量（*hexadecimal floating-point literals*）由前缀 `0x` 后跟可选的十六进制小数部分以及十六进制指数部分组成。十六进制小数部分由小数点后跟十六进制数字串组成。指数部分由大写或小写字母 `p` 后跟十进制数字串组成，这串数字表示 `p` 之前的数量乘以 2 的几次方。例如：`0xFp2` 表示 `15 ⨉ 2^2`，也就是 `60`；同样，`0xFp-2` 表示 `15 ⨉ 2^-2`，也就是 `3.75`。
与整型字面量不同，负的浮点型字面量由一元运算符减号 `-` 和浮点型字面量组成，例如 `-42.0`。这代表一个表达式，而不是一个浮点整型字面量。 与整型字面量不同，负的浮点型字面量由一元运算符减号 `-` 和浮点型字面量组成，例如 `-42.0`。这代表一个表达式，而不是一个浮点整型字面量。
允许使用下划线 `_` 来增强可读性，下划线不会影响字面量的值。浮点型字面量也可以在数字前加 `0`，同样不会影响字面量的值。 允许使用下划线 `_` 来增强可读性，下划线不会影响字面量的值。浮点型字面量也可以在数字前加 `0`，同样不会影响字面量的值。
```swift ```swift
10_000.56 // 等于 10000.56 10_000.56 // 等于 10000.56
005000.76 // 等于 5000.76 005000.76 // 等于 5000.76
``` ```
除非特殊指定，浮点型字面量的默认类型为 Swift 标准库类型中的 `Double`，表示64位浮点数。Swift 标准库也定义 `Float` 类型，表示32位浮点数。 除非特殊指定，浮点型字面量的默认类型为 Swift 标准库类型中的 `Double`，表示64位浮点数。Swift 标准库也定义 `Float` 类型，表示32位浮点数。
> 浮点型字面量语法 > 浮点型字面量语法
> *浮点数字面量* → [*十进制字面量*](LexicalStructure.html#decimal_literal) [*十进制分数*](LexicalStructure.html#decimal_fraction) _可选_ [*十进制指数*](LexicalStructure.html#decimal_exponent) _可选_ > *浮点数字面量* → [*十进制字面量*](LexicalStructure.html#decimal_literal) [*十进制分数*](LexicalStructure.html#decimal_fraction) _可选_ [*十进制指数*](LexicalStructure.html#decimal_exponent) _可选_
> *浮点数字面量* → [*十六进制字面量*](LexicalStructure.html#hexadecimal_literal) [*十六进制分数*](LexicalStructure.html#hexadecimal_fraction) _可选_ [*十六进制指数*](LexicalStructure.html#hexadecimal_exponent) > *浮点数字面量* → [*十六进制字面量*](LexicalStructure.html#hexadecimal_literal) [*十六进制分数*](LexicalStructure.html#hexadecimal_fraction) _可选_ [*十六进制指数*](LexicalStructure.html#hexadecimal_exponent)
> *十进制分数* → **.** [*十进制字面量*](LexicalStructure.html#decimal_literal) > *十进制分数* → **.** [*十进制字面量*](LexicalStructure.html#decimal_literal)
> *十进制指数* → [*浮点数e*](LexicalStructure.html#floating_point_e) [*正负号*](LexicalStructure.html#sign) _可选_ [*十进制字面量*](LexicalStructure.html#decimal_literal) > *十进制指数* → [*浮点数e*](LexicalStructure.html#floating_point_e) [*正负号*](LexicalStructure.html#sign) _可选_ [*十进制字面量*](LexicalStructure.html#decimal_literal)
> *十六进制分数* → **.** [*十六进制字面量*](LexicalStructure.html#hexadecimal_literal) _可选_ > *十六进制分数* → **.** [*十六进制字面量*](LexicalStructure.html#hexadecimal_literal) _可选_
> *十六进制指数* → [*浮点数p*](LexicalStructure.html#floating_point_p) [*正负号*](LexicalStructure.html#sign) _可选_ [*十六进制字面量*](LexicalStructure.html#hexadecimal_literal) > *十六进制指数* → [*浮点数p*](LexicalStructure.html#floating_point_p) [*正负号*](LexicalStructure.html#sign) _可选_ [*十六进制字面量*](LexicalStructure.html#hexadecimal_literal)
> *浮点数e* → **e** | **E** > *浮点数e* → **e** | **E**
> *浮点数p* → **p** | **P** > *浮点数p* → **p** | **P**
> *正负号* → **+** | **-** > *正负号* → **+** | **-**
### 文本型字面量 ### 文本型字面量
文本型字面量（*string literal*）由双引号中的字符串组成，形式如下： 文本型字面量（*string literal*）由双引号中的字符串组成，形式如下：
```swift ```swift
"characters" "characters"
``` ```
文本型字面量中不能包含未转义的双引号 `"`、未转义的反斜线`\`、回车符（*carriage return*）或换行符（*line feed*）。 文本型字面量中不能包含未转义的双引号 `"`、未转义的反斜线`\`、回车符（*carriage return*）或换行符（*line feed*）。
可以在文本型字面量中使用的转义特殊符号如下： 可以在文本型字面量中使用的转义特殊符号如下：
* 空字符（Null Character）`\0` * 空字符（Null Character）`\0`
* 反斜线（Backslash）`\\` * 反斜线（Backslash）`\\`
* 水平 Tab （Horizontal Tab）`\t` * 水平 Tab （Horizontal Tab）`\t`
* 换行符（Line Feed）`\n` * 换行符（Line Feed）`\n`
* 回车符（Carriage Return）`\r` * 回车符（Carriage Return）`\r`
* 双引号（Double Quote）`\"` * 双引号（Double Quote）`\"`
* 单引号（Single Quote）`\'` * 单引号（Single Quote）`\'`
字符也可以用以下方式表示： 字符也可以用以下方式表示：
* `\x` 后跟两位十六进制数字 * `\x` 后跟两位十六进制数字
* `\u` 后跟四位十六进制数字 * `\u` 后跟四位十六进制数字
* `\U` 后跟八位十六进制数字 * `\U` 后跟八位十六进制数字
后跟的数字表示一个 Unicode 码点。 后跟的数字表示一个 Unicode 码点。
文本型字面量允许在反斜线小括号 `\()` 中插入表达式的值。插入表达式（*interpolated expression*）不能包含未转义的双引号 `"`、反斜线 `\`、回车符或者换行符。表达式值的类型必须在 *String* 类中有对应的初始化方法。 文本型字面量允许在反斜线小括号 `\()` 中插入表达式的值。插入表达式（*interpolated expression*）不能包含未转义的双引号 `"`、反斜线 `\`、回车符或者换行符。表达式值的类型必须在 *String* 类中有对应的初始化方法。
例如，以下所有文本型字面量的值相同： 例如，以下所有文本型字面量的值相同：
```swift ```swift
"1 2 3" "1 2 3"
"1 2 \(3)" "1 2 \(3)"
"1 2 \(1 + 2)" "1 2 \(1 + 2)"
var x = 3; "1 2 \(x)" var x = 3; "1 2 \(x)"
``` ```
文本型字面量的默认类型为 `String`。组成字符串的字符类型为 `Character`。更多有关 `String` 和 `Character` 的信息请参照 [字符串和字符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/StringsAndCharacters.html#//apple_ref/doc/uid/TP40014097-CH7-XID_368)。 文本型字面量的默认类型为 `String`。组成字符串的字符类型为 `Character`。更多有关 `String` 和 `Character` 的信息请参照 [字符串和字符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/StringsAndCharacters.html#//apple_ref/doc/uid/TP40014097-CH7-XID_368)。
> 字符型字面量语法 > 字符型字面量语法
> *字符串字面量* → **"** [*引用文本*](LexicalStructure.html#quoted_text) **"** > *字符串字面量* → **"** [*引用文本*](LexicalStructure.html#quoted_text) **"**
> *引用文本* → [*引用文本条目*](LexicalStructure.html#quoted_text_item) [*引用文本*](LexicalStructure.html#quoted_text) _可选_ > *引用文本* → [*引用文本条目*](LexicalStructure.html#quoted_text_item) [*引用文本*](LexicalStructure.html#quoted_text) _可选_
> *引用文本条目* → [*转义字符*](LexicalStructure.html#escaped_character) > *引用文本条目* → [*转义字符*](LexicalStructure.html#escaped_character)
> *引用文本条目* → **\(** [*表达式*](..\chapter3\04_Expressions.html#expression) **)** > *引用文本条目* → **\(** [*表达式*](..\chapter3\04_Expressions.html#expression) **)**
> *引用文本条目* → 除了"­, \­, U+000A, or U+000D的所有Unicode的字符 > *引用文本条目* → 除了"­, \­, U+000A, or U+000D的所有Unicode的字符
> *转义字符* → **\0** | **\\** | **\t** | **\n** | **\r** | **\"** | **\'** > *转义字符* → **\0** | **\\** | **\t** | **\n** | **\r** | **\"** | **\'**
> *转义字符* → **\x** [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) > *转义字符* → **\x** [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit)
> *转义字符* → **\u** [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) > *转义字符* → **\u** [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit)
> *转义字符* → **\U** [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) > *转义字符* → **\U** [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit)
<a name="operators"></a> <a name="operators"></a>
## 运算符 ## 运算符
Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基础运算符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/BasicOperators.html#//apple_ref/doc/uid/TP40014097-CH6-XID_70) 和 [高级运算符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_28) 中进行了阐述。这里将描述哪些字符能用作运算符。 Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基础运算符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/BasicOperators.html#//apple_ref/doc/uid/TP40014097-CH6-XID_70) 和 [高级运算符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_28) 中进行了阐述。这里将描述哪些字符能用作运算符。
运算符由一个或多个以下字符组成： 运算符由一个或多个以下字符组成：
`/`、`=`、`-`、`+`、`!`、`*`、`%`、`<`、`>`、`&`、`|`、`^`、`~`、`.`。也就是说，标记 `=`, `->`、`//`、`/*`、`*/`、`.` 以及一元前缀运算符 `&` 属于保留字，这些标记不能被重写或用于自定义运算符。 `/`、`=`、`-`、`+`、`!`、`*`、`%`、`<`、`>`、`&`、`|`、`^`、`~`、`.`。也就是说，标记 `=`, `->`、`//`、`/*`、`*/`、`.` 以及一元前缀运算符 `&` 属于保留字，这些标记不能被重写或用于自定义运算符。
运算符两侧的空白被用来区分该运算符是否为前缀运算符（*prefix operator*）、后缀运算符（*postfix operator*）或二元运算符（*binary operator*）。规则总结如下： 运算符两侧的空白被用来区分该运算符是否为前缀运算符（*prefix operator*）、后缀运算符（*postfix operator*）或二元运算符（*binary operator*）。规则总结如下：
* 如果运算符两侧都有空白或两侧都无空白，将被看作二元运算符。例如：`a+b` 和 `a + b` 中的运算符 `+` 被看作二元运算符。 * 如果运算符两侧都有空白或两侧都无空白，将被看作二元运算符。例如：`a+b` 和 `a + b` 中的运算符 `+` 被看作二元运算符。
* 如果运算符只有左侧空白，将被看作前缀一元运算符。例如 `a ++b` 中的 `++` 被看作前缀一元运算符。 * 如果运算符只有左侧空白，将被看作前缀一元运算符。例如 `a ++b` 中的 `++` 被看作前缀一元运算符。
* 如果运算符只有右侧空白，将被看作后缀一元运算符。例如 `a++ b` 中的 `++` 被看作后缀一元运算符。 * 如果运算符只有右侧空白，将被看作后缀一元运算符。例如 `a++ b` 中的 `++` 被看作后缀一元运算符。
* 如果运算符左侧没有空白并紧跟 `.`，将被看作后缀一元运算符。例如 `a++.b` 中的 `++` 被看作后缀一元运算符（同理， `a++ . b` 中的 `++` 是后缀一元运算符而 `a ++ .b` 中的 `++` 不是）. * 如果运算符左侧没有空白并紧跟 `.`，将被看作后缀一元运算符。例如 `a++.b` 中的 `++` 被看作后缀一元运算符（同理， `a++ . b` 中的 `++` 是后缀一元运算符而 `a ++ .b` 中的 `++` 不是）.
鉴于这些规则，运算符前的字符 `(`、`[` 和 `{` ；运算符后的字符 `)`、`]` 和 `}` 以及字符 `,`、`;` 和 `:` 都将用于空白检测。 鉴于这些规则，运算符前的字符 `(`、`[` 和 `{` ；运算符后的字符 `)`、`]` 和 `}` 以及字符 `,`、`;` 和 `:` 都将用于空白检测。
以上规则需注意一点，如果运算符 `!` 或 `?` 左侧没有空白，则不管右侧是否有空白都将被看作后缀运算符。如果将 `?` 用作可选类型（*optional type*）修饰，左侧必须无空白。如果用于条件运算符 `? :`，必须两侧都有空白。 以上规则需注意一点，如果运算符 `!` 或 `?` 左侧没有空白，则不管右侧是否有空白都将被看作后缀运算符。如果将 `?` 用作可选类型（*optional type*）修饰，左侧必须无空白。如果用于条件运算符 `? :`，必须两侧都有空白。
在特定构成中 ，以 `<` 或 `>` 开头的运算符会被分离成两个或多个标记，剩余部分以同样的方式会被再次分离。因此，在 `Dictionary<String, Array<Int>>` 中没有必要添加空白来消除闭合字符 `>` 的歧义。在这个例子中， 闭合字符 `>` 被看作单字符标记，而不会被误解为移位运算符 `>>`。 在特定构成中 ，以 `<` 或 `>` 开头的运算符会被分离成两个或多个标记，剩余部分以同样的方式会被再次分离。因此，在 `Dictionary<String, Array<Int>>` 中没有必要添加空白来消除闭合字符 `>` 的歧义。在这个例子中， 闭合字符 `>` 被看作单字符标记，而不会被误解为移位运算符 `>>`。
要学习如何自定义新的运算符，请参考 [自定义操作符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_48) 和 [运算符声明](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/doc/uid/TP40014097-CH34-XID_644)。学习如何重写现有运算符，请参考 [运算符方法](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_43)。 要学习如何自定义新的运算符，请参考 [自定义操作符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_48) 和 [运算符声明](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/doc/uid/TP40014097-CH34-XID_644)。学习如何重写现有运算符，请参考 [运算符方法](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_43)。
> 运算符语法语法 > 运算符语法语法
> *运算符* → [*运算符字符*](LexicalStructure.html#operator_character) [*运算符*](LexicalStructure.html#operator) _可选_ > *运算符* → [*运算符字符*](LexicalStructure.html#operator_character) [*运算符*](LexicalStructure.html#operator) _可选_
> *运算符字符* → **/** | **=** | **-** | **+** | **!** | **&#42;** | **%** | **<** | **>** | **&** | **|** | **^** | **~** | **.** > *运算符字符* → **/** | **=** | **-** | **+** | **!** | **&#42;** | **%** | **<** | **>** | **&** | **|** | **^** | **~** | **.**
> *二元运算符* → [*运算符*](LexicalStructure.html#operator) > *二元运算符* → [*运算符*](LexicalStructure.html#operator)
> *前置运算符* → [*运算符*](LexicalStructure.html#operator) > *前置运算符* → [*运算符*](LexicalStructure.html#operator)
> *后置运算符* → [*运算符*](LexicalStructure.html#operator) > *后置运算符* → [*运算符*](LexicalStructure.html#operator)

600
source/chapter3/03_Types.md
View File

@ -1,300 +1,300 @@
> 翻译：[lyuka](https://github.com/lyuka) > 翻译：[lyuka](https://github.com/lyuka)
> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai) > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
# 类型（Types） # 类型（Types）
----------------- -----------------
本页包含内容： 本页包含内容：
- [类型注解（Type Annotation）](#type_annotation) - [类型注解（Type Annotation）](#type_annotation)
- [类型标识符（Type Identifier）](#type_identifier) - [类型标识符（Type Identifier）](#type_identifier)
- [元组类型（Tuple Type）](#tuple_type) - [元组类型（Tuple Type）](#tuple_type)
- [函数类型（Function Type）](#function_type) - [函数类型（Function Type）](#function_type)
- [数组类型（Array Type）](#array_type) - [数组类型（Array Type）](#array_type)
- [可选类型（Optional Type）](#optional_type) - [可选类型（Optional Type）](#optional_type)
- [隐式解析可选类型（Implicitly Unwrapped Optional Type）](#implicitly_unwrapped_optional_type) - [隐式解析可选类型（Implicitly Unwrapped Optional Type）](#implicitly_unwrapped_optional_type)
- [协议合成类型（Protocol Composition Type）](#protocol_composition_type) - [协议合成类型（Protocol Composition Type）](#protocol_composition_type)
- [元类型（Metatype Type）](#metatype_type) - [元类型（Metatype Type）](#metatype_type)
- [类型继承子句（Type Inheritance Clause）](#type_inheritance_clause) - [类型继承子句（Type Inheritance Clause）](#type_inheritance_clause)
- [类型推断（Type Inference）](#type_inference) - [类型推断（Type Inference）](#type_inference)
Swift 语言存在两种类型：命名型类型和复合型类型。*命名型类型*是指定义时可以给定名字的类型。命名型类型包括类、结构体、枚举和协议。比如，一个用户定义的类`MyClass`的实例拥有类型`MyClass`。除了用户定义的命名型类型，Swift 标准库也定义了很多常用的命名型类型，包括那些表示数组、字典和可选值的类型。 Swift 语言存在两种类型：命名型类型和复合型类型。*命名型类型*是指定义时可以给定名字的类型。命名型类型包括类、结构体、枚举和协议。比如，一个用户定义的类`MyClass`的实例拥有类型`MyClass`。除了用户定义的命名型类型，Swift 标准库也定义了很多常用的命名型类型，包括那些表示数组、字典和可选值的类型。
那些通常被其它语言认为是基本或初级的数据型类型（Data types）——比如表示数字、字符和字符串——实际上就是命名型类型，Swift 标准库是使用结构体定义和实现它们的。因为它们是命名型类型，因此你可以按照“扩展和扩展声明”章节里讨论的那样，声明一个扩展来增加它们的行为以适应你程序的需求。 那些通常被其它语言认为是基本或初级的数据型类型（Data types）——比如表示数字、字符和字符串——实际上就是命名型类型，Swift 标准库是使用结构体定义和实现它们的。因为它们是命名型类型，因此你可以按照“扩展和扩展声明”章节里讨论的那样，声明一个扩展来增加它们的行为以适应你程序的需求。
*复合型类型*是没有名字的类型，它由 Swift 本身定义。Swift 存在两种复合型类型：函数类型和元组类型。一个复合型类型可以包含命名型类型和其它复合型类型。例如，元组类型`(Int, (Int, Int))`包含两个元素：第一个是命名型类型`Int`，第二个是另一个复合型类型`(Int, Int)`. *复合型类型*是没有名字的类型，它由 Swift 本身定义。Swift 存在两种复合型类型：函数类型和元组类型。一个复合型类型可以包含命名型类型和其它复合型类型。例如，元组类型`(Int, (Int, Int))`包含两个元素：第一个是命名型类型`Int`，第二个是另一个复合型类型`(Int, Int)`.
本节讨论 Swift 语言本身定义的类型，并描述 Swift 中的类型推断行为。 本节讨论 Swift 语言本身定义的类型，并描述 Swift 中的类型推断行为。
> 类型语法 > 类型语法
> *类型* → [*数组类型*](..\chapter3\03_Types.html#array_type) | [*函数类型*](..\chapter3\03_Types.html#function_type) | [*类型标识*](..\chapter3\03_Types.html#type_identifier) | [*元组类型*](..\chapter3\03_Types.html#tuple_type) | [*可选类型*](..\chapter3\03_Types.html#optional_type) | [*隐式解析可选类型*](..\chapter3\03_Types.html#implicitly_unwrapped_optional_type) | [*协议合成类型*](..\chapter3\03_Types.html#protocol_composition_type) | [*元型类型*](..\chapter3\03_Types.html#metatype_type) > *类型* → [*数组类型*](..\chapter3\03_Types.html#array_type) | [*函数类型*](..\chapter3\03_Types.html#function_type) | [*类型标识*](..\chapter3\03_Types.html#type_identifier) | [*元组类型*](..\chapter3\03_Types.html#tuple_type) | [*可选类型*](..\chapter3\03_Types.html#optional_type) | [*隐式解析可选类型*](..\chapter3\03_Types.html#implicitly_unwrapped_optional_type) | [*协议合成类型*](..\chapter3\03_Types.html#protocol_composition_type) | [*元型类型*](..\chapter3\03_Types.html#metatype_type)
<a name="type_annotation"></a> <a name="type_annotation"></a>
##类型注解 ##类型注解
类型注解显式地指定一个变量或表达式的值。类型注解始于冒号`:`终于类型，比如下面两个例子： 类型注解显式地指定一个变量或表达式的值。类型注解始于冒号`:`终于类型，比如下面两个例子：
```swift ```swift
let someTuple：(Double, Double) = (3.14159, 2.71828) let someTuple: (Double, Double) = (3.14159, 2.71828)
func someFunction(a: Int){ /* ... */ } func someFunction(a: Int){ /* ... */ }
``` ```
在第一个例子中，表达式`someTuple`的类型被指定为`(Double, Double)`。在第二个例子中，函数`someFunction`的参数`a`的类型被指定为`Int`。 在第一个例子中，表达式`someTuple`的类型被指定为`(Double, Double)`。在第二个例子中，函数`someFunction`的参数`a`的类型被指定为`Int`。
类型注解可以在类型之前包含一个类型特性（type attributes）的可选列表。 类型注解可以在类型之前包含一个类型特性（type attributes）的可选列表。
> 类型注解语法 > 类型注解语法
> *类型注解* → **:** [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type) > *类型注解* → **:** [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)
<a name="type_identifier"></a> <a name="type_identifier"></a>
##类型标识符 ##类型标识符
类型标识符引用命名型类型或者是命名型/复合型类型的别名。 类型标识符引用命名型类型或者是命名型/复合型类型的别名。
大多数情况下，类型标识符引用的是同名的命名型类型。例如类型标识符`Int`引用命名型类型`Int`，同样，类型标识符`Dictionary<String, Int>`引用命名型类型`Dictionary<String, Int>`。 大多数情况下，类型标识符引用的是同名的命名型类型。例如类型标识符`Int`引用命名型类型`Int`，同样，类型标识符`Dictionary<String, Int>`引用命名型类型`Dictionary<String, Int>`。
在两种情况下类型标识符引用的不是同名的类型。情况一，类型标识符引用的是命名型/复合型类型的类型别名。比如，在下面的例子中，类型标识符使用`Point`来引用元组`(Int, Int)`： 在两种情况下类型标识符引用的不是同名的类型。情况一，类型标识符引用的是命名型/复合型类型的类型别名。比如，在下面的例子中，类型标识符使用`Point`来引用元组`(Int, Int)`：
```swift ```swift
typealias Point = (Int, Int) typealias Point = (Int, Int)
let origin: Point = (0, 0) let origin: Point = (0, 0)
``` ```
情况二，类型标识符使用dot(`.`)语法来表示在其它模块（modules）或其它类型嵌套内声明的命名型类型。例如，下面例子中的类型标识符引用在`ExampleModule`模块中声明的命名型类型`MyType`： 情况二，类型标识符使用dot(`.`)语法来表示在其它模块（modules）或其它类型嵌套内声明的命名型类型。例如，下面例子中的类型标识符引用在`ExampleModule`模块中声明的命名型类型`MyType`：
```swift ```swift
var someValue: ExampleModule.MyType var someValue: ExampleModule.MyType
``` ```
> 类型标识语法 > 类型标识语法
> *类型标识* → [*类型名称*](..\chapter3\03_Types.html#type_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ | [*类型名称*](..\chapter3\03_Types.html#type_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ **.** [*类型标识*](..\chapter3\03_Types.html#type_identifier) > *类型标识* → [*类型名称*](..\chapter3\03_Types.html#type_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ | [*类型名称*](..\chapter3\03_Types.html#type_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ **.** [*类型标识*](..\chapter3\03_Types.html#type_identifier)
> *类名* → [*标识符*](LexicalStructure.html#identifier) > *类名* → [*标识符*](LexicalStructure.html#identifier)
<a name="tuple_type"></a> <a name="tuple_type"></a>
##元组类型 ##元组类型
元组类型使用逗号隔开并使用括号括起来的0个或多个类型组成的列表。 元组类型使用逗号隔开并使用括号括起来的0个或多个类型组成的列表。
你可以使用元组类型作为一个函数的返回类型，这样就可以使函数返回多个值。你也可以命名元组类型中的元素，然后用这些名字来引用每个元素的值。元素的名字由一个标识符和`:`组成。“函数和多返回值”章节里有一个展示上述特性的例子。 你可以使用元组类型作为一个函数的返回类型，这样就可以使函数返回多个值。你也可以命名元组类型中的元素，然后用这些名字来引用每个元素的值。元素的名字由一个标识符和`:`组成。“函数和多返回值”章节里有一个展示上述特性的例子。
`void`是空元组类型`()`的别名。如果括号内只有一个元素，那么该类型就是括号内元素的类型。比如，`(Int)`的类型是`Int`而不是`(Int)`。所以，只有当元组类型包含两个元素以上时才可以标记元组元素。 `void`是空元组类型`()`的别名。如果括号内只有一个元素，那么该类型就是括号内元素的类型。比如，`(Int)`的类型是`Int`而不是`(Int)`。所以，只有当元组类型包含两个元素以上时才可以标记元组元素。
> 元组类型语法 > 元组类型语法
> *元组类型* → **(** [*元组类型主体*](..\chapter3\03_Types.html#tuple_type_body) _可选_ **)** > *元组类型* → **(** [*元组类型主体*](..\chapter3\03_Types.html#tuple_type_body) _可选_ **)**
> *元组类型主体* → [*元组类型的元素列表*](..\chapter3\03_Types.html#tuple_type_element_list) **...** _可选_ > *元组类型主体* → [*元组类型的元素列表*](..\chapter3\03_Types.html#tuple_type_element_list) **...** _可选_
> *元组类型的元素列表* → [*元组类型的元素*](..\chapter3\03_Types.html#tuple_type_element) | [*元组类型的元素*](..\chapter3\03_Types.html#tuple_type_element) **,** [*元组类型的元素列表*](..\chapter3\03_Types.html#tuple_type_element_list) > *元组类型的元素列表* → [*元组类型的元素*](..\chapter3\03_Types.html#tuple_type_element) | [*元组类型的元素*](..\chapter3\03_Types.html#tuple_type_element) **,** [*元组类型的元素列表*](..\chapter3\03_Types.html#tuple_type_element_list)
> *元组类型的元素* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **inout** _可选_ [*类型*](..\chapter3\03_Types.html#type) | **inout** _可选_ [*元素名*](..\chapter3\03_Types.html#element_name) [*类型注解*](..\chapter3\03_Types.html#type_annotation) > *元组类型的元素* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **inout** _可选_ [*类型*](..\chapter3\03_Types.html#type) | **inout** _可选_ [*元素名*](..\chapter3\03_Types.html#element_name) [*类型注解*](..\chapter3\03_Types.html#type_annotation)
> *元素名* → [*标识符*](LexicalStructure.html#identifier) > *元素名* → [*标识符*](LexicalStructure.html#identifier)
<a name="function_type"></a> <a name="function_type"></a>
##函数类型 ##函数类型
函数类型表示一个函数、方法或闭包的类型，它由一个参数类型和返回值类型组成，中间用箭头`->`隔开： 函数类型表示一个函数、方法或闭包的类型，它由一个参数类型和返回值类型组成，中间用箭头`->`隔开：
- `parameter type` -> `return type` - `parameter type` -> `return type`
由于 *参数类型* 和 *返回值类型* 可以是元组类型，所以函数类型可以让函数与方法支持多参数与多返回值。 由于 *参数类型* 和 *返回值类型* 可以是元组类型，所以函数类型可以让函数与方法支持多参数与多返回值。
你可以对函数类型应用带有参数类型`()`并返回表达式类型的`auto_closure`属性（见类型属性章节）。一个自动闭包函数捕获特定表达式上的隐式闭包而非表达式本身。下面的例子使用`auto_closure`属性来定义一个很简单的assert函数： 你可以对函数类型应用带有参数类型`()`并返回表达式类型的`auto_closure`属性（见类型属性章节）。一个自动闭包函数捕获特定表达式上的隐式闭包而非表达式本身。下面的例子使用`auto_closure`属性来定义一个很简单的assert函数：
```swift ```swift
func simpleAssert(condition: @auto_closure () -> Bool, message: String){ func simpleAssert(condition: @auto_closure () -> Bool, message: String){
if !condition(){ if !condition(){
println(message) println(message)
} }
} }
let testNumber = 5 let testNumber = 5
simpleAssert(testNumber % 2 == 0, "testNumber isn't an even number.") simpleAssert(testNumber % 2 == 0, "testNumber isn't an even number.")
// prints "testNumber isn't an even number." // prints "testNumber isn't an even number."
``` ```
函数类型可以拥有一个可变长参数作为参数类型中的最后一个参数。从语法角度上讲，可变长参数由一个基础类型名字和`...`组成，如`Int...`。可变长参数被认为是一个包含了基础类型元素的数组。即`Int...`就是`Int[]`。关于使用可变长参数的例子，见章节“可变长参数”。 函数类型可以拥有一个可变长参数作为参数类型中的最后一个参数。从语法角度上讲，可变长参数由一个基础类型名字和`...`组成，如`Int...`。可变长参数被认为是一个包含了基础类型元素的数组。即`Int...`就是`Int[]`。关于使用可变长参数的例子，见章节“可变长参数”。
为了指定一个`in-out`参数，可以在参数类型前加`inout`前缀。但是你不可以对可变长参数或返回值类型使用`inout`。关于In-Out参数的讨论见章节In-Out参数部分。 为了指定一个`in-out`参数，可以在参数类型前加`inout`前缀。但是你不可以对可变长参数或返回值类型使用`inout`。关于In-Out参数的讨论见章节In-Out参数部分。
柯里化函数（curried function）的类型相当于一个嵌套函数类型。例如，下面的柯里化函数`addTwoNumber()()`的类型是`Int -> Int -> Int`： 柯里化函数（curried function）的类型相当于一个嵌套函数类型。例如，下面的柯里化函数`addTwoNumber()()`的类型是`Int -> Int -> Int`：
```swift ```swift
func addTwoNumbers(a: Int)(b: Int) -> Int{ func addTwoNumbers(a: Int)(b: Int) -> Int{
return a + b return a + b
} }
addTwoNumbers(4)(5) // returns 9 addTwoNumbers(4)(5) // returns 9
``` ```
柯里化函数的函数类型从右向左组成一组。例如，函数类型`Int -> Int -> Int`可以被理解为`Int -> (Int -> Int)`——也就是说，一个函数传入一个`Int`然后输出作为另一个函数的输入，然后又返回一个`Int`。例如，你可以使用如下嵌套函数来重写柯里化函数`addTwoNumbers()()`： 柯里化函数的函数类型从右向左组成一组。例如，函数类型`Int -> Int -> Int`可以被理解为`Int -> (Int -> Int)`——也就是说，一个函数传入一个`Int`然后输出作为另一个函数的输入，然后又返回一个`Int`。例如，你可以使用如下嵌套函数来重写柯里化函数`addTwoNumbers()()`：
```swift ```swift
func addTwoNumbers(a: Int) -> (Int -> Int){ func addTwoNumbers(a: Int) -> (Int -> Int){
func addTheSecondNumber(b: Int) -> Int{ func addTheSecondNumber(b: Int) -> Int{
return a + b return a + b
} }
return addTheSecondNumber return addTheSecondNumber
} }
addTwoNumbers(4)(5) // Returns 9 addTwoNumbers(4)(5) // Returns 9
``` ```
> 函数类型语法 > 函数类型语法
> *函数类型* → [*类型*](..\chapter3\03_Types.html#type) **->** [*类型*](..\chapter3\03_Types.html#type) > *函数类型* → [*类型*](..\chapter3\03_Types.html#type) **->** [*类型*](..\chapter3\03_Types.html#type)
<a name="array_type"></a> <a name="array_type"></a>
##数组类型 ##数组类型
Swift语言使用类型名紧接中括号`[]`来简化标准库中定义的命名型类型`Array<T>`。换句话说，下面两个声明是等价的： Swift语言使用类型名紧接中括号`[]`来简化标准库中定义的命名型类型`Array<T>`。换句话说，下面两个声明是等价的：
```swift ```swift
let someArray: String[] = ["Alex", "Brian", "Dave"] let someArray: String[] = ["Alex", "Brian", "Dave"]
let someArray: Array<String> = ["Alex", "Brian", "Dave"] let someArray: Array<String> = ["Alex", "Brian", "Dave"]
``` ```
上面两种情况下，常量`someArray`都被声明为字符串数组。数组的元素也可以通过`[]`获取访问：`someArray[0]`是指第0个元素`“Alex”`。 上面两种情况下，常量`someArray`都被声明为字符串数组。数组的元素也可以通过`[]`获取访问：`someArray[0]`是指第0个元素`“Alex”`。
上面的例子同时显示，你可以使用`[]`作为初始值构造数组，空的`[]`则用来来构造指定类型的空数组。 上面的例子同时显示，你可以使用`[]`作为初始值构造数组，空的`[]`则用来来构造指定类型的空数组。
```swift ```swift
var emptyArray: Double[] = [] var emptyArray: Double[] = []
``` ```
你也可以使用链接起来的多个`[]`集合来构造多维数组。例如，下例使用三个`[]`集合来构造三维整型数组： 你也可以使用链接起来的多个`[]`集合来构造多维数组。例如，下例使用三个`[]`集合来构造三维整型数组：
```swift ```swift
var array3D: Int[][][] = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]] var array3D: Int[][][] = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
``` ```
访问一个多维数组的元素时，最左边的下标指向最外层数组的相应位置元素。接下来往右的下标指向第一层嵌入的相应位置元素，依次类推。这就意味着，在上面的例子中，`array3D[0]`是指`[[1, 2], [3, 4]]`，`array3D[0][1]`是指`[3, 4]`，`array3D[0][1][1]`则是指值`4`。 访问一个多维数组的元素时，最左边的下标指向最外层数组的相应位置元素。接下来往右的下标指向第一层嵌入的相应位置元素，依次类推。这就意味着，在上面的例子中，`array3D[0]`是指`[[1, 2], [3, 4]]`，`array3D[0][1]`是指`[3, 4]`，`array3D[0][1][1]`则是指值`4`。
关于Swift标准库中`Array`类型的细节讨论，见章节Arrays。 关于Swift标准库中`Array`类型的细节讨论，见章节Arrays。
> 数组类型语法 > 数组类型语法
> *数组类型* → [*类型*](..\chapter3\03_Types.html#type) **[** **]** | [*数组类型*](..\chapter3\03_Types.html#array_type) **[** **]** > *数组类型* → [*类型*](..\chapter3\03_Types.html#type) **[** **]** | [*数组类型*](..\chapter3\03_Types.html#array_type) **[** **]**
<a name="optional_type"></a> <a name="optional_type"></a>
##可选类型 ##可选类型
Swift定义后缀`?`来作为标准库中的定义的命名型类型`Optional<T>`的简写。换句话说，下面两个声明是等价的： Swift定义后缀`?`来作为标准库中的定义的命名型类型`Optional<T>`的简写。换句话说，下面两个声明是等价的：
```swift ```swift
var optionalInteger: Int? var optionalInteger: Int?
var optionalInteger: Optional<Int> var optionalInteger: Optional<Int>
``` ```
在上述两种情况下，变量`optionalInteger`都被声明为可选整型类型。注意在类型和`?`之间没有空格。 在上述两种情况下，变量`optionalInteger`都被声明为可选整型类型。注意在类型和`?`之间没有空格。
类型`Optional<T>`是一个枚举，有两种形式，`None`和`Some(T)`，又来代表可能出现或可能不出现的值。任意类型都可以被显式的声明（或隐式的转换）为可选类型。当声明一个可选类型时，确保使用括号给`?`提供合适的作用范围。比如说，声明一个整型的可选数组，应写作`(Int[])?`，写成`Int[]?`的话则会出错。 类型`Optional<T>`是一个枚举，有两种形式，`None`和`Some(T)`，又来代表可能出现或可能不出现的值。任意类型都可以被显式的声明（或隐式的转换）为可选类型。当声明一个可选类型时，确保使用括号给`?`提供合适的作用范围。比如说，声明一个整型的可选数组，应写作`(Int[])?`，写成`Int[]?`的话则会出错。
如果你在声明或定义可选变量或特性的时候没有提供初始值，它的值则会自动赋成缺省值`nil`。 如果你在声明或定义可选变量或特性的时候没有提供初始值，它的值则会自动赋成缺省值`nil`。
可选符合`LogicValue`协议，因此可以出现在布尔值环境下。此时，如果一个可选类型`T?`实例包含有类型为`T`的值（也就是说值为`Optional.Some(T)`），那么此可选类型就为`true`，否则为`false`。 可选符合`LogicValue`协议，因此可以出现在布尔值环境下。此时，如果一个可选类型`T?`实例包含有类型为`T`的值（也就是说值为`Optional.Some(T)`），那么此可选类型就为`true`，否则为`false`。
如果一个可选类型的实例包含一个值，那么你就可以使用后缀操作符`!`来获取该值，正如下面描述的： 如果一个可选类型的实例包含一个值，那么你就可以使用后缀操作符`!`来获取该值，正如下面描述的：
```swift ```swift
optionalInteger = 42 optionalInteger = 42
optionalInteger! // 42 optionalInteger! // 42
``` ```
使用`!`操作符获取值为`nil`的可选项会导致运行错误（runtime error）。 使用`!`操作符获取值为`nil`的可选项会导致运行错误（runtime error）。
你也可以使用可选链和可选绑定来选择性的执行可选表达式上的操作。如果值为`nil`，不会执行任何操作因此也就没有运行错误产生。 你也可以使用可选链和可选绑定来选择性的执行可选表达式上的操作。如果值为`nil`，不会执行任何操作因此也就没有运行错误产生。
更多细节以及更多如何使用可选类型的例子，见章节“可选”。 更多细节以及更多如何使用可选类型的例子，见章节“可选”。
> 可选类型语法 > 可选类型语法
> *可选类型* → [*类型*](..\chapter3\03_Types.html#type) **?** > *可选类型* → [*类型*](..\chapter3\03_Types.html#type) **?**
<a name="implicitly_unwrapped_optional_type"></a> <a name="implicitly_unwrapped_optional_type"></a>
##隐式解析可选类型 ##隐式解析可选类型
Swift语言定义后缀`!`作为标准库中命名类型`ImplicitlyUnwrappedOptional<T>`的简写。换句话说，下面两个声明等价： Swift语言定义后缀`!`作为标准库中命名类型`ImplicitlyUnwrappedOptional<T>`的简写。换句话说，下面两个声明等价：
```swift ```swift
var implicitlyUnwrappedString: String! var implicitlyUnwrappedString: String!
var implicitlyUnwrappedString: ImplicitlyUnwrappedOptional<String> var implicitlyUnwrappedString: ImplicitlyUnwrappedOptional<String>
``` ```
上述两种情况下，变量`implicitlyUnwrappedString`被声明为一个隐式解析可选类型的字符串。注意类型与`!`之间没有空格。 上述两种情况下，变量`implicitlyUnwrappedString`被声明为一个隐式解析可选类型的字符串。注意类型与`!`之间没有空格。
你可以在使用可选的地方同样使用隐式解析可选。比如，你可以将隐式解析可选的值赋给变量、常量和可选特性，反之亦然。 你可以在使用可选的地方同样使用隐式解析可选。比如，你可以将隐式解析可选的值赋给变量、常量和可选特性，反之亦然。
有了可选，你在声明隐式解析可选变量或特性的时候就不用指定初始值，因为它有缺省值`nil`。 有了可选，你在声明隐式解析可选变量或特性的时候就不用指定初始值，因为它有缺省值`nil`。
由于隐式解析可选的值会在使用时自动解析，所以没必要使用操作符`!`来解析它。也就是说，如果你使用值为`nil`的隐式解析可选，就会导致运行错误。 由于隐式解析可选的值会在使用时自动解析，所以没必要使用操作符`!`来解析它。也就是说，如果你使用值为`nil`的隐式解析可选，就会导致运行错误。
使用可选链会选择性的执行隐式解析可选表达式上的某一个操作。如果值为`nil`，就不会执行任何操作，因此也不会产生运行错误。 使用可选链会选择性的执行隐式解析可选表达式上的某一个操作。如果值为`nil`，就不会执行任何操作，因此也不会产生运行错误。
关于隐式解析可选的更多细节，见章节“隐式解析可选”。 关于隐式解析可选的更多细节，见章节“隐式解析可选”。
> 隐式解析可选类型(Implicitly Unwrapped Optional Type)语法 > 隐式解析可选类型(Implicitly Unwrapped Optional Type)语法
> *隐式解析可选类型* → [*类型*](..\chapter3\03_Types.html#type) **!** > *隐式解析可选类型* → [*类型*](..\chapter3\03_Types.html#type) **!**
<a name="protocol_composition_type"></a> <a name="protocol_composition_type"></a>
##协议合成类型 ##协议合成类型
协议合成类型是一种符合每个协议的指定协议列表类型。协议合成类型可能会用在类型注解和泛型参数中。 协议合成类型是一种符合每个协议的指定协议列表类型。协议合成类型可能会用在类型注解和泛型参数中。
协议合成类型的形式如下： 协议合成类型的形式如下：
```swift ```swift
protocol<Protocol 1, Procotol 2> protocol<Protocol 1, Procotol 2>
``` ```
协议合成类型允许你指定一个值，其类型可以适配多个协议的条件，而且不需要定义一个新的命名型协议来继承其它想要适配的各个协议。比如，协议合成类型`protocol<Protocol A, Protocol B, Protocol C>`等效于一个从`Protocol A`，`Protocol B`， `Protocol C`继承而来的新协议`Protocol D`，很显然这样做有效率的多，甚至不需引入一个新名字。 协议合成类型允许你指定一个值，其类型可以适配多个协议的条件，而且不需要定义一个新的命名型协议来继承其它想要适配的各个协议。比如，协议合成类型`protocol<Protocol A, Protocol B, Protocol C>`等效于一个从`Protocol A`，`Protocol B`， `Protocol C`继承而来的新协议`Protocol D`，很显然这样做有效率的多，甚至不需引入一个新名字。
协议合成列表中的每项必须是协议名或协议合成类型的类型别名。如果列表为空，它就会指定一个空协议合成列表，这样每个类型都能适配。 协议合成列表中的每项必须是协议名或协议合成类型的类型别名。如果列表为空，它就会指定一个空协议合成列表，这样每个类型都能适配。
> 协议合成类型语法 > 协议合成类型语法
> *协议合成类型* → **protocol** **<** [*协议标识符列表*](..\chapter3\03_Types.html#protocol_identifier_list) _可选_ **>** > *协议合成类型* → **protocol** **<** [*协议标识符列表*](..\chapter3\03_Types.html#protocol_identifier_list) _可选_ **>**
> *协议标识符列表* → [*协议标识符*](..\chapter3\03_Types.html#protocol_identifier) | [*协议标识符*](..\chapter3\03_Types.html#protocol_identifier) **,** [*协议标识符列表*](..\chapter3\03_Types.html#protocol_identifier_list) > *协议标识符列表* → [*协议标识符*](..\chapter3\03_Types.html#protocol_identifier) | [*协议标识符*](..\chapter3\03_Types.html#protocol_identifier) **,** [*协议标识符列表*](..\chapter3\03_Types.html#protocol_identifier_list)
> *协议标识符* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) > *协议标识符* → [*类型标识*](..\chapter3\03_Types.html#type_identifier)
<a name="metatype_type"></a> <a name="metatype_type"></a>
##元类型 ##元类型
元类型是指所有类型的类型，包括类、结构体、枚举和协议。 元类型是指所有类型的类型，包括类、结构体、枚举和协议。
类、结构体或枚举类型的元类型是相应的类型名紧跟`.Type`。协议类型的元类型——并不是运行时适配该协议的具体类型——是该协议名字紧跟`.Protocol`。比如，类`SomeClass`的元类型就是`SomeClass.Type`，协议`SomeProtocol`的元类型就是`SomeProtocal.Protocol`。 类、结构体或枚举类型的元类型是相应的类型名紧跟`.Type`。协议类型的元类型——并不是运行时适配该协议的具体类型——是该协议名字紧跟`.Protocol`。比如，类`SomeClass`的元类型就是`SomeClass.Type`，协议`SomeProtocol`的元类型就是`SomeProtocal.Protocol`。
你可以使用后缀`self`表达式来获取类型。比如，`SomeClass.self`返回`SomeClass`本身，而不是`SomeClass`的一个实例。同样，`SomeProtocol.self`返回`SomeProtocol`本身，而不是运行时适配`SomeProtocol`的某个类型的实例。还可以对类型的实例使用`dynamicType`表达式来获取该实例在运行阶段的类型，如下所示： 你可以使用后缀`self`表达式来获取类型。比如，`SomeClass.self`返回`SomeClass`本身，而不是`SomeClass`的一个实例。同样，`SomeProtocol.self`返回`SomeProtocol`本身，而不是运行时适配`SomeProtocol`的某个类型的实例。还可以对类型的实例使用`dynamicType`表达式来获取该实例在运行阶段的类型，如下所示：
```swift ```swift
class SomeBaseClass { class SomeBaseClass {
class func printClassName() { class func printClassName() {
println("SomeBaseClass") println("SomeBaseClass")
} }
} }
class SomeSubClass: SomeBaseClass { class SomeSubClass: SomeBaseClass {
override class func printClassName() { override class func printClassName() {
println("SomeSubClass") println("SomeSubClass")
} }
} }
let someInstance: SomeBaseClass = SomeSubClass() let someInstance: SomeBaseClass = SomeSubClass()
// someInstance is of type SomeBaseClass at compile time, but // someInstance is of type SomeBaseClass at compile time, but
// someInstance is of type SomeSubClass at runtime // someInstance is of type SomeSubClass at runtime
someInstance.dynamicType.printClassName() someInstance.dynamicType.printClassName()
// prints "SomeSubClass // prints "SomeSubClass
``` ```
> 元(Metatype)类型语法 > 元(Metatype)类型语法
> *元类型* → [*类型*](..\chapter3\03_Types.html#type) **.** **Type** | [*类型*](..\chapter3\03_Types.html#type) **.** **Protocol** x > *元类型* → [*类型*](..\chapter3\03_Types.html#type) **.** **Type** | [*类型*](..\chapter3\03_Types.html#type) **.** **Protocol** x
<a name="type_inheritance_clause"></a> <a name="type_inheritance_clause"></a>
##类型继承子句 ##类型继承子句
类型继承子句被用来指定一个命名型类型继承哪个类且适配哪些协议。类型继承子句开始于冒号`:`，紧跟由`,`隔开的类型标识符列表。 类型继承子句被用来指定一个命名型类型继承哪个类且适配哪些协议。类型继承子句开始于冒号`:`，紧跟由`,`隔开的类型标识符列表。
类可以继承单个超类，适配任意数量的协议。当定义一个类时，超类的名字必须出现在类型标识符列表首位，然后跟上该类需要适配的任意数量的协议。如果一个类不是从其它类继承而来，那么列表可以以协议开头。关于类继承更多的讨论和例子，见章节“继承”。 类可以继承单个超类，适配任意数量的协议。当定义一个类时，超类的名字必须出现在类型标识符列表首位，然后跟上该类需要适配的任意数量的协议。如果一个类不是从其它类继承而来，那么列表可以以协议开头。关于类继承更多的讨论和例子，见章节“继承”。
其它命名型类型可能只继承或适配一个协议列表。协议类型可能继承于其它任意数量的协议。当一个协议类型继承于其它协议时，其它协议的条件集合会被集成在一起，然后其它从当前协议继承的任意类型必须适配所有这些条件。 其它命名型类型可能只继承或适配一个协议列表。协议类型可能继承于其它任意数量的协议。当一个协议类型继承于其它协议时，其它协议的条件集合会被集成在一起，然后其它从当前协议继承的任意类型必须适配所有这些条件。
枚举定义中的类型继承子句可以是一个协议列表，或是指定原始值的枚举，一个单独的指定原始值类型的命名型类型。使用类型继承子句来指定原始值类型的枚举定义的例子，见章节“原始值”。 枚举定义中的类型继承子句可以是一个协议列表，或是指定原始值的枚举，一个单独的指定原始值类型的命名型类型。使用类型继承子句来指定原始值类型的枚举定义的例子，见章节“原始值”。
> 类型继承子句语法 > 类型继承子句语法
> *类型继承子句* → **:** [*类型继承列表*](..\chapter3\03_Types.html#type_inheritance_list) > *类型继承子句* → **:** [*类型继承列表*](..\chapter3\03_Types.html#type_inheritance_list)
> *类型继承列表* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) | [*类型标识*](..\chapter3\03_Types.html#type_identifier) **,** [*类型继承列表*](..\chapter3\03_Types.html#type_inheritance_list) > *类型继承列表* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) | [*类型标识*](..\chapter3\03_Types.html#type_identifier) **,** [*类型继承列表*](..\chapter3\03_Types.html#type_inheritance_list)
<a name="type_inference"></a> <a name="type_inference"></a>
##类型推断 ##类型推断
Swift广泛的使用类型推断，从而允许你可以忽略很多变量和表达式的类型或部分类型。比如，对于`var x: Int = 0`，你可以完全忽略类型而简写成`var x = 0`——编译器会正确的推断出`x`的类型`Int`。类似的，当完整的类型可以从上下文推断出来时，你也可以忽略类型的一部分。比如，如果你写了`let dict: Dictionary = ["A": 1]`，编译提也能推断出`dict`的类型是`Dictionary<String, Int>`。 Swift广泛的使用类型推断，从而允许你可以忽略很多变量和表达式的类型或部分类型。比如，对于`var x: Int = 0`，你可以完全忽略类型而简写成`var x = 0`——编译器会正确的推断出`x`的类型`Int`。类似的，当完整的类型可以从上下文推断出来时，你也可以忽略类型的一部分。比如，如果你写了`let dict: Dictionary = ["A": 1]`，编译提也能推断出`dict`的类型是`Dictionary<String, Int>`。
在上面的两个例子中，类型信息从表达式树（expression tree）的叶子节点传向根节点。也就是说，`var x: Int = 0`中`x`的类型首先根据`0`的类型进行推断，然后将该类型信息传递到根节点（变量`x`）。 在上面的两个例子中，类型信息从表达式树（expression tree）的叶子节点传向根节点。也就是说，`var x: Int = 0`中`x`的类型首先根据`0`的类型进行推断，然后将该类型信息传递到根节点（变量`x`）。
在Swift中，类型信息也可以反方向流动——从根节点传向叶子节点。在下面的例子中，常量`eFloat`上的显式类型注解（`:Float`）导致数字字面量`2.71828`的类型是`Float`而非`Double`。 在Swift中，类型信息也可以反方向流动——从根节点传向叶子节点。在下面的例子中，常量`eFloat`上的显式类型注解（`:Float`）导致数字字面量`2.71828`的类型是`Float`而非`Double`。
```swift ```swift
let e = 2.71828 // The type of e is inferred to be Double. let e = 2.71828 // The type of e is inferred to be Double.
let eFloat: Float = 2.71828 // The type of eFloat is Float. let eFloat: Float = 2.71828 // The type of eFloat is Float.
``` ```
Swift中的类型推断在单独的表达式或语句水平上进行。这意味着所有用于推断类型的信息必须可以从表达式或其某个子表达式的类型检查中获取。 Swift中的类型推断在单独的表达式或语句水平上进行。这意味着所有用于推断类型的信息必须可以从表达式或其某个子表达式的类型检查中获取。

1278
source/chapter3/04_Expressions.md
View File

File diff suppressed because it is too large Load Diff

1710
source/chapter3/05_Declarations.md
View File

File diff suppressed because it is too large Load Diff

248
source/chapter3/06_Attributes.md
View File

@ -1,124 +1,124 @@
> 翻译：[Hawstein](https://github.com/Hawstein) > 翻译：[Hawstein](https://github.com/Hawstein)
> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai) > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
# 特性 # 特性
----------------- -----------------
本页内容包括： 本页内容包括：
- [声明特性](#declaration_attributes) - [声明特性](#declaration_attributes)
- [类型特性](#type_attributes) - [类型特性](#type_attributes)
特性提供了关于声明和类型的更多信息。在Swift中有两类特性，用于修饰声明的以及用于修饰类型的。例如，`required`特性，当应用于一个类的指定或便利初始化器声明时，表明它的每个子类都必须实现那个初始化器。再比如`noreturn`特性，当应用于函数或方法类型时，表明该函数或方法不会返回到它的调用者。 特性提供了关于声明和类型的更多信息。在Swift中有两类特性，用于修饰声明的以及用于修饰类型的。例如，`required`特性，当应用于一个类的指定或便利初始化器声明时，表明它的每个子类都必须实现那个初始化器。再比如`noreturn`特性，当应用于函数或方法类型时，表明该函数或方法不会返回到它的调用者。
通过以下方式指定一个特性：符号`@`后面跟特性名，如果包含参数，则把参数带上： 通过以下方式指定一个特性：符号`@`后面跟特性名，如果包含参数，则把参数带上：
> @`attribute name` > @`attribute name`
> @`attribute name`(`attribute arguments`) > @`attribute name`(`attribute arguments`)
有些声明特性通过接收参数来指定特性的更多信息以及它是如何修饰一个特定的声明的。这些特性的参数写在小括号内，它们的格式由它们所属的特性来定义。 有些声明特性通过接收参数来指定特性的更多信息以及它是如何修饰一个特定的声明的。这些特性的参数写在小括号内，它们的格式由它们所属的特性来定义。
<a name="declaration_attributes"></a> <a name="declaration_attributes"></a>
## 声明特性 ## 声明特性
声明特性只能应用于声明。然而，你也可以将`noreturn`特性应用于函数或方法类型。 声明特性只能应用于声明。然而，你也可以将`noreturn`特性应用于函数或方法类型。
`assignment` `assignment`
该特性用于修饰重载了复合赋值运算符的函数。重载了复合赋值运算符的函数必需将它们的初始输入参数标记为`inout`。如何使用`assignment`特性的一个例子，请见：[复合赋值运算符]()。 该特性用于修饰重载了复合赋值运算符的函数。重载了复合赋值运算符的函数必需将它们的初始输入参数标记为`inout`。如何使用`assignment`特性的一个例子，请见：[复合赋值运算符]()。
`class_protocol` `class_protocol`
该特性用于修饰一个协议表明该协议只能被类类型采用[待改：adopted]。 该特性用于修饰一个协议表明该协议只能被类类型采用[待改：adopted]。
如果你用`objc`特性修饰一个协议，`class_protocol`特性就会隐式地应用到该协议，因此无需显式地用`class_protocol`特性标记该协议。 如果你用`objc`特性修饰一个协议，`class_protocol`特性就会隐式地应用到该协议，因此无需显式地用`class_protocol`特性标记该协议。
`exported` `exported`
该特性用于修饰导入声明，以此来导出已导入的模块，子模块，或当前模块的声明。如果另一个模块导入了当前模块，那么那个模块可以访问当前模块的导出项。 该特性用于修饰导入声明，以此来导出已导入的模块，子模块，或当前模块的声明。如果另一个模块导入了当前模块，那么那个模块可以访问当前模块的导出项。
`final` `final`
该特性用于修饰一个类或类中的属性，方法，以及下标成员。如果用它修饰一个类，那么这个类则不能被继承。如果用它修饰类中的属性，方法或下标，则表示在子类中，它们不能被重写。 该特性用于修饰一个类或类中的属性，方法，以及下标成员。如果用它修饰一个类，那么这个类则不能被继承。如果用它修饰类中的属性，方法或下标，则表示在子类中，它们不能被重写。
`lazy` `lazy`
该特性用于修饰类或结构体中的存储型变量属性，表示该属性的初始值最多只被计算和存储一次，且发生在第一次访问它时。如何使用`lazy`特性的一个例子，请见：[惰性存储型属性]()。 该特性用于修饰类或结构体中的存储型变量属性，表示该属性的初始值最多只被计算和存储一次，且发生在第一次访问它时。如何使用`lazy`特性的一个例子，请见：[惰性存储型属性]()。
`noreturn` `noreturn`
该特性用于修饰函数或方法声明，表明该函数或方法的对应类型，`T`，是`@noreturn T`。你可以用这个特性修饰函数或方法的类型，这样一来，函数或方法就不会返回到它的调用者中去。 该特性用于修饰函数或方法声明，表明该函数或方法的对应类型，`T`，是`@noreturn T`。你可以用这个特性修饰函数或方法的类型，这样一来，函数或方法就不会返回到它的调用者中去。
对于一个没有用`noreturn`特性标记的函数或方法，你可以将它重写(override)为用该特性标记的。相反，对于一个已经用`noreturn`特性标记的函数或方法，你则不可以将它重写为没使用该特性标记的。相同的规则试用于当你在一个comforming类型中实现一个协议方法时。 对于一个没有用`noreturn`特性标记的函数或方法，你可以将它重写(override)为用该特性标记的。相反，对于一个已经用`noreturn`特性标记的函数或方法，你则不可以将它重写为没使用该特性标记的。相同的规则试用于当你在一个comforming类型中实现一个协议方法时。
`NSCopying` `NSCopying`
该特性用于修饰一个类的存储型变量属性。该特性将使属性的setter与属性值的一个副本合成，由`copyWithZone`方法返回，而不是属性本身的值。该属性的类型必需遵循`NSCopying`协议。 该特性用于修饰一个类的存储型变量属性。该特性将使属性的setter与属性值的一个副本合成，由`copyWithZone`方法返回，而不是属性本身的值。该属性的类型必需遵循`NSCopying`协议。
`NSCopying`特性的行为与Objective-C中的`copy`特性相似。 `NSCopying`特性的行为与Objective-C中的`copy`特性相似。
`NSManaged` `NSManaged`
该特性用于修饰`NSManagedObject`子类中的存储型变量属性，表明属性的存储和实现由Core Data在运行时基于相关实体描述动态提供。 该特性用于修饰`NSManagedObject`子类中的存储型变量属性，表明属性的存储和实现由Core Data在运行时基于相关实体描述动态提供。
`objc` `objc`
该特性用于修饰任意可以在Objective-C中表示的声明，比如，非嵌套类，协议，类和协议中的属性和方法（包含getter和setter），初始化器，析构器，以下下标。`objc`特性告诉编译器该声明可以在Objective-C代码中使用。 该特性用于修饰任意可以在Objective-C中表示的声明，比如，非嵌套类，协议，类和协议中的属性和方法（包含getter和setter），初始化器，析构器，以下下标。`objc`特性告诉编译器该声明可以在Objective-C代码中使用。
如果你将`objc`特性应用于一个类或协议，它也会隐式地应用于那个类或协议的成员。对于标记了`objc`特性的类，编译器会隐式地为它的子类添加`objc`特性。标记了`objc`特性的协议不能继承自没有标记`objc`的协议。 如果你将`objc`特性应用于一个类或协议，它也会隐式地应用于那个类或协议的成员。对于标记了`objc`特性的类，编译器会隐式地为它的子类添加`objc`特性。标记了`objc`特性的协议不能继承自没有标记`objc`的协议。
`objc`特性有一个可选的参数，由标记符组成。当你想把`objc`所修饰的实体以一个不同的名字暴露给Objective-C，你就可以使用这个特性参数。你可以使用这个参数来命名类，协议，方法，getters，setters，以及初始化器。下面的例子把`ExampleClass`中`enabled`属性的getter暴露给Objective-C，名字是`isEnabled`，而不是它原来的属性名。 `objc`特性有一个可选的参数，由标记符组成。当你想把`objc`所修饰的实体以一个不同的名字暴露给Objective-C，你就可以使用这个特性参数。你可以使用这个参数来命名类，协议，方法，getters，setters，以及初始化器。下面的例子把`ExampleClass`中`enabled`属性的getter暴露给Objective-C，名字是`isEnabled`，而不是它原来的属性名。
```swift ```swift
@objc @objc
class ExampleClass { class ExampleClass {
var enabled: Bool { var enabled: Bool {
@objc(isEnabled) get { @objc(isEnabled) get {
// Return the appropriate value // Return the appropriate value
} }
} }
} }
``` ```
`optional` `optional`
用该特性修饰协议的属性，方法或下标成员，表示实现这些成员并不需要一致性类型（conforming type）。 用该特性修饰协议的属性，方法或下标成员，表示实现这些成员并不需要一致性类型（conforming type）。
你只能用`optional`特性修饰那些标记了`objc`特性的协议。因此，只有类类型可以adopt和comform to那些包含可选成员需求的协议。更多关于如何使用`optional`特性以及如何访问可选协议成员的指导，例如，当你不确定一个conforming类型是否实现了它们，请见：[可选协议需求]()。 你只能用`optional`特性修饰那些标记了`objc`特性的协议。因此，只有类类型可以adopt和comform to那些包含可选成员需求的协议。更多关于如何使用`optional`特性以及如何访问可选协议成员的指导，例如，当你不确定一个conforming类型是否实现了它们，请见：[可选协议需求]()。
`required` `required`
用该特性修饰一个类的指定或便利初始化器，表示该类的所有子类都必需实现该初始化器。 用该特性修饰一个类的指定或便利初始化器，表示该类的所有子类都必需实现该初始化器。
加了该特性的指定初始化器必需显式地实现，而便利初始化器既可显式地实现，也可以在子类实现了超类所有指定初始化器后继承而来（或者当子类使用便利初始化器重写了指定初始化器）。 加了该特性的指定初始化器必需显式地实现，而便利初始化器既可显式地实现，也可以在子类实现了超类所有指定初始化器后继承而来（或者当子类使用便利初始化器重写了指定初始化器）。
### Interface Builder使用的声明特性 ### Interface Builder使用的声明特性
Interface Builder特性是Interface Builder用来与Xcode同步的声明特性。Swift提供了以下的Interface Builder特性：`IBAction`，`IBDesignable`，`IBInspectable`，以及`IBOutlet`。这些特性与Objective-C中对应的特性在概念上是相同的。 Interface Builder特性是Interface Builder用来与Xcode同步的声明特性。Swift提供了以下的Interface Builder特性：`IBAction`，`IBDesignable`，`IBInspectable`，以及`IBOutlet`。这些特性与Objective-C中对应的特性在概念上是相同的。
`IBOutlet`和`IBInspectable`用于修饰一个类的属性声明；`IBAction`特性用于修饰一个类的方法声明；`IBDesignable`用于修饰类的声明。 `IBOutlet`和`IBInspectable`用于修饰一个类的属性声明；`IBAction`特性用于修饰一个类的方法声明；`IBDesignable`用于修饰类的声明。
<a name="type_attributes"></a> <a name="type_attributes"></a>
## 类型特性 ## 类型特性
类型特性只能用于修饰类型。然而，你也可以用`noreturn`特性去修饰函数或方法声明。 类型特性只能用于修饰类型。然而，你也可以用`noreturn`特性去修饰函数或方法声明。
`auto_closure` `auto_closure`
这个特性通过自动地将表达式封闭到一个无参数闭包中来延迟表达式的求值。使用该特性修饰无参的函数或方法类型，返回表达式的类型。一个如何使用`auto_closure`特性的例子，见[函数类型]() 这个特性通过自动地将表达式封闭到一个无参数闭包中来延迟表达式的求值。使用该特性修饰无参的函数或方法类型，返回表达式的类型。一个如何使用`auto_closure`特性的例子，见[函数类型]()
`noreturn` `noreturn`
该特性用于修饰函数或方法的类型，表明该函数或方法不会返回到它的调用者中去。你也可以用它标记函数或方法的声明，表示函数或方法的相应类型，`T`，是`@noreturn T`。 该特性用于修饰函数或方法的类型，表明该函数或方法不会返回到它的调用者中去。你也可以用它标记函数或方法的声明，表示函数或方法的相应类型，`T`，是`@noreturn T`。
> 特性语法 > 特性语法
> *特性* → **@** [*特性名*](..\chapter3\06_Attributes.html#attribute_name) [*特性参数子句*](..\chapter3\06_Attributes.html#attribute_argument_clause) _可选_ > *特性* → **@** [*特性名*](..\chapter3\06_Attributes.html#attribute_name) [*特性参数子句*](..\chapter3\06_Attributes.html#attribute_argument_clause) _可选_
> *特性名* → [*标识符*](LexicalStructure.html#identifier) > *特性名* → [*标识符*](LexicalStructure.html#identifier)
> *特性参数子句* → **(** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **)** > *特性参数子句* → **(** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **)**
> *特性(Attributes)列表* → [*特色*](..\chapter3\06_Attributes.html#attribute) [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ > *特性(Attributes)列表* → [*特色*](..\chapter3\06_Attributes.html#attribute) [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_
> *平衡令牌列表* → [*平衡令牌*](..\chapter3\06_Attributes.html#balanced_token) [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ > *平衡令牌列表* → [*平衡令牌*](..\chapter3\06_Attributes.html#balanced_token) [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_
> *平衡令牌* → **(** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **)** > *平衡令牌* → **(** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **)**
> *平衡令牌* → **[** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **]** > *平衡令牌* → **[** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **]**
> *平衡令牌* → **{** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **}** > *平衡令牌* → **{** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **}**
> *平衡令牌* → **任意标识符, 关键字, 字面量或运算符** > *平衡令牌* → **任意标识符, 关键字, 字面量或运算符**
> *平衡令牌* → **任意标点除了(, ), [, ], {, 或 }** > *平衡令牌* → **任意标点除了(, ), [, ], {, 或 }**

362
source/chapter3/07_Patterns.md
View File

@ -1,182 +1,182 @@
> 翻译：[honghaoz](https://github.com/honghaoz) > 翻译：[honghaoz](https://github.com/honghaoz)
> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai) > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
# 模式（Patterns） # 模式（Patterns）
----------------- -----------------
本页内容包括： 本页内容包括：
- [通配符模式（Wildcard Pattern）](#wildcard_pattern) - [通配符模式（Wildcard Pattern）](#wildcard_pattern)
- [标识符模式（Identifier Pattern）](#identifier_pattern) - [标识符模式（Identifier Pattern）](#identifier_pattern)
- [值绑定模式（Value-Binding Pattern）](#value-binding_pattern) - [值绑定模式（Value-Binding Pattern）](#value-binding_pattern)
- [元组模式（Tuple Pattern）](#tuple_pattern) - [元组模式（Tuple Pattern）](#tuple_pattern)
- [枚举用例模式（Enumeration Case Pattern）](#enumeration_case_pattern) - [枚举用例模式（Enumeration Case Pattern）](#enumeration_case_pattern)
- [类型转换模式（Type-Casting Patterns）](#type-casting_patterns) - [类型转换模式（Type-Casting Patterns）](#type-casting_patterns)
- [表达式模式（Expression Pattern）](#expression_pattern) - [表达式模式（Expression Pattern）](#expression_pattern)
模式（pattern）代表了单个值或者复合值的结构。例如，元组`(1, 2)`的结构是逗号分隔的，包含两个元素的列表。因为模式代表一种值的结构，而不是特定的某个值，你可以把模式和各种同类型的值匹配起来。比如，`(x, y)`可以匹配元组`(1, 2)`，以及任何含两个元素的元组。除了将模式与一个值匹配外，你可以从合成值中提取出部分或全部，然后分别把各个部分和一个常量或变量绑定起来。 模式（pattern）代表了单个值或者复合值的结构。例如，元组`(1, 2)`的结构是逗号分隔的，包含两个元素的列表。因为模式代表一种值的结构，而不是特定的某个值，你可以把模式和各种同类型的值匹配起来。比如，`(x, y)`可以匹配元组`(1, 2)`，以及任何含两个元素的元组。除了将模式与一个值匹配外，你可以从合成值中提取出部分或全部，然后分别把各个部分和一个常量或变量绑定起来。
在Swift中，模式出现在变量和常量的声明（在它们的左侧），`for-in`语句和`switch`语句（在它们的case标签）中。尽管任何模式都可以出现在`switch`语句的case标签中，但在其他情况下，只有通配符模式（wildcard pattern），标识符模式（identifier pattern）和包含这两种模式的模式才能出现。 在Swift中，模式出现在变量和常量的声明（在它们的左侧），`for-in`语句和`switch`语句（在它们的case标签）中。尽管任何模式都可以出现在`switch`语句的case标签中，但在其他情况下，只有通配符模式（wildcard pattern），标识符模式（identifier pattern）和包含这两种模式的模式才能出现。
你可以为通配符模式（wildcard pattern），标识符模式（identifier pattern）和元组模式（tuple pattern）指定类型注释，用来限制这种模式只匹配某种类型的值。 你可以为通配符模式（wildcard pattern），标识符模式（identifier pattern）和元组模式（tuple pattern）指定类型注释，用来限制这种模式只匹配某种类型的值。
> 模式(Patterns) 语法 > 模式(Patterns) 语法
> *模式* → [*通配符模式*](..\chapter3\07_Patterns.html#wildcard_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotation) _可选_ > *模式* → [*通配符模式*](..\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#identifier_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotati(Value Binding)on) _可选_
> *模式* → [*值绑定模式*](..\chapter3\07_Patterns.html#value_binding_pattern) > *模式* → [*值绑定模式*](..\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) _可选_
> *模式* → [*enum-case-pattern*](..\chapter3\07_Patterns.html#enum_case_pattern) > *模式* → [*enum-case-pattern*](..\chapter3\07_Patterns.html#enum_case_pattern)
> *模式* → [*type-casting-pattern*](..\chapter3\07_Patterns.html#type_casting_pattern) > *模式* → [*type-casting-pattern*](..\chapter3\07_Patterns.html#type_casting_pattern)
> *模式* → [*表达式模式*](..\chapter3\07_Patterns.html#expression_pattern) > *模式* → [*表达式模式*](..\chapter3\07_Patterns.html#expression_pattern)
<a name="wildcard_pattern"></a> <a name="wildcard_pattern"></a>
## 通配符模式（Wildcard Pattern） ## 通配符模式（Wildcard Pattern）
通配符模式匹配并忽略任何值，包含一个下划线（_）。当你不关心被匹配的值时，可以使用此模式。例如，下面这段代码进行了`1...3`的循环，并忽略了每次循环的值： 通配符模式匹配并忽略任何值，包含一个下划线（_）。当你不关心被匹配的值时，可以使用此模式。例如，下面这段代码进行了`1...3`的循环，并忽略了每次循环的值：
```swift ```swift
for _ in 1...3 { for _ in 1...3 {
// Do something three times. // Do something three times.
} }
``` ```
> 通配符模式语法 > 通配符模式语法
> *通配符模式* → **_** > *通配符模式* → **_**
<a name="identifier_pattern"></a> <a name="identifier_pattern"></a>
## 标识符模式（Identifier Pattern） ## 标识符模式（Identifier Pattern）
标识符模式匹配任何值，并将匹配的值和一个变量或常量绑定起来。例如，在下面的常量申明中，`someValue`是一个标识符模式，匹配了类型是`Int`的`42`。 标识符模式匹配任何值，并将匹配的值和一个变量或常量绑定起来。例如，在下面的常量申明中，`someValue`是一个标识符模式，匹配了类型是`Int`的`42`。
```swift ```swift
let someValue = 42 let someValue = 42
``` ```
当匹配成功时，`42`被绑定（赋值）给常量`someValue`。 当匹配成功时，`42`被绑定（赋值）给常量`someValue`。
当一个变量或常量申明的左边是标识符模式时，此时，标识符模式是隐式的值绑定模式（value-binding pattern）。 当一个变量或常量申明的左边是标识符模式时，此时，标识符模式是隐式的值绑定模式（value-binding pattern）。
> 标识符模式语法 > 标识符模式语法
> *标识符模式* → [*标识符*](LexicalStructure.html#identifier) > *标识符模式* → [*标识符*](LexicalStructure.html#identifier)
<a name="value-binding_pattern"></a> <a name="value-binding_pattern"></a>
## 值绑定模式（Value-Binding Pattern） ## 值绑定模式（Value-Binding Pattern）
值绑定模式绑定匹配的值到一个变量或常量。当绑定匹配值给常量时，用关键字`let`,绑定给变量时，用关键之`var`。 值绑定模式绑定匹配的值到一个变量或常量。当绑定匹配值给常量时，用关键字`let`,绑定给变量时，用关键之`var`。
标识符模式包含在值绑定模式中，绑定新的变量或常量到匹配的值。例如，你可以分解一个元组的元素，并把每个元素绑定到相应的标识符模式中。 标识符模式包含在值绑定模式中，绑定新的变量或常量到匹配的值。例如，你可以分解一个元组的元素，并把每个元素绑定到相应的标识符模式中。
```swift ```swift
let point = (3, 2) let point = (3, 2)
switch point { switch point {
// Bind x and y to the elements of point. // Bind x and y to the elements of point.
case let (x, y): 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).” // 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)模式语法 > 值绑定(Value Binding)模式语法
> *值绑定模式* → **var** [*模式*](..\chapter3\07_Patterns.html#pattern) | **let** [*模式*](..\chapter3\07_Patterns.html#pattern) > *值绑定模式* → **var** [*模式*](..\chapter3\07_Patterns.html#pattern) | **let** [*模式*](..\chapter3\07_Patterns.html#pattern)
<a name="tuple_pattern"></a> <a name="tuple_pattern"></a>
## 元组模式（Tuple Pattern） ## 元组模式（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 ```swift
let points = [(0, 0), (1, 0), (1, 1), (2, 0), (2, 1)] let points = [(0, 0), (1, 0), (1, 1), (2, 0), (2, 1)]
// This code isn't valid. // This code isn't valid.
for (x, 0) in points { for (x, 0) in points {
/* ... */ /* ... */
} }
``` ```
对于只包含一个元素的元组，括号是不起作用的。模式匹配那个单个元素的类型。例如，下面是等效的： 对于只包含一个元素的元组，括号是不起作用的。模式匹配那个单个元素的类型。例如，下面是等效的：
```swift ```swift
let a = 2 // a: Int = 2 let a = 2 // a: Int = 2
let (a) = 2 // a: Int = 2 let (a) = 2 // a: Int = 2
let (a): Int = 2 // a: Int = 2 let (a): Int = 2 // a: Int = 2
``` ```
> 元组模式语法 > 元组模式语法
> *元组模式* → **(** [*元组模式元素列表*](..\chapter3\07_Patterns.html#tuple_pattern_element_list) _可选_ **)** > *元组模式* → **(** [*元组模式元素列表*](..\chapter3\07_Patterns.html#tuple_pattern_element_list) _可选_ **)**
> *元组模式元素列表* → [*元组模式元素*](..\chapter3\07_Patterns.html#tuple_pattern_element) | [*元组模式元素*](..\chapter3\07_Patterns.html#tuple_pattern_element) **,** [*元组模式元素列表*](..\chapter3\07_Patterns.html#tuple_pattern_element_list) > *元组模式元素列表* → [*元组模式元素*](..\chapter3\07_Patterns.html#tuple_pattern_element) | [*元组模式元素*](..\chapter3\07_Patterns.html#tuple_pattern_element) **,** [*元组模式元素列表*](..\chapter3\07_Patterns.html#tuple_pattern_element_list)
> *元组模式元素* → [*模式*](..\chapter3\07_Patterns.html#pattern) > *元组模式元素* → [*模式*](..\chapter3\07_Patterns.html#pattern)
<a name="enumeration_case_pattern"></a> <a name="enumeration_case_pattern"></a>
## 枚举用例模式（Enumeration Case Pattern） ## 枚举用例模式（Enumeration Case Pattern）
枚举用例模式匹配现有的枚举类型的某种用例。枚举用例模式仅在`switch`语句中的`case`标签中出现。 枚举用例模式匹配现有的枚举类型的某种用例。枚举用例模式仅在`switch`语句中的`case`标签中出现。
如果你准备匹配的枚举用例有任何关联的值，则相应的枚举用例模式必须指定一个包含每个关联值元素的元组模式。关于使用`switch`语句来匹配包含关联值枚举用例的例子，请参阅`Associated Values`. 如果你准备匹配的枚举用例有任何关联的值，则相应的枚举用例模式必须指定一个包含每个关联值元素的元组模式。关于使用`switch`语句来匹配包含关联值枚举用例的例子，请参阅`Associated Values`.
> 枚举用例模式语法 > 枚举用例模式语法
> *enum-case-pattern* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) _可选_ **.** [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) _可选_ > *enum-case-pattern* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) _可选_ **.** [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) _可选_
<a name="type-casting_patterns"></a> <a name="type-casting_patterns"></a>
## 类型转换模式（Type-Casting Patterns） ## 类型转换模式（Type-Casting Patterns）
有两种类型转换模式，`is`模式和`as`模式。这两种模式均只出现在`switch`语句中的`case`标签中。`is`模式和`as`模式有以下形式： 有两种类型转换模式，`is`模式和`as`模式。这两种模式均只出现在`switch`语句中的`case`标签中。`is`模式和`as`模式有以下形式：
> is `type` > is `type`
> `pattern` as `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`。 关于使用`switch`语句来匹配`is`模式和`as`模式值的例子，请参阅`Type Casting for Any and AnyObject`。
> 类型转换模式语法 > 类型转换模式语法
> *type-casting-pattern* → [*is模式*](..\chapter3\07_Patterns.html#is_pattern) | [*as模式*](..\chapter3\07_Patterns.html#as_pattern) > *type-casting-pattern* → [*is模式*](..\chapter3\07_Patterns.html#is_pattern) | [*as模式*](..\chapter3\07_Patterns.html#as_pattern)
> *is模式* → **is** [*类型*](..\chapter3\03_Types.html#type) > *is模式* → **is** [*类型*](..\chapter3\03_Types.html#type)
> *as模式* → [*模式*](..\chapter3\07_Patterns.html#pattern) **as** [*类型*](..\chapter3\03_Types.html#type) > *as模式* → [*模式*](..\chapter3\07_Patterns.html#pattern) **as** [*类型*](..\chapter3\03_Types.html#type)
<a name="expression_pattern"></a> <a name="expression_pattern"></a>
## 表达式模式（Expression Pattern） ## 表达式模式（Expression Pattern）
表达式模式代表了一个表达式的值。这个模式只出现在`switch`语句中的`case`标签中。 表达式模式代表了一个表达式的值。这个模式只出现在`switch`语句中的`case`标签中。
由表达式模式所代表的表达式用Swift标准库中的`~=`操作符与输入表达式的值进行比较。如果`~=`操作符返回`true`，则匹配成功。默认情况下，`~=`操作符使用`==`操作符来比较两个相同类型的值。它也可以匹配一个整数值与一个`Range`对象中的整数范围，正如下面这个例子所示： 由表达式模式所代表的表达式用Swift标准库中的`~=`操作符与输入表达式的值进行比较。如果`~=`操作符返回`true`，则匹配成功。默认情况下，`~=`操作符使用`==`操作符来比较两个相同类型的值。它也可以匹配一个整数值与一个`Range`对象中的整数范围，正如下面这个例子所示：
```swift ```swift
let point = (1, 2) let point = (1, 2)
switch point { switch point {
case (0, 0): case (0, 0):
println("(0, 0) is at the origin.") println("(0, 0) is at the origin.")
case (-2...2, -2...2): case (-2...2, -2...2):
println("(\(point.0), \(point.1)) is near the origin.") println("(\(point.0), \(point.1)) is near the origin.")
default: 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.” // prints "(1, 2) is near the origin.”
``` ```
你可以重载`~=`操作符来提供自定义的表达式行为。例如，你可以重写上面的例子，以实现用字符串表达的点来比较`point`表达式。 你可以重载`~=`操作符来提供自定义的表达式行为。例如，你可以重写上面的例子，以实现用字符串表达的点来比较`point`表达式。
```swift ```swift
// Overload the ~= operator to match a string with an integer // Overload the ~= operator to match a string with an integer
func ~=(pattern: String, value: Int) -> Bool { func ~=(pattern: String, value: Int) -> Bool {
return pattern == "\(value)" return pattern == "\(value)"
} }
switch point { switch point {
case ("0", "0"): case ("0", "0"):
println("(0, 0) is at the origin.") println("(0, 0) is at the origin.")
case ("-2...2", "-2...2"): case ("-2...2", "-2...2"):
println("(\(point.0), \(point.1)) is near the origin.") println("(\(point.0), \(point.1)) is near the origin.")
default: 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.” // prints "(1, 2) is near the origin.”
``` ```
> 表达式模式语法 > 表达式模式语法
> *表达式模式* → [*表达式*](..\chapter3\04_Expressions.html#expression) > *表达式模式* → [*表达式*](..\chapter3\04_Expressions.html#expression)

210
source/chapter3/08_Generic_Parameters_and_Arguments.md
View File

@ -1,106 +1,106 @@
> 翻译：[fd5788](https://github.com/fd5788) > 翻译：[fd5788](https://github.com/fd5788)
> 校对：[yankuangshi](https://github.com/yankuangshi), [stanzhai](https://github.com/stanzhai) > 校对：[yankuangshi](https://github.com/yankuangshi), [stanzhai](https://github.com/stanzhai)
# 泛型参数 # 泛型参数
--------- ---------
本页包含内容： 本页包含内容：
- [泛型形参子句](#generic_parameter) - [泛型形参子句](#generic_parameter)
- [泛型实参子句](#generic_argument) - [泛型实参子句](#generic_argument)
本节涉及泛型类型、泛型函数以及泛型构造器的参数，包括形参和实参。声明泛型类型、函数或构造器时，须指定相应的类型参数。类型参数相当于一个占位符，当实例化泛型类型、调用泛型函数或泛型构造器时，就用具体的类型实参替代之。 本节涉及泛型类型、泛型函数以及泛型构造器的参数，包括形参和实参。声明泛型类型、函数或构造器时，须指定相应的类型参数。类型参数相当于一个占位符，当实例化泛型类型、调用泛型函数或泛型构造器时，就用具体的类型实参替代之。
关于 Swift 语言的泛型概述，见[泛型](../charpter2/22_Generics.md)(第二部分第22章)。 关于 Swift 语言的泛型概述，见[泛型](../charpter2/22_Generics.md)(第二部分第22章)。
<a name="generic_parameter"></a> <a name="generic_parameter"></a>
## 泛型形参子句 ## 泛型形参子句
泛型形参子句指定泛型类型或函数的类型形参，以及这些参数的关联约束和要求。泛型形参子句用尖括号（<>）包住，并且有以下两种形式： 泛型形参子句指定泛型类型或函数的类型形参，以及这些参数的关联约束和要求。泛型形参子句用尖括号（<>）包住，并且有以下两种形式：
> <`generic parameter list`> > <`generic parameter list`>
> <`generic parameter list` where `requirements`> > <`generic parameter list` where `requirements`>
泛型形参列表中泛型形参用逗号分开，每一个采用以下形式： 泛型形参列表中泛型形参用逗号分开，每一个采用以下形式：
> `type parameter` : `constrain` > `type parameter` : `constrain`
泛型形参由两部分组成：类型形参及其后的可选约束。类型形参只是占位符类型（如T，U，V，KeyType，ValueType等）的名字而已。你可以在泛型类型、函数的其余部分或者构造器声明，以及函数或构造器的签名中使用它。 泛型形参由两部分组成：类型形参及其后的可选约束。类型形参只是占位符类型（如T，U，V，KeyType，ValueType等）的名字而已。你可以在泛型类型、函数的其余部分或者构造器声明，以及函数或构造器的签名中使用它。
约束用于指明该类型形参继承自某个类或者遵守某个协议或协议的一部分。例如，在下面的泛型中，泛型形参`T: Comparable`表示任何用于替代类型形参`T`的类型实参必须满足`Comparable`协议。 约束用于指明该类型形参继承自某个类或者遵守某个协议或协议的一部分。例如，在下面的泛型中，泛型形参`T: Comparable`表示任何用于替代类型形参`T`的类型实参必须满足`Comparable`协议。
```swift ```swift
func simpleMin<T: COmparable>(x: T, y: T) -> T { func simpleMin<T: COmparable>(x: T, y: T) -> T {
if x < y { if x < y {
return y return y
} }
return x return x
} }
``` ```
如，`Int`和`Double`均满足`Comparable`协议，该函数接受任何一种类型。与泛型类型相反，调用泛型函数或构造器时不需要指定泛型实参子句。类型实参由传递给函数或构造器的实参推断而出。 如，`Int`和`Double`均满足`Comparable`协议，该函数接受任何一种类型。与泛型类型相反，调用泛型函数或构造器时不需要指定泛型实参子句。类型实参由传递给函数或构造器的实参推断而出。
```swift ```swift
simpleMin(17, 42) // T is inferred to be Int simpleMin(17, 42) // T is inferred to be Int
simpleMin(3.14159, 2.71828) // T is inferred to be Double simpleMin(3.14159, 2.71828) // T is inferred to be Double
``` ```
## Where 子句 ## Where 子句
要想对类型形参及其关联类型指定额外要求，可以在泛型形参列表之后添加`where`子句。`where`子句由关键字`where`及其后的用逗号分割的多个要求组成。 要想对类型形参及其关联类型指定额外要求，可以在泛型形参列表之后添加`where`子句。`where`子句由关键字`where`及其后的用逗号分割的多个要求组成。
`where`子句中的要求用于指明该类型形参继承自某个类或遵守某个协议或协议的一部分。尽管`where`子句有助于表达类型形参上的简单约束（如`T: Comparable`等同于`T where T: Comparable`，等等），但是依然可以用来对类型形参及其关联约束提供更复杂的约束。如，`<T where T: C, T: P>`表示泛型类型`T`继承自类`C`且遵守协议`P`。 `where`子句中的要求用于指明该类型形参继承自某个类或遵守某个协议或协议的一部分。尽管`where`子句有助于表达类型形参上的简单约束（如`T: Comparable`等同于`T where T: Comparable`，等等），但是依然可以用来对类型形参及其关联约束提供更复杂的约束。如，`<T where T: C, T: P>`表示泛型类型`T`继承自类`C`且遵守协议`P`。
如上所述，可以强制约束类型形参的关联类型遵守某个协议。`<T: Generator where T.Element: Equatable>`表示`T`遵守`Generator`协议，而且`T`的关联类型`T.Element`遵守`Eauatable`协议（`T`有关联类型是因为`Generator`声明了`Element`，而`T`遵守`Generator`协议）。 如上所述，可以强制约束类型形参的关联类型遵守某个协议。`<T: Generator where T.Element: Equatable>`表示`T`遵守`Generator`协议，而且`T`的关联类型`T.Element`遵守`Eauatable`协议（`T`有关联类型是因为`Generator`声明了`Element`，而`T`遵守`Generator`协议）。
也可以用操作符`==`来指定两个类型等效的要求。例如，有这样一个约束：`T`和`U`遵守`Generator`协议，同时要求它们的关联类型等同，可以这样来表达：`<T: Generator, U: Generator where T.Element == U.Element>`。 也可以用操作符`==`来指定两个类型等效的要求。例如，有这样一个约束：`T`和`U`遵守`Generator`协议，同时要求它们的关联类型等同，可以这样来表达：`<T: Generator, U: Generator where T.Element == U.Element>`。
当然，替代类型形参的类型实参必须满足所有类型形参所要求的约束和要求。 当然，替代类型形参的类型实参必须满足所有类型形参所要求的约束和要求。
泛型函数或构造器可以重载，但在泛型形参子句中的类型形参必须有不同的约束或要求，抑或二者皆不同。当调用重载的泛型函数或构造器时，编译器会用这些约束来决定调用哪个重载函数或构造器。 泛型函数或构造器可以重载，但在泛型形参子句中的类型形参必须有不同的约束或要求，抑或二者皆不同。当调用重载的泛型函数或构造器时，编译器会用这些约束来决定调用哪个重载函数或构造器。
泛型类可以生成一个子类，但是这个子类也必须是泛型类。 泛型类可以生成一个子类，但是这个子类也必须是泛型类。
> 泛型形参子句语法 > 泛型形参子句语法
> *泛型参数子句* → **<** [*泛型参数列表*](GenericParametersAndArguments.html#generic_parameter_list) [*约束子句*](GenericParametersAndArguments.html#requirement_clause) _可选_ **>** > *泛型参数子句* → **<** [*泛型参数列表*](GenericParametersAndArguments.html#generic_parameter_list) [*约束子句*](GenericParametersAndArguments.html#requirement_clause) _可选_ **>**
> *泛型参数列表* → [*泛形参数*](GenericParametersAndArguments.html#generic_parameter) | [*泛形参数*](GenericParametersAndArguments.html#generic_parameter) **,** [*泛型参数列表*](GenericParametersAndArguments.html#generic_parameter_list) > *泛型参数列表* → [*泛形参数*](GenericParametersAndArguments.html#generic_parameter) | [*泛形参数*](GenericParametersAndArguments.html#generic_parameter) **,** [*泛型参数列表*](GenericParametersAndArguments.html#generic_parameter_list)
> *泛形参数* → [*类型名称*](..\chapter3\03_Types.html#type_name) > *泛形参数* → [*类型名称*](..\chapter3\03_Types.html#type_name)
> *泛形参数* → [*类型名称*](..\chapter3\03_Types.html#type_name) **:** [*类型标识*](..\chapter3\03_Types.html#type_identifier) > *泛形参数* → [*类型名称*](..\chapter3\03_Types.html#type_name) **:** [*类型标识*](..\chapter3\03_Types.html#type_identifier)
> *泛形参数* → [*类型名称*](..\chapter3\03_Types.html#type_name) **:** [*协议合成类型*](..\chapter3\03_Types.html#protocol_composition_type) > *泛形参数* → [*类型名称*](..\chapter3\03_Types.html#type_name) **:** [*协议合成类型*](..\chapter3\03_Types.html#protocol_composition_type)
> *约束子句* → **where** [*约束列表*](GenericParametersAndArguments.html#requirement_list) > *约束子句* → **where** [*约束列表*](GenericParametersAndArguments.html#requirement_list)
> *约束列表* → [*约束*](GenericParametersAndArguments.html#requirement) | [*约束*](GenericParametersAndArguments.html#requirement) **,** [*约束列表*](GenericParametersAndArguments.html#requirement_list) > *约束列表* → [*约束*](GenericParametersAndArguments.html#requirement) | [*约束*](GenericParametersAndArguments.html#requirement) **,** [*约束列表*](GenericParametersAndArguments.html#requirement_list)
> *约束* → [*一致性约束*](GenericParametersAndArguments.html#conformance_requirement) | [*同类型约束*](GenericParametersAndArguments.html#same_type_requirement) > *约束* → [*一致性约束*](GenericParametersAndArguments.html#conformance_requirement) | [*同类型约束*](GenericParametersAndArguments.html#same_type_requirement)
> *一致性约束* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) **:** [*类型标识*](..\chapter3\03_Types.html#type_identifier) > *一致性约束* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) **:** [*类型标识*](..\chapter3\03_Types.html#type_identifier)
> *一致性约束* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) **:** [*协议合成类型*](..\chapter3\03_Types.html#protocol_composition_type) > *一致性约束* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) **:** [*协议合成类型*](..\chapter3\03_Types.html#protocol_composition_type)
> *同类型约束* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) **==** [*类型标识*](..\chapter3\03_Types.html#type_identifier) > *同类型约束* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) **==** [*类型标识*](..\chapter3\03_Types.html#type_identifier)
<a name="generic_argument"></a> <a name="generic_argument"></a>
## 泛型实参子句 ## 泛型实参子句
泛型实参子句指定_泛型类型_的类型实参。泛型实参子句用尖括号（<>）包住，形式如下： 泛型实参子句指定_泛型类型_的类型实参。泛型实参子句用尖括号（<>）包住，形式如下：
> <`generic argument list`> > <`generic argument list`>
泛型实参列表中类型实参有逗号分开。类型实参是实际具体类型的名字，用来替代泛型类型的泛型形参子句中的相应的类型形参。从而得到泛型类型的一个特化版本。如，Swift标准库的泛型字典类型定义如下： 泛型实参列表中类型实参有逗号分开。类型实参是实际具体类型的名字，用来替代泛型类型的泛型形参子句中的相应的类型形参。从而得到泛型类型的一个特化版本。如，Swift标准库的泛型字典类型定义如下：
```swift ```swift
struct Dictionary<KeyTypel: Hashable, ValueType>: Collection, DictionaryLiteralConvertible { struct Dictionary<KeyTypel: Hashable, ValueType>: Collection, DictionaryLiteralConvertible {
/* .. */ /* .. */
} }
``` ```
泛型`Dictionary`类型的特化版本，`Dictionary<String, Int>`就是用具体的`String`和`Int`类型替代泛型类型`KeyType: Hashable`和`ValueType`产生的。每一个类型实参必须满足它所替代的泛型形参的所有约束，包括任何`where`子句所指定的额外的要求。上面的例子中，类型形参`KeyType`要求满足`Hashable`协议，因此`String`也必须满足`Hashable`协议。 泛型`Dictionary`类型的特化版本，`Dictionary<String, Int>`就是用具体的`String`和`Int`类型替代泛型类型`KeyType: Hashable`和`ValueType`产生的。每一个类型实参必须满足它所替代的泛型形参的所有约束，包括任何`where`子句所指定的额外的要求。上面的例子中，类型形参`KeyType`要求满足`Hashable`协议，因此`String`也必须满足`Hashable`协议。
可以用本身就是泛型类型的特化版本的类型实参替代类型形参（假设已满足合适的约束和要求）。例如，为了生成一个元素类型是整型数组的数组，可以用数组的特化版本`Array<Int>`替代泛型类型`Array<T>`的类型形参`T`来实现。 可以用本身就是泛型类型的特化版本的类型实参替代类型形参（假设已满足合适的约束和要求）。例如，为了生成一个元素类型是整型数组的数组，可以用数组的特化版本`Array<Int>`替代泛型类型`Array<T>`的类型形参`T`来实现。
```swift ```swift
let arrayOfArrays: Array<Array<Int>> = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] let arrayOfArrays: Array<Array<Int>> = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
``` ```
如[泛型形参子句](#generic_parameter)所述，不能用泛型实参子句来指定泛型函数或构造器的类型实参。 如[泛型形参子句](#generic_parameter)所述，不能用泛型实参子句来指定泛型函数或构造器的类型实参。
> 泛型实参子句语法 > 泛型实参子句语法
> *(泛型参数子句Generic Argument Clause)* → **<** [*泛型参数列表*](GenericParametersAndArguments.html#generic_argument_list) **>** > *(泛型参数子句Generic Argument Clause)* → **<** [*泛型参数列表*](GenericParametersAndArguments.html#generic_argument_list) **>**
> *泛型参数列表* → [*泛型参数*](GenericParametersAndArguments.html#generic_argument) | [*泛型参数*](GenericParametersAndArguments.html#generic_argument) **,** [*泛型参数列表*](GenericParametersAndArguments.html#generic_argument_list) > *泛型参数列表* → [*泛型参数*](GenericParametersAndArguments.html#generic_argument) | [*泛型参数*](GenericParametersAndArguments.html#generic_argument) **,** [*泛型参数列表*](GenericParametersAndArguments.html#generic_argument_list)
> *泛型参数* → [*类型*](..\chapter3\03_Types.html#type) > *泛型参数* → [*类型*](..\chapter3\03_Types.html#type)

1486
source/chapter3/09_Summary_of_the_Grammar.md
View File

File diff suppressed because it is too large Load Diff

644
source/chapter3/10_Statements.md
View File

@ -1,322 +1,322 @@
> 翻译：[coverxit](https://github.com/coverxit) > 翻译：[coverxit](https://github.com/coverxit)
> 校对：[numbbbbb](https://github.com/numbbbbb), [coverxit](https://github.com/coverxit), [stanzhai](https://github.com/stanzhai) > 校对：[numbbbbb](https://github.com/numbbbbb), [coverxit](https://github.com/coverxit), [stanzhai](https://github.com/stanzhai)
# 语句 # 语句
----------------- -----------------
本页包含内容： 本页包含内容：
- [循环语句](#loop_statements) - [循环语句](#loop_statements)
- [分支语句](#branch_statements) - [分支语句](#branch_statements)
- [带标签的语句](#labeled_statement) - [带标签的语句](#labeled_statement)
- [控制传递语句](#control_transfer_statements) - [控制传递语句](#control_transfer_statements)
在 Swift 中，有两种类型的语句：简单语句和控制流语句。简单语句是最常见的，用于构造表达式和声明。控制流语句则用于控制程序执行的流程，Swift 中有三种类型的控制流语句：循环语句、分支语句和控制传递语句。 在 Swift 中，有两种类型的语句：简单语句和控制流语句。简单语句是最常见的，用于构造表达式和声明。控制流语句则用于控制程序执行的流程，Swift 中有三种类型的控制流语句：循环语句、分支语句和控制传递语句。
循环语句用于重复执行代码块；分支语句用于执行满足特定条件的代码块；控制传递语句则用于修改代码的执行顺序。在稍后的叙述中，将会详细地介绍每一种类型的控制流语句。 循环语句用于重复执行代码块；分支语句用于执行满足特定条件的代码块；控制传递语句则用于修改代码的执行顺序。在稍后的叙述中，将会详细地介绍每一种类型的控制流语句。
是否将分号（`;`）添加到语句的结尾处是可选的。但若要在同一行内写多条独立语句，请务必使用分号。 是否将分号（`;`）添加到语句的结尾处是可选的。但若要在同一行内写多条独立语句，请务必使用分号。
> 语句语法 > 语句语法
> *语句* → [*表达式*](..\chapter3\04_Expressions.html#expression) **;** _可选_ > *语句* → [*表达式*](..\chapter3\04_Expressions.html#expression) **;** _可选_
> *语句* → [*声明*](..\chapter3\05_Declarations.html#declaration) **;** _可选_ > *语句* → [*声明*](..\chapter3\05_Declarations.html#declaration) **;** _可选_
> *语句* → [*循环语句*](..\chapter3\10_Statements.html#loop_statement) **;** _可选_ > *语句* → [*循环语句*](..\chapter3\10_Statements.html#loop_statement) **;** _可选_
> *语句* → [*分支语句*](..\chapter3\10_Statements.html#branch_statement) **;** _可选_ > *语句* → [*分支语句*](..\chapter3\10_Statements.html#branch_statement) **;** _可选_
> *语句* → [*标记语句(Labeled Statement)*](..\chapter3\10_Statements.html#labeled_statement) > *语句* → [*标记语句(Labeled Statement)*](..\chapter3\10_Statements.html#labeled_statement)
> *语句* → [*控制转移语句*](..\chapter3\10_Statements.html#control_transfer_statement) **;** _可选_ > *语句* → [*控制转移语句*](..\chapter3\10_Statements.html#control_transfer_statement) **;** _可选_
> *多条语句(Statements)* → [*语句*](..\chapter3\10_Statements.html#statement) [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) _可选_ > *多条语句(Statements)* → [*语句*](..\chapter3\10_Statements.html#statement) [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) _可选_
<a name="loop_statements"></a> <a name="loop_statements"></a>
## 循环语句 ## 循环语句
取决于特定的循环条件，循环语句允许重复执行代码块。Swift 提供四种类型的循环语句：`for`语句、`for-in`语句、`while`语句和`do-while`语句。 取决于特定的循环条件，循环语句允许重复执行代码块。Swift 提供四种类型的循环语句：`for`语句、`for-in`语句、`while`语句和`do-while`语句。
通过`break`语句和`continue`语句可以改变循环语句的控制流。有关这两条语句，详情参见 [Break 语句](#break_statement)和 [Continue 语句](#continue_statement)。 通过`break`语句和`continue`语句可以改变循环语句的控制流。有关这两条语句，详情参见 [Break 语句](#break_statement)和 [Continue 语句](#continue_statement)。
> 循环语句语法 > 循环语句语法
> *循环语句* → [*for语句*](..\chapter3\10_Statements.html#for_statement) > *循环语句* → [*for语句*](..\chapter3\10_Statements.html#for_statement)
> *循环语句* → [*for-in语句*](..\chapter3\10_Statements.html#for_in_statement) > *循环语句* → [*for-in语句*](..\chapter3\10_Statements.html#for_in_statement)
> *循环语句* → [*while语句*](..\chapter3\10_Statements.html#wheetatype类型ile_statement) > *循环语句* → [*while语句*](..\chapter3\10_Statements.html#wheetatype类型ile_statement)
> *循环语句* → [*do-while语句*](..\chapter3\10_Statements.html#do_while_statement) > *循环语句* → [*do-while语句*](..\chapter3\10_Statements.html#do_while_statement)
### For 语句 ### For 语句
`for`语句允许在重复执行代码块的同时，递增一个计数器。 `for`语句允许在重复执行代码块的同时，递增一个计数器。
`for`语句的形式如下： `for`语句的形式如下：
> for `initialzation`; `condition`; `increment` { > for `initialzation`; `condition`; `increment` {
> `statements` > `statements`
> } > }
*initialzation*、*condition* 和 *increment* 之间的分号，以及包围循环体 *statements* 的大括号都是不可省略的。 *initialzation*、*condition* 和 *increment* 之间的分号，以及包围循环体 *statements* 的大括号都是不可省略的。
`for`语句的执行流程如下： `for`语句的执行流程如下：
1. *initialzation* 只会被执行一次，通常用于声明和初始化在接下来的循环中需要使用的变量。 1. *initialzation* 只会被执行一次，通常用于声明和初始化在接下来的循环中需要使用的变量。
2. 计算 *condition* 表达式： 2. 计算 *condition* 表达式：
如果为`true`，*statements* 将会被执行，然后转到第3步。如果为`false`，*statements* 和 *increment* 都不会被执行，`for`至此执行完毕。 如果为`true`，*statements* 将会被执行，然后转到第3步。如果为`false`，*statements* 和 *increment* 都不会被执行，`for`至此执行完毕。
3. 计算 *increment* 表达式，然后转到第2步。 3. 计算 *increment* 表达式，然后转到第2步。
定义在 *initialzation* 中的变量仅在`for`语句的作用域以内有效。*condition* 表达式的值的类型必须遵循`LogicValue`协议。 定义在 *initialzation* 中的变量仅在`for`语句的作用域以内有效。*condition* 表达式的值的类型必须遵循`LogicValue`协议。
> For 循环语法 > For 循环语法
> *for语句* → **for** [*for初始条件*](..\chapter3\10_Statements.html#for_init) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block) > *for语句* → **for** [*for初始条件*](..\chapter3\10_Statements.html#for_init) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block)
> *for语句* → **for** **(** [*for初始条件*](..\chapter3\10_Statements.html#for_init) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ **)** [*代码块*](..\chapter3\05_Declarations.html#code_block) > *for语句* → **for** **(** [*for初始条件*](..\chapter3\10_Statements.html#for_init) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ **)** [*代码块*](..\chapter3\05_Declarations.html#code_block)
> *for初始条件* → [*变量声明*](..\chapter3\05_Declarations.html#variable_declaration) | [*表达式列表*](..\chapter3\04_Expressions.html#expression_list) > *for初始条件* → [*变量声明*](..\chapter3\05_Declarations.html#variable_declaration) | [*表达式列表*](..\chapter3\04_Expressions.html#expression_list)
### For-In 语句 ### For-In 语句
`for-in`语句允许在重复执行代码块的同时，迭代集合（或遵循`Sequence`协议的任意类型）中的每一项。 `for-in`语句允许在重复执行代码块的同时，迭代集合（或遵循`Sequence`协议的任意类型）中的每一项。
`for-in`语句的形式如下： `for-in`语句的形式如下：
> for `item` in `collection` { > for `item` in `collection` {
> `statements` > `statements`
> } > }
`for-in`语句在循环开始前会调用 *collection* 表达式的`generate`方法来获取一个生成器类型（这是一个遵循`Generator`协议的类型）的值。接下来循环开始，调用 *collection* 表达式的`next`方法。如果其返回值不是`None`，它将会被赋给 *item*，然后执行 *statements*，执行完毕后回到循环开始处；否则，将不会赋值给 *item* 也不会执行 *statements*，`for-in`至此执行完毕。 `for-in`语句在循环开始前会调用 *collection* 表达式的`generate`方法来获取一个生成器类型（这是一个遵循`Generator`协议的类型）的值。接下来循环开始，调用 *collection* 表达式的`next`方法。如果其返回值不是`None`，它将会被赋给 *item*，然后执行 *statements*，执行完毕后回到循环开始处；否则，将不会赋值给 *item* 也不会执行 *statements*，`for-in`至此执行完毕。
> For-In 循环语法 > For-In 循环语法
> *for-in语句* → **for** [*模式*](..\chapter3\07_Patterns.html#pattern) **in** [*表达式*](..\chapter3\04_Expressions.html#expression) [*代码块*](..\chapter3\05_Declarations.html#code_block) > *for-in语句* → **for** [*模式*](..\chapter3\07_Patterns.html#pattern) **in** [*表达式*](..\chapter3\04_Expressions.html#expression) [*代码块*](..\chapter3\05_Declarations.html#code_block)
### While 语句 ### While 语句
`while`语句允许重复执行代码块。 `while`语句允许重复执行代码块。
`while`语句的形式如下： `while`语句的形式如下：
> while `condition` { > while `condition` {
> `statements` > `statements`
> } > }
`while`语句的执行流程如下： `while`语句的执行流程如下：
1. 计算 *condition* 表达式： 1. 计算 *condition* 表达式：
如果为真`true`，转到第2步。如果为`false`，`while`至此执行完毕。 如果为真`true`，转到第2步。如果为`false`，`while`至此执行完毕。
2. 执行 *statements* ，然后转到第1步。 2. 执行 *statements* ，然后转到第1步。
由于 *condition* 的值在 *statements* 执行前就已计算出，因此`while`语句中的 *statements* 可能会被执行若干次，也可能不会被执行。 由于 *condition* 的值在 *statements* 执行前就已计算出，因此`while`语句中的 *statements* 可能会被执行若干次，也可能不会被执行。
*condition* 表达式的值的类型必须遵循`LogicValue`协议。同时，*condition* 表达式也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。 *condition* 表达式的值的类型必须遵循`LogicValue`协议。同时，*condition* 表达式也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
> While 循环语法 > While 循环语法
> *while语句* → **while** [*while条件*](..\chapter3\10_Statements.html#while_condition) [*代码块*](..\chapter3\05_Declarations.html#code_block) > *while语句* → **while** [*while条件*](..\chapter3\10_Statements.html#while_condition) [*代码块*](..\chapter3\05_Declarations.html#code_block)
> *while条件* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*声明*](..\chapter3\05_Declarations.html#declaration) > *while条件* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*声明*](..\chapter3\05_Declarations.html#declaration)
### Do-While 语句 ### Do-While 语句
`do-while`语句允许代码块被执行一次或多次。 `do-while`语句允许代码块被执行一次或多次。
`do-while`语句的形式如下： `do-while`语句的形式如下：
> do { > do {
> `statements` > `statements`
> } while `condition` > } while `condition`
`do-while`语句的执行流程如下： `do-while`语句的执行流程如下：
1. 执行 *statements*，然后转到第2步。 1. 执行 *statements*，然后转到第2步。
2. 计算 *condition* 表达式： 2. 计算 *condition* 表达式：
如果为`true`，转到第1步。如果为`false`，`do-while`至此执行完毕。 如果为`true`，转到第1步。如果为`false`，`do-while`至此执行完毕。
由于 *condition* 表达式的值是在 *statements* 执行后才计算出，因此`do-while`语句中的 *statements* 至少会被执行一次。 由于 *condition* 表达式的值是在 *statements* 执行后才计算出，因此`do-while`语句中的 *statements* 至少会被执行一次。
*condition* 表达式的值的类型必须遵循`LogicValue`协议。同时，*condition* 表达式也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。 *condition* 表达式的值的类型必须遵循`LogicValue`协议。同时，*condition* 表达式也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
> Do-While 循环语法 > Do-While 循环语法
> *do-while语句* → **do** [*代码块*](..\chapter3\05_Declarations.html#code_block) **while** [*while条件*](..\chapter3\10_Statements.html#while_condition) > *do-while语句* → **do** [*代码块*](..\chapter3\05_Declarations.html#code_block) **while** [*while条件*](..\chapter3\10_Statements.html#while_condition)
<a name="branch_statements"></a> <a name="branch_statements"></a>
## 分支语句 ## 分支语句
取决于一个或者多个条件的值，分支语句允许程序执行指定部分的代码。显然，分支语句中条件的值将会决定如何分支以及执行哪一块代码。Swift 提供两种类型的分支语句：`if`语句和`switch`语句。 取决于一个或者多个条件的值，分支语句允许程序执行指定部分的代码。显然，分支语句中条件的值将会决定如何分支以及执行哪一块代码。Swift 提供两种类型的分支语句：`if`语句和`switch`语句。
`switch`语句中的控制流可以用`break`语句修改，详情请见[Break 语句](#break_statement)。 `switch`语句中的控制流可以用`break`语句修改，详情请见[Break 语句](#break_statement)。
> 分支语句语法 > 分支语句语法
> *分支语句* → [*if语句*](..\chapter3\10_Statements.html#if_statement) > *分支语句* → [*if语句*](..\chapter3\10_Statements.html#if_statement)
> *分支语句* → [*switch语句*](..\chapter3\10_Statements.html#switch_statement) > *分支语句* → [*switch语句*](..\chapter3\10_Statements.html#switch_statement)
### If 语句 ### If 语句
取决于一个或多个条件的值，`if`语句将决定执行哪一块代码。 取决于一个或多个条件的值，`if`语句将决定执行哪一块代码。
`if`语句有两种标准形式，在这两种形式里都必须有大括号。 `if`语句有两种标准形式，在这两种形式里都必须有大括号。
第一种形式是当且仅当条件为真时执行代码，像下面这样： 第一种形式是当且仅当条件为真时执行代码，像下面这样：
> if `condition` { > if `condition` {
> `statements` > `statements`
> } > }
第二种形式是在第一种形式的基础上添加 *else 语句*，当只有一个 else 语句时，像下面这样： 第二种形式是在第一种形式的基础上添加 *else 语句*，当只有一个 else 语句时，像下面这样：
> if `condition` { > if `condition` {
> `statements to execute if condition is true` > `statements to execute if condition is true`
> } else { > } else {
> `statements to execute if condition is false` > `statements to execute if condition is false`
> } > }
同时，else 语句也可包含`if`语句，从而形成一条链来测试更多的条件，像下面这样： 同时，else 语句也可包含`if`语句，从而形成一条链来测试更多的条件，像下面这样：
> if `condition 1` { > if `condition 1` {
> `statements to execute if condition 1 is true` > `statements to execute if condition 1 is true`
> } else if `condition 2` { > } else if `condition 2` {
> `statements to execute if condition 2 is true` > `statements to execute if condition 2 is true`
> } > }
> else { > else {
> `statements to execute if both conditions are false` > `statements to execute if both conditions are false`
> } > }
`if`语句中条件的值的类型必须遵循`LogicValue`协议。同时，条件也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。 `if`语句中条件的值的类型必须遵循`LogicValue`协议。同时，条件也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
> If语句语法 > If语句语法
> *if语句* → **if** [*if条件*](..\chapter3\10_Statements.html#if_condition) [*代码块*](..\chapter3\05_Declarations.html#code_block) [*else子句(Clause)*](..\chapter3\10_Statements.html#else_clause) _可选_ > *if语句* → **if** [*if条件*](..\chapter3\10_Statements.html#if_condition) [*代码块*](..\chapter3\05_Declarations.html#code_block) [*else子句(Clause)*](..\chapter3\10_Statements.html#else_clause) _可选_
> *if条件* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*声明*](..\chapter3\05_Declarations.html#declaration) > *if条件* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*声明*](..\chapter3\05_Declarations.html#declaration)
> *else子句(Clause)* → **else** [*代码块*](..\chapter3\05_Declarations.html#code_block) | **else** [*if语句*](..\chapter3\10_Statements.html#if_statement) > *else子句(Clause)* → **else** [*代码块*](..\chapter3\05_Declarations.html#code_block) | **else** [*if语句*](..\chapter3\10_Statements.html#if_statement)
### Switch 语句 ### Switch 语句
取决于`switch`语句的*控制表达式（control expression）*，`switch`语句将决定执行哪一块代码。 取决于`switch`语句的*控制表达式（control expression）*，`switch`语句将决定执行哪一块代码。
`switch`语句的形式如下： `switch`语句的形式如下：
> switch `control expression` { > switch `control expression` {
> case `pattern 1`: > case `pattern 1`:
> `statements` > `statements`
> case `pattern 2` where `condition`: > case `pattern 2` where `condition`:
> `statements` > `statements`
> case `pattern 3` where `condition`, > case `pattern 3` where `condition`,
> `pattern 4` where `condition`: > `pattern 4` where `condition`:
> `statements` > `statements`
> default: > default:
> `statements` > `statements`
> } > }
`switch`语句的*控制表达式（control expression）*会首先被计算，然后与每一个 case 的模式（pattern）进行匹配。如果匹配成功，程序将会执行对应的 case 分支里的 *statements*。另外，每一个 case 分支都不能为空，也就是说在每一个 case 分支中至少有一条语句。如果你不想在匹配到的 case 分支中执行代码，只需在该分支里写一条`break`语句即可。 `switch`语句的*控制表达式（control expression）*会首先被计算，然后与每一个 case 的模式（pattern）进行匹配。如果匹配成功，程序将会执行对应的 case 分支里的 *statements*。另外，每一个 case 分支都不能为空，也就是说在每一个 case 分支中至少有一条语句。如果你不想在匹配到的 case 分支中执行代码，只需在该分支里写一条`break`语句即可。
可以用作控制表达式的值是十分灵活的，除了标量类型(scalar types，如`Int`、`Character`)外，你可以使用任何类型的值，包括浮点数、字符串、元组、自定义类的实例和可选（optional）类型，甚至是枚举类型中的成员值和指定的范围(range)等。关于在`switch`语句中使用这些类型，详情参见[控制流](../chapter2/05_Control_Flow.html)一章的 [Switch](../chapter2/05_Control_Flow.html#switch)。 可以用作控制表达式的值是十分灵活的，除了标量类型(scalar types，如`Int`、`Character`)外，你可以使用任何类型的值，包括浮点数、字符串、元组、自定义类的实例和可选（optional）类型，甚至是枚举类型中的成员值和指定的范围(range)等。关于在`switch`语句中使用这些类型，详情参见[控制流](../chapter2/05_Control_Flow.html)一章的 [Switch](../chapter2/05_Control_Flow.html#switch)。
你可以在模式后面添加一个起保护作用的表达式(guard expression)。*起保护作用的表达式*是这样构成的：关键字`where`后面跟着一个作为额外测试条件的表达式。因此，当且仅当*控制表达式*匹配一个*case*的某个模式且起保护作用的表达式为真时，对应 case 分支中的 *statements* 才会被执行。在下面的例子中，*控制表达式*只会匹配含两个相等元素的元组，如`(1, 1)`： 你可以在模式后面添加一个起保护作用的表达式(guard expression)。*起保护作用的表达式*是这样构成的：关键字`where`后面跟着一个作为额外测试条件的表达式。因此，当且仅当*控制表达式*匹配一个*case*的某个模式且起保护作用的表达式为真时，对应 case 分支中的 *statements* 才会被执行。在下面的例子中，*控制表达式*只会匹配含两个相等元素的元组，如`(1, 1)`：
```swift ```swift
case let (x, y) where x == y: case let (x, y) where x == y:
``` ```
正如上面这个例子，也可以在模式中使用`let`（或`var`）语句来绑定常量（或变量）。这些常量（或变量）可以在其对应的起保护作用的表达式和其对应的*case*块里的代码中引用。但是，如果 case 中有多个模式匹配控制表达式，那么这些模式都不能绑定常量（或变量）。 正如上面这个例子，也可以在模式中使用`let`（或`var`）语句来绑定常量（或变量）。这些常量（或变量）可以在其对应的起保护作用的表达式和其对应的*case*块里的代码中引用。但是，如果 case 中有多个模式匹配控制表达式，那么这些模式都不能绑定常量（或变量）。
`switch`语句也可以包含默认（`default`）分支，只有其它 case 分支都无法匹配控制表达式时，默认分支中的代码才会被执行。一个`switch`语句只能有一个默认分支，而且必须在`switch`语句的最后面。 `switch`语句也可以包含默认（`default`）分支，只有其它 case 分支都无法匹配控制表达式时，默认分支中的代码才会被执行。一个`switch`语句只能有一个默认分支，而且必须在`switch`语句的最后面。
尽管模式匹配操作实际的执行顺序，特别是模式的计算顺序是不可知的，但是 Swift 规定`switch`语句中的模式匹配的顺序和书写源代码的顺序保持一致。因此，当多个模式含有相同的值且能够匹配控制表达式时，程序只会执行源代码中第一个匹配的 case 分支中的代码。 尽管模式匹配操作实际的执行顺序，特别是模式的计算顺序是不可知的，但是 Swift 规定`switch`语句中的模式匹配的顺序和书写源代码的顺序保持一致。因此，当多个模式含有相同的值且能够匹配控制表达式时，程序只会执行源代码中第一个匹配的 case 分支中的代码。
#### Switch 语句必须是完备的 #### Switch 语句必须是完备的
在 Swift 中，`switch`语句中控制表达式的每一个可能的值都必须至少有一个 case 分支与之对应。在某些情况下（例如，表达式的类型是`Int`），你可以使用默认块满足该要求。 在 Swift 中，`switch`语句中控制表达式的每一个可能的值都必须至少有一个 case 分支与之对应。在某些情况下（例如，表达式的类型是`Int`），你可以使用默认块满足该要求。
#### 不存在隐式的贯穿(fall through) #### 不存在隐式的贯穿(fall through)
当匹配的 case 分支中的代码执行完毕后，程序会终止`switch`语句，而不会继续执行下一个 case 分支。这就意味着，如果你想执行下一个 case 分支，需要显式地在你需要的 case 分支里使用`fallthrough`语句。关于`fallthrough`语句的更多信息，详情参见 [Fallthrough 语句](#fallthrough_statement)。 当匹配的 case 分支中的代码执行完毕后，程序会终止`switch`语句，而不会继续执行下一个 case 分支。这就意味着，如果你想执行下一个 case 分支，需要显式地在你需要的 case 分支里使用`fallthrough`语句。关于`fallthrough`语句的更多信息，详情参见 [Fallthrough 语句](#fallthrough_statement)。
> Switch语句语法 > Switch语句语法
> *switch语句* → **switch** [*表达式*](..\chapter3\04_Expressions.html#expression) **{** [*SwitchCase列表*](..\chapter3\10_Statements.html#switch_cases) _可选_ **}** > *switch语句* → **switch** [*表达式*](..\chapter3\04_Expressions.html#expression) **{** [*SwitchCase列表*](..\chapter3\10_Statements.html#switch_cases) _可选_ **}**
> *SwitchCase列表* → [*SwitchCase*](..\chapter3\10_Statements.html#switch_case) [*SwitchCase列表*](..\chapter3\10_Statements.html#switch_cases) _可选_ > *SwitchCase列表* → [*SwitchCase*](..\chapter3\10_Statements.html#switch_case) [*SwitchCase列表*](..\chapter3\10_Statements.html#switch_cases) _可选_
> *SwitchCase* → [*case标签*](..\chapter3\10_Statements.html#case_label) [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) | [*default标签*](..\chapter3\10_Statements.html#default_label) [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) > *SwitchCase* → [*case标签*](..\chapter3\10_Statements.html#case_label) [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) | [*default标签*](..\chapter3\10_Statements.html#default_label) [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements)
> *SwitchCase* → [*case标签*](..\chapter3\10_Statements.html#case_label) **;** | [*default标签*](..\chapter3\10_Statements.html#default_label) **;** > *SwitchCase* → [*case标签*](..\chapter3\10_Statements.html#case_label) **;** | [*default标签*](..\chapter3\10_Statements.html#default_label) **;**
> *case标签* → **case** [*case项列表*](..\chapter3\10_Statements.html#case_item_list) **:** > *case标签* → **case** [*case项列表*](..\chapter3\10_Statements.html#case_item_list) **:**
> *case项列表* → [*模式*](..\chapter3\07_Patterns.html#pattern) [*guard-clause*](..\chapter3\10_Statements.html#guard_clause) _可选_ | [*模式*](..\chapter3\07_Patterns.html#pattern) [*guard-clause*](..\chapter3\10_Statements.html#guard_clause) _可选_ **,** [*case项列表*](..\chapter3\10_Statements.html#case_item_list) > *case项列表* → [*模式*](..\chapter3\07_Patterns.html#pattern) [*guard-clause*](..\chapter3\10_Statements.html#guard_clause) _可选_ | [*模式*](..\chapter3\07_Patterns.html#pattern) [*guard-clause*](..\chapter3\10_Statements.html#guard_clause) _可选_ **,** [*case项列表*](..\chapter3\10_Statements.html#case_item_list)
> *default标签* → **default** **:** > *default标签* → **default** **:**
> *guard-clause* → **where** [*guard-expression*](..\chapter3\10_Statements.html#guard_expression) > *guard-clause* → **where** [*guard-expression*](..\chapter3\10_Statements.html#guard_expression)
> *guard-expression* → [*表达式*](..\chapter3\04_Expressions.html#expression) > *guard-expression* → [*表达式*](..\chapter3\04_Expressions.html#expression)
<a name="labeled_statement"></a> <a name="labeled_statement"></a>
<a name="control_transfer_statements"></a> 带标签的语句 <a name="control_transfer_statements"></a> 带标签的语句
你可以在循环语句或`switch`语句前面加上*标签*，它由标签名和紧随其后的冒号(:)组成。在`break`和`continue`后面跟上标签名可以显式地在循环语句或`switch`语句中更改控制流，把控制权传递给指定标签标记的语句。关于这两条语句用法，详情参见 [Break 语句](#break_statement)和 [Continue 语句](#continue_statement)。 你可以在循环语句或`switch`语句前面加上*标签*，它由标签名和紧随其后的冒号(:)组成。在`break`和`continue`后面跟上标签名可以显式地在循环语句或`switch`语句中更改控制流，把控制权传递给指定标签标记的语句。关于这两条语句用法，详情参见 [Break 语句](#break_statement)和 [Continue 语句](#continue_statement)。
标签的作用域是该标签所标记的语句之后的所有语句。你可以不使用带标签的语句，但只要使用它，标签名就必唯一。 标签的作用域是该标签所标记的语句之后的所有语句。你可以不使用带标签的语句，但只要使用它，标签名就必唯一。
关于使用带标签的语句的例子，详情参见[控制流](../chapter2/05_Control_Flow.html)一章的[带标签的语句](../chapter2/05_Control_Flow.html#labeled_statements)。 关于使用带标签的语句的例子，详情参见[控制流](../chapter2/05_Control_Flow.html)一章的[带标签的语句](../chapter2/05_Control_Flow.html#labeled_statements)。
> 标记语句语法 > 标记语句语法
> *标记语句(Labeled Statement)* → [*语句标签*](..\chapter3\10_Statements.html#statement_label) [*循环语句*](..\chapter3\10_Statements.html#loop_statement) | [*语句标签*](..\chapter3\10_Statements.html#statement_label) [*switch语句*](..\chapter3\10_Statements.html#switch_statement) > *标记语句(Labeled Statement)* → [*语句标签*](..\chapter3\10_Statements.html#statement_label) [*循环语句*](..\chapter3\10_Statements.html#loop_statement) | [*语句标签*](..\chapter3\10_Statements.html#statement_label) [*switch语句*](..\chapter3\10_Statements.html#switch_statement)
> *语句标签* → [*标签名称*](..\chapter3\10_Statements.html#label_name) **:** > *语句标签* → [*标签名称*](..\chapter3\10_Statements.html#label_name) **:**
> *标签名称* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) > *标签名称* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)
## 控制传递语句 ## 控制传递语句
通过无条件地把控制权从一片代码传递到另一片代码，控制传递语句能够改变代码执行的顺序。Swift 提供四种类型的控制传递语句：`break`语句、`continue`语句、`fallthrough`语句和`return`语句。 通过无条件地把控制权从一片代码传递到另一片代码，控制传递语句能够改变代码执行的顺序。Swift 提供四种类型的控制传递语句：`break`语句、`continue`语句、`fallthrough`语句和`return`语句。
> 控制传递语句(Control Transfer Statement) 语法 > 控制传递语句(Control Transfer Statement) 语法
> *控制传递语句* → [*break语句*](..\chapter3\10_Statements.html#break_statement) > *控制传递语句* → [*break语句*](..\chapter3\10_Statements.html#break_statement)
> *控制传递语句* → [*continue语句*](..\chapter3\10_Statements.html#continue_statement) > *控制传递语句* → [*continue语句*](..\chapter3\10_Statements.html#continue_statement)
> *控制传递语句* → [*fallthrough语句*](..\chapter3\10_Statements.html#fallthrough_statement) > *控制传递语句* → [*fallthrough语句*](..\chapter3\10_Statements.html#fallthrough_statement)
> *控制传递语句* → [*return语句*](..\chapter3\10_Statements.html#return_statement) > *控制传递语句* → [*return语句*](..\chapter3\10_Statements.html#return_statement)
<a name="break_statement"></a> <a name="break_statement"></a>
### Break 语句 ### Break 语句
`break`语句用于终止循环或`switch`语句的执行。使用`break`语句时，可以只写`break`这个关键词，也可以在`break`后面跟上标签名（label name），像下面这样： `break`语句用于终止循环或`switch`语句的执行。使用`break`语句时，可以只写`break`这个关键词，也可以在`break`后面跟上标签名（label name），像下面这样：
> break > break
> break `label name` > break `label name`
当`break`语句后面带标签名时，可用于终止由这个标签标记的循环或`switch`语句的执行。 当`break`语句后面带标签名时，可用于终止由这个标签标记的循环或`switch`语句的执行。
而当只写`break`时，则会终止`switch`语句或上下文中包含`break`语句的最内层循环的执行。 而当只写`break`时，则会终止`switch`语句或上下文中包含`break`语句的最内层循环的执行。
在这两种情况下，控制权都会被传递给循环或`switch`语句外面的第一行语句。 在这两种情况下，控制权都会被传递给循环或`switch`语句外面的第一行语句。
关于使用`break`语句的例子，详情参见[控制流](../chapter2/05_Control_Flow.html)一章的 [Break](../chapter2/05_Control_Flow.html#break) 和[带标签的语句](../chapter2/05_Control_Flow.html#labeled_statements)。 关于使用`break`语句的例子，详情参见[控制流](../chapter2/05_Control_Flow.html)一章的 [Break](../chapter2/05_Control_Flow.html#break) 和[带标签的语句](../chapter2/05_Control_Flow.html#labeled_statements)。
> Break 语句语法 > Break 语句语法
> *break语句* → **break** [*标签名称*](..\chapter3\10_Statements.html#label_name) _可选_ > *break语句* → **break** [*标签名称*](..\chapter3\10_Statements.html#label_name) _可选_
<a name="continue_statement"></a> <a name="continue_statement"></a>
### Continue 语句 ### Continue 语句
`continue`语句用于终止循环中当前迭代的执行，但不会终止该循环的执行。使用`continue`语句时，可以只写`continue`这个关键词，也可以在`continue`后面跟上标签名（label name），像下面这样： `continue`语句用于终止循环中当前迭代的执行，但不会终止该循环的执行。使用`continue`语句时，可以只写`continue`这个关键词，也可以在`continue`后面跟上标签名（label name），像下面这样：
> continue > continue
> continue `label name` > continue `label name`
当`continue`语句后面带标签名时，可用于终止由这个标签标记的循环中当前迭代的执行。 当`continue`语句后面带标签名时，可用于终止由这个标签标记的循环中当前迭代的执行。
而当只写`break`时，可用于终止上下文中包含`continue`语句的最内层循环中当前迭代的执行。 而当只写`break`时，可用于终止上下文中包含`continue`语句的最内层循环中当前迭代的执行。
在这两种情况下，控制权都会被传递给循环外面的第一行语句。 在这两种情况下，控制权都会被传递给循环外面的第一行语句。
在`for`语句中，`continue`语句执行后，*increment* 表达式还是会被计算，这是因为每次循环体执行完毕后 *increment* 表达式都会被计算。 在`for`语句中，`continue`语句执行后，*increment* 表达式还是会被计算，这是因为每次循环体执行完毕后 *increment* 表达式都会被计算。
关于使用`continue`语句的例子，详情参见[控制流](../chapter2/05_Control_Flow.html)一章的 [Continue](../chapter2/05_Control_Flow.html#continue) 和[带标签的语句](../chapter2/05_Control_Flow.html#labeled_statements)。 关于使用`continue`语句的例子，详情参见[控制流](../chapter2/05_Control_Flow.html)一章的 [Continue](../chapter2/05_Control_Flow.html#continue) 和[带标签的语句](../chapter2/05_Control_Flow.html#labeled_statements)。
> Continue 语句语法 > Continue 语句语法
> *continue语句* → **continue** [*标签名称*](..\chapter3\10_Statements.html#label_name) _可选_ > *continue语句* → **continue** [*标签名称*](..\chapter3\10_Statements.html#label_name) _可选_
<a name="fallthrough_statement"></a> <a name="fallthrough_statement"></a>
### Fallthrough 语句 ### Fallthrough 语句
`fallthrough`语句用于在`switch`语句中传递控制权。`fallthrough`语句会把控制权从`switch`语句中的一个 case 传递给下一个 case 。这种传递是无条件的，即使下一个 case 的模式与`switch`语句的控制表达式的值不匹配。 `fallthrough`语句用于在`switch`语句中传递控制权。`fallthrough`语句会把控制权从`switch`语句中的一个 case 传递给下一个 case 。这种传递是无条件的，即使下一个 case 的模式与`switch`语句的控制表达式的值不匹配。
`fallthrough`语句可出现在`switch`语句中的任意 case 里，但不能出现在最后一个 case 分支中。同时，`fallthrough`语句也不能把控制权传递给使用了可选绑定的 case 分支。 `fallthrough`语句可出现在`switch`语句中的任意 case 里，但不能出现在最后一个 case 分支中。同时，`fallthrough`语句也不能把控制权传递给使用了可选绑定的 case 分支。
关于在`switch`语句中使用`fallthrough`语句的例子，详情参见[控制流](../chapter2/05_Control_Flow.html)一章的[控制传递语句](../chapter2/05_Control_Flow.html#control_transfer_statements)。 关于在`switch`语句中使用`fallthrough`语句的例子，详情参见[控制流](../chapter2/05_Control_Flow.html)一章的[控制传递语句](../chapter2/05_Control_Flow.html#control_transfer_statements)。
> Fallthrough 语句语法 > Fallthrough 语句语法
> *fallthrough语句* → **fallthrough** > *fallthrough语句* → **fallthrough**
### Return 语句 ### Return 语句
`return`语句用于在函数或方法的实现中将控制权传递给调用者，接着程序将会从调用者的位置继续向下执行。 `return`语句用于在函数或方法的实现中将控制权传递给调用者，接着程序将会从调用者的位置继续向下执行。
使用`return`语句时，可以只写`return`这个关键词，也可以在`return`后面跟上表达式，像下面这样： 使用`return`语句时，可以只写`return`这个关键词，也可以在`return`后面跟上表达式，像下面这样：
> return > return
> return `expression` > return `expression`
当`return`语句后面带表达式时，表达式的值将会返回给调用者。如果表达式值的类型与调用者期望的类型不匹配，Swift 则会在返回表达式的值之前将表达式值的类型转换为调用者期望的类型。 当`return`语句后面带表达式时，表达式的值将会返回给调用者。如果表达式值的类型与调用者期望的类型不匹配，Swift 则会在返回表达式的值之前将表达式值的类型转换为调用者期望的类型。
而当只写`return`时，仅仅是将控制权从该函数或方法传递给调用者，而不返回一个值。（这就是说，该函数或方法的返回类型为`Void`或`()`） 而当只写`return`时，仅仅是将控制权从该函数或方法传递给调用者，而不返回一个值。（这就是说，该函数或方法的返回类型为`Void`或`()`）
> Return 语句语法 > Return 语句语法
> *return语句* → **return** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ > *return语句* → **return** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_