-
-
- - 苹果全球开发者大会WWDC2014召开，发布了苹果最新的开发语言Swift，并释放出XCode6 Beta1版本 -
-
-
-### 便捷 setter 声明
-
-如果计算属性的 setter 没有定义表示新值的参数名，则可以使用默认名称`newValue`。下面是使用了便捷 setter 声明的`Rect`结构体代码：
-
-```swift
-struct AlternativeRect {
- var origin = Point()
- var size = Size()
- var center: Point {
- get {
- let centerX = origin.x + (size.width / 2)
- let centerY = origin.y + (size.height / 2)
- return Point(x: centerX, y: centerY)
- }
- set {
- origin.x = newValue.x - (size.width / 2)
- origin.y = newValue.y - (size.height / 2)
- }
- }
-}
-```
-
-
-### 只读计算属性
-
-只有 getter 没有 setter 的计算属性就是*只读计算属性*。只读计算属性总是返回一个值，可以通过点运算符访问，但不能设置新的值。
-
-> 注意
-> 必须使用`var`关键字定义计算属性，包括只读计算属性，因为它们的值不是固定的。`let`关键字只用来声明常量属性，表示初始化后再也无法修改的值。
-
-只读计算属性的声明可以去掉`get`关键字和花括号：
-
-```swift
-struct Cuboid {
- var width = 0.0, height = 0.0, depth = 0.0
- var volume: Double {
- return width * height * depth
- }
-}
-let fourByFiveByTwo = Cuboid(width: 4.0, height: 5.0, depth: 2.0)
-print("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")
-// 输出 "the volume of fourByFiveByTwo is 40.0"
-```
-
-这个例子定义了一个名为`Cuboid`的结构体，表示三维空间的立方体，包含`width`、`height`和`depth`属性。结构体还有一个名为`volume`的只读计算属性用来返回立方体的体积。为`volume`提供 setter 毫无意义，因为无法确定如何修改`width`、`height`和`depth`三者的值来匹配新的`volume`。然而，`Cuboid`提供一个只读计算属性来让外部用户直接获取体积是很有用的。
-
-
-## 属性观察器
-
-*属性观察器*监控和响应属性值的变化，每次属性被设置值的时候都会调用属性观察器，甚至新值和当前值相同的时候也不例外。
-
-可以为除了延迟存储属性之外的其他存储属性添加属性观察器，也可以通过重写属性的方式为继承的属性（包括存储属性和计算属性）添加属性观察器。属性重写请参考[重写](./13_Inheritance.html#overriding)。
-
-> 注意
-> 不需要为非重写的计算属性添加属性观察器，因为可以通过它的 setter 直接监控和响应值的变化。
-
-可以为属性添加如下的一个或全部观察器：
-
-- `willSet`在新的值被设置之前调用
-- `didSet`在新的值被设置之后立即调用
-
-`willSet`观察器会将新的属性值作为常量参数传入，在`willSet`的实现代码中可以为这个参数指定一个名称，如果不指定则参数仍然可用，这时使用默认名称`newValue`表示。
-
-类似地，`didSet`观察器会将旧的属性值作为参数传入，可以为该参数命名或者使用默认参数名`oldValue`。
-
-> 注意
-> 父类的属性在子类的构造器中被赋值时，它在父类中的`willSet`和`didSet`观察器会被调用。
-> 有关构造器代理的更多信息，请参考[值类型的构造器代理](./14_Initialization.html#initializer_delegation_for_value_types)和[类的构造器代理规则](./14_Initialization.html#initializer_delegation_for_class_types)。
-
-这里是一个`willSet`和`didSet`的实际例子，其中定义了一个名为`StepCounter`的类，用来统计一个人步行时的总步数。这个类可以跟计步器或其他日常锻炼的统计装置的输入数据配合使用。
-
-```swift
-class StepCounter {
- var totalSteps: Int = 0 {
- willSet(newTotalSteps) {
- print("About to set totalSteps to \(newTotalSteps)")
- }
- didSet {
- if totalSteps > oldValue {
- print("Added \(totalSteps - oldValue) steps")
- }
- }
- }
-}
-let stepCounter = StepCounter()
-stepCounter.totalSteps = 200
-// About to set totalSteps to 200
-// Added 200 steps
-stepCounter.totalSteps = 360
-// About to set totalSteps to 360
-// Added 160 steps
-stepCounter.totalSteps = 896
-// About to set totalSteps to 896
-// Added 536 steps
-```
-
-`StepCounter`类定义了一个`Int`类型的属性`totalSteps`，它是一个存储属性，包含`willSet`和`didSet`观察器。
-
-当`totalSteps`被设置新值的时候，它的`willSet`和`didSet`观察器都会被调用，甚至新值和当前值完全相同时也会被调用。
-
-例子中的`willSet`观察器将表示新值的参数自定义为`newTotalSteps`，这个观察器只是简单的将新的值输出。
-
-`didSet`观察器在`totalSteps`的值改变后被调用，它把新值和旧值进行对比，如果总步数增加了，就输出一个消息表示增加了多少步。`didSet`没有为旧值提供自定义名称，所以默认值`oldValue`表示旧值的参数名。
-
-> 注意
-> 如果在一个属性的`didSet`观察器里为它赋值，这个值会替换之前设置的值。
-
-
-##全局变量和局部变量
-
-计算属性和属性观察器所描述的功能也可以用于*全局变量*和*局部变量*。全局变量是在函数、方法、闭包或任何类型之外定义的变量。局部变量是在函数、方法或闭包内部定义的变量。
-
-前面章节提到的全局或局部变量都属于存储型变量，跟存储属性类似，它为特定类型的值提供存储空间，并允许读取和写入。
-
-另外，在全局或局部范围都可以定义计算型变量和为存储型变量定义观察器。计算型变量跟计算属性一样，返回一个计算结果而不是存储值，声明格式也完全一样。
-
-> 注意
-> 全局的常量或变量都是延迟计算的，跟[延迟存储属性](#lazy_stored_properties)相似，不同的地方在于，全局的常量或变量不需要标记`lazy`修饰符。
-> 局部范围的常量或变量从不延迟计算。
-
-
-##类型属性
-
-实例属性属于一个特定类型的实例，每创建一个实例，实例都拥有属于自己的一套属性值，实例之间的属性相互独立。
-
-也可以为类型本身定义属性，无论创建了多少个该类型的实例，这些属性都只有唯一一份。这种属性就是*类型属性*。
-
-类型属性用于定义某个类型所有实例共享的数据，比如所有实例都能用的一个常量（就像 C 语言中的静态常量），或者所有实例都能访问的一个变量（就像 C 语言中的静态变量）。
-
-存储型类型属性可以是变量或常量，计算型类型属性跟实例的计算型属性一样只能定义成变量属性。
-
-> 注意
-> 跟实例的存储型属性不同，必须给存储型类型属性指定默认值，因为类型本身没有构造器，也就无法在初始化过程中使用构造器给类型属性赋值。
-> 存储型类型属性是延迟初始化的，它们只有在第一次被访问的时候才会被初始化。即使它们被多个线程同时访问，系统也保证只会对其进行一次初始化，并且不需要对其使用`lazy`修饰符。
-
-
-###类型属性语法
-
-在 C 或 Objective-C 中，与某个类型关联的静态常量和静态变量，是作为全局（*global*）静态变量定义的。但是在 Swift 中，类型属性是作为类型定义的一部分写在类型最外层的花括号内，因此它的作用范围也就在类型支持的范围内。
-
-使用关键字`static`来定义类型属性。在为类定义计算型类型属性时，可以改用关键字`class`来支持子类对父类的实现进行重写。下面的例子演示了存储型和计算型类型属性的语法：
-
-```swift
-struct SomeStructure {
- static var storedTypeProperty = "Some value."
- static var computedTypeProperty: Int {
- return 1
- }
-}
-enum SomeEnumeration {
- static var storedTypeProperty = "Some value."
- static var computedTypeProperty: Int {
- return 6
- }
-}
-class SomeClass {
- static var storedTypeProperty = "Some value."
- static var computedTypeProperty: Int {
- return 27
- }
- class var overrideableComputedTypeProperty: Int {
- return 107
- }
-}
-```
-
-> 注意
-> 例子中的计算型类型属性是只读的，但也可以定义可读可写的计算型类型属性，跟计算型实例属性的语法相同。
-
-
-###获取和设置类型属性的值
-
-跟实例属性一样，类型属性也是通过点运算符来访问。但是，类型属性是通过类型本身来访问，而不是通过实例。比如：
-
-```swift
-print(SomeStructure.storedTypeProperty)
-// 输出 "Some value."
-SomeStructure.storedTypeProperty = "Another value."
-print(SomeStructure.storedTypeProperty)
-// 输出 "Another value.”
-print(SomeEnumeration.computedTypeProperty)
-// 输出 "6"
-print(SomeClass.computedTypeProperty)
-// 输出 "27"
-```
-
-下面的例子定义了一个结构体，使用两个存储型类型属性来表示两个声道的音量，每个声道具有`0`到`10`之间的整数音量。
-
-下图展示了如何把两个声道结合来模拟立体声的音量。当声道的音量是`0`，没有一个灯会亮；当声道的音量是`10`，所有灯点亮。本图中，左声道的音量是`9`，右声道的音量是`7`：
-
-
-
-上面所描述的声道模型使用`AudioChannel`结构体的实例来表示：
-
-```swift
-struct AudioChannel {
- static let thresholdLevel = 10
- static var maxInputLevelForAllChannels = 0
- var currentLevel: Int = 0 {
- didSet {
- if currentLevel > AudioChannel.thresholdLevel {
- // 将当前音量限制在阀值之内
- currentLevel = AudioChannel.thresholdLevel
- }
- if currentLevel > AudioChannel.maxInputLevelForAllChannels {
- // 存储当前音量作为新的最大输入音量
- AudioChannel.maxInputLevelForAllChannels = currentLevel
- }
- }
- }
-}
-```
-
-结构`AudioChannel`定义了 2 个存储型类型属性来实现上述功能。第一个是`thresholdLevel`，表示音量的最大上限阈值，它是一个值为`10`的常量，对所有实例都可见，如果音量高于`10`，则取最大上限值`10`（见后面描述）。
-
-第二个类型属性是变量存储型属性`maxInputLevelForAllChannels`，它用来表示所有`AudioChannel`实例的最大音量，初始值是`0`。
-
-`AudioChannel`也定义了一个名为`currentLevel`的存储型实例属性，表示当前声道现在的音量，取值为`0`到`10`。
-
-属性`currentLevel`包含`didSet`属性观察器来检查每次设置后的属性值，它做如下两个检查：
-
-- 如果`currentLevel`的新值大于允许的阈值`thresholdLevel`，属性观察器将`currentLevel`的值限定为阈值`thresholdLevel`。
-- 如果修正后的`currentLevel`值大于静态类型属性`maxInputLevelForAllChannels`的值，属性观察器就将新值保存在`maxInputLevelForAllChannels`中。
-
-> 注意
-> 在第一个检查过程中，`didSet`属性观察器将`currentLevel`设置成了不同的值，但这不会造成属性观察器被再次调用。
-
-可以使用结构体`AudioChannel`创建两个声道`leftChannel`和`rightChannel`，用以表示立体声系统的音量：
-
-```swift
-var leftChannel = AudioChannel()
-var rightChannel = AudioChannel()
-```
-
-如果将左声道的`currentLevel`设置成`7`，类型属性`maxInputLevelForAllChannels`也会更新成`7`：
-
-```swift
-leftChannel.currentLevel = 7
-print(leftChannel.currentLevel)
-// 输出 "7"
-print(AudioChannel.maxInputLevelForAllChannels)
-// 输出 "7"
-```
-
-如果试图将右声道的`currentLevel`设置成`11`，它会被修正到最大值`10`，同时`maxInputLevelForAllChannels`的值也会更新到`10`：
-
-```swift
-rightChannel.currentLevel = 11
-print(rightChannel.currentLevel)
-// 输出 "10"
-print(AudioChannel.maxInputLevelForAllChannels)
-// 输出 "10"
-```
+# 属性 (Properties)
+---
+
+> 1.0
+> 翻译：[shinyzhu](https://github.com/shinyzhu)
+> 校对：[pp-prog](https://github.com/pp-prog) [yangsiy](https://github.com/yangsiy)
+
+
+> 2.0
+> 翻译+校对：[yangsiy](https://github.com/yangsiy)
+
+
+> 2.1
+> 翻译：[buginux](https://github.com/buginux)
+> 校对：[shanks](http://codebuild.me)，2015-10-29
+
+
+> 2.2
+> 翻译：[saitjr](https://github.com/saitjr)，2016-04-11，[SketchK](https://github.com/SketchK) 2016-05-13
+
+
+
+本页包含内容：
+
+- [存储属性（Stored Properties）](#stored_properties)
+- [计算属性（Computed Properties）](#computed_properties)
+- [属性观察器（Property Observers）](#property_observers)
+- [全局变量和局部变量（Global and Local Variables）](#global_and_local_variables)
+- [类型属性（Type Properties）](#type_properties)
+
+*属性*将值跟特定的类、结构或枚举关联。存储属性存储常量或变量作为实例的一部分，而计算属性计算（不是存储）一个值。计算属性可以用于类、结构体和枚举，存储属性只能用于类和结构体。
+
+存储属性和计算属性通常与特定类型的实例关联。但是，属性也可以直接作用于类型本身，这种属性称为类型属性。
+
+另外，还可以定义属性观察器来监控属性值的变化，以此来触发一个自定义的操作。属性观察器可以添加到自己定义的存储属性上，也可以添加到从父类继承的属性上。
+
+
+## 存储属性
+
+简单来说，一个存储属性就是存储在特定类或结构体实例里的一个常量或变量。存储属性可以是*变量存储属性*（用关键字 `var` 定义），也可以是*常量存储属性*（用关键字 `let` 定义）。
+
+可以在定义存储属性的时候指定默认值，请参考[默认构造器](./14_Initialization.html#default_initializers)一节。也可以在构造过程中设置或修改存储属性的值，甚至修改常量存储属性的值，请参考[构造过程中常量属性的修改](./14_Initialization.html#assigning_constant_properties_during_initialization)一节。
+
+下面的例子定义了一个名为 `FixedLengthRange` 的结构体，该结构体用于描述整数的范围，且这个范围值在被创建后不能被修改.
+
+```swift
+struct FixedLengthRange {
+ var firstValue: Int
+ let length: Int
+}
+var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)
+// 该区间表示整数0，1，2
+rangeOfThreeItems.firstValue = 6
+// 该区间现在表示整数6，7，8
+```
+
+`FixedLengthRange` 的实例包含一个名为 `firstValue` 的变量存储属性和一个名为 `length` 的常量存储属性。在上面的例子中，`length` 在创建实例的时候被初始化，因为它是一个常量存储属性，所以之后无法修改它的值。
+
+
+### 常量结构体的存储属性
+
+如果创建了一个结构体的实例并将其赋值给一个常量，则无法修改该实例的任何属性，即使有属性被声明为变量也不行：
+
+```swift
+let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
+// 该区间表示整数0，1，2，3
+rangeOfFourItems.firstValue = 6
+// 尽管 firstValue 是个变量属性，这里还是会报错
+```
+
+因为 `rangeOfFourItems` 被声明成了常量（用 `let` 关键字），即使 `firstValue` 是一个变量属性，也无法再修改它了。
+
+这种行为是由于结构体（struct）属于*值类型*。当值类型的实例被声明为常量的时候，它的所有属性也就成了常量。
+
+属于*引用类型*的类（class）则不一样。把一个引用类型的实例赋给一个常量后，仍然可以修改该实例的变量属性。
+
+
+### 延迟存储属性
+
+延迟存储属性是指当第一次被调用的时候才会计算其初始值的属性。在属性声明前使用 `lazy` 来标示一个延迟存储属性。
+
+> 注意
+> 必须将延迟存储属性声明成变量（使用 `var` 关键字），因为属性的初始值可能在实例构造完成之后才会得到。而常量属性在构造过程完成之前必须要有初始值，因此无法声明成延迟属性。
+
+延迟属性很有用，当属性的值依赖于在实例的构造过程结束后才会知道影响值的外部因素时，或者当获得属性的初始值需要复杂或大量计算时，可以只在需要的时候计算它。
+
+下面的例子使用了延迟存储属性来避免复杂类中不必要的初始化。例子中定义了 `DataImporter` 和 `DataManager` 两个类，下面是部分代码：
+
+```swift
+class DataImporter {
+ /*
+ DataImporter 是一个负责将外部文件中的数据导入的类。
+ 这个类的初始化会消耗不少时间。
+ */
+ var fileName = "data.txt"
+ // 这里会提供数据导入功能
+}
+
+class DataManager {
+ lazy var importer = DataImporter()
+ var data = [String]()
+ // 这里会提供数据管理功能
+}
+
+let manager = DataManager()
+manager.data.append("Some data")
+manager.data.append("Some more data")
+// DataImporter 实例的 importer 属性还没有被创建
+```
+
+`DataManager` 类包含一个名为 `data` 的存储属性，初始值是一个空的字符串（`String`）数组。这里没有给出全部代码，只需知道 `DataManager` 类的目的是管理和提供对这个字符串数组的访问即可。
+
+`DataManager` 的一个功能是从文件导入数据。该功能由 `DataImporter` 类提供，`DataImporter` 完成初始化需要消耗不少时间：因为它的实例在初始化时可能要打开文件，还要读取文件内容到内存。
+
+`DataManager` 管理数据时也可能不从文件中导入数据。所以当 `DataManager` 的实例被创建时，没必要创建一个 `DataImporter` 的实例，更明智的做法是第一次用到 `DataImporter` 的时候才去创建它。
+
+由于使用了 `lazy` ，`importer` 属性只有在第一次被访问的时候才被创建。比如访问它的属性 `fileName` 时：
+
+```swift
+print(manager.importer.fileName)
+// DataImporter 实例的 importer 属性现在被创建了
+// 输出 "data.txt”
+```
+
+> 注意
+> 如果一个被标记为 `lazy` 的属性在没有初始化时就同时被多个线程访问，则无法保证该属性只会被初始化一次。
+
+
+### 存储属性和实例变量
+
+如果您有过 Objective-C 经验，应该知道 Objective-C 为类实例存储值和引用提供两种方法。除了属性之外，还可以使用实例变量作为属性值的后端存储。
+
+Swift 编程语言中把这些理论统一用属性来实现。Swift 中的属性没有对应的实例变量，属性的后端存储也无法直接访问。这就避免了不同场景下访问方式的困扰，同时也将属性的定义简化成一个语句。属性的全部信息——包括命名、类型和内存管理特征——都在唯一一个地方（类型定义中）定义。
+
+
+## 计算属性
+
+除存储属性外，类、结构体和枚举可以定义*计算属性*。计算属性不直接存储值，而是提供一个 getter 和一个可选的 setter，来间接获取和设置其他属性或变量的值。
+
+```swift
+struct Point {
+ var x = 0.0, y = 0.0
+}
+struct Size {
+ var width = 0.0, height = 0.0
+}
+struct Rect {
+ var origin = Point()
+ var size = Size()
+ var center: Point {
+ get {
+ let centerX = origin.x + (size.width / 2)
+ let centerY = origin.y + (size.height / 2)
+ return Point(x: centerX, y: centerY)
+ }
+ set(newCenter) {
+ origin.x = newCenter.x - (size.width / 2)
+ origin.y = newCenter.y - (size.height / 2)
+ }
+ }
+}
+var square = Rect(origin: Point(x: 0.0, y: 0.0),
+ size: Size(width: 10.0, height: 10.0))
+let initialSquareCenter = square.center
+square.center = Point(x: 15.0, y: 15.0)
+print("square.origin is now at (\(square.origin.x), \(square.origin.y))")
+// 输出 "square.origin is now at (10.0, 10.0)”
+```
+
+这个例子定义了 3 个结构体来描述几何形状：
+
+- `Point` 封装了一个 `(x, y)` 的坐标
+- `Size` 封装了一个 `width` 和一个 `height`
+- `Rect` 表示一个有原点和尺寸的矩形
+
+`Rect`也提供了一个名为`center` 的计算属性。一个矩形的中心点可以从原点（`origin`）和大小（`size`）算出，所以不需要将它以显式声明的 `Point` 来保存。`Rect` 的计算属性 `center` 提供了自定义的 getter 和 setter 来获取和设置矩形的中心点，就像它有一个存储属性一样。
+
+上述例子中创建了一个名为 `square` 的 `Rect` 实例，初始值原点是 `(0, 0)`，宽度高度都是 `10`。如下图中蓝色正方形所示。
+
+`square` 的 `center` 属性可以通过点运算符（`square.center`）来访问，这会调用该属性的 getter 来获取它的值。跟直接返回已经存在的值不同，getter 实际上通过计算然后返回一个新的 `Point` 来表示 `square` 的中心点。如代码所示，它正确返回了中心点 `(5, 5)`。
+
+`center` 属性之后被设置了一个新的值 `(15, 15)`，表示向右上方移动正方形到如下图橙色正方形所示的位置。设置属性`center`的值会调用它的 setter 来修改属性 `origin` 的 `x` 和 `y` 的值，从而实现移动正方形到新的位置。
+
+
+
+
+### 便捷 setter 声明
+
+如果计算属性的 setter 没有定义表示新值的参数名，则可以使用默认名称 `newValue`。下面是使用了便捷 setter 声明的 `Rect` 结构体代码：
+
+```swift
+struct AlternativeRect {
+ var origin = Point()
+ var size = Size()
+ var center: Point {
+ get {
+ let centerX = origin.x + (size.width / 2)
+ let centerY = origin.y + (size.height / 2)
+ return Point(x: centerX, y: centerY)
+ }
+ set {
+ origin.x = newValue.x - (size.width / 2)
+ origin.y = newValue.y - (size.height / 2)
+ }
+ }
+}
+```
+
+
+### 只读计算属性
+
+只有 getter 没有 setter 的计算属性就是*只读计算属性*。只读计算属性总是返回一个值，可以通过点运算符访问，但不能设置新的值。
+
+> 注意
+> 必须使用 `var` 关键字定义计算属性，包括只读计算属性，因为它们的值不是固定的。`let` 关键字只用来声明常量属性，表示初始化后再也无法修改的值。
+
+只读计算属性的声明可以去掉 `get` 关键字和花括号：
+
+```swift
+struct Cuboid {
+ var width = 0.0, height = 0.0, depth = 0.0
+ var volume: Double {
+ return width * height * depth
+ }
+}
+let fourByFiveByTwo = Cuboid(width: 4.0, height: 5.0, depth: 2.0)
+print("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")
+// 输出 "the volume of fourByFiveByTwo is 40.0"
+```
+
+这个例子定义了一个名为 `Cuboid` 的结构体，表示三维空间的立方体，包含 `width`、`height` 和 `depth` 属性。结构体还有一个名为 `volume` 的只读计算属性用来返回立方体的体积。为 `volume` 提供 setter 毫无意义，因为无法确定如何修改 `width`、`height` 和 `depth` 三者的值来匹配新的 `volume`。然而，`Cuboid` 提供一个只读计算属性来让外部用户直接获取体积是很有用的。
+
+
+## 属性观察器
+
+*属性观察器*监控和响应属性值的变化，每次属性被设置值的时候都会调用属性观察器，即使新值和当前值相同的时候也不例外。
+
+可以为除了延迟存储属性之外的其他存储属性添加属性观察器，也可以通过重写属性的方式为继承的属性（包括存储属性和计算属性）添加属性观察器。你不必为非重写的计算属性添加属性观察器，因为可以通过它的 setter 直接监控和响应值的变化。 属性重写请参考[重写](./13_Inheritance.html#overriding)。
+
+
+可以为属性添加如下的一个或全部观察器：
+
+- `willSet` 在新的值被设置之前调用
+- `didSet` 在新的值被设置之后立即调用
+
+`willSet` 观察器会将新的属性值作为常量参数传入，在 `willSet` 的实现代码中可以为这个参数指定一个名称，如果不指定则参数仍然可用，这时使用默认名称 `newValue` 表示。
+
+同样，`didSet` 观察器会将旧的属性值作为参数传入，可以为该参数命名或者使用默认参数名 `oldValue`。如果在 `didSet` 方法中再次对该属性赋值，那么新值会覆盖旧的值。
+
+> 注意
+> 父类的属性在子类的构造器中被赋值时，它在父类中的 `willSet` 和 `didSet` 观察器会被调用，随后才会调用子类的观察器。在父类初始化方法调用之前，子类给属性赋值时，观察器不会被调用。
+> 有关构造器代理的更多信息，请参考[值类型的构造器代理](./14_Initialization.html#initializer_delegation_for_value_types)和[类的构造器代理规则](./14_Initialization.html#initializer_delegation_for_class_types)。
+
+下面是一个 `willSet` 和 `didSet` 实际运用的例子，其中定义了一个名为 `StepCounter` 的类，用来统计一个人步行时的总步数。这个类可以跟计步器或其他日常锻炼的统计装置的输入数据配合使用。
+
+```swift
+class StepCounter {
+ var totalSteps: Int = 0 {
+ willSet(newTotalSteps) {
+ print("About to set totalSteps to \(newTotalSteps)")
+ }
+ didSet {
+ if totalSteps > oldValue {
+ print("Added \(totalSteps - oldValue) steps")
+ }
+ }
+ }
+}
+let stepCounter = StepCounter()
+stepCounter.totalSteps = 200
+// About to set totalSteps to 200
+// Added 200 steps
+stepCounter.totalSteps = 360
+// About to set totalSteps to 360
+// Added 160 steps
+stepCounter.totalSteps = 896
+// About to set totalSteps to 896
+// Added 536 steps
+```
+
+`StepCounter` 类定义了一个 `Int` 类型的属性 `totalSteps`，它是一个存储属性，包含 `willSet` 和 `didSet` 观察器。
+
+当 `totalSteps` 被设置新值的时候，它的 `willSet` 和 `didSet` 观察器都会被调用，即使新值和当前值完全相同时也会被调用。
+
+例子中的 `willSet` 观察器将表示新值的参数自定义为 `newTotalSteps`，这个观察器只是简单的将新的值输出。
+
+`didSet` 观察器在 `totalSteps` 的值改变后被调用，它把新值和旧值进行对比，如果总步数增加了，就输出一个消息表示增加了多少步。`didSet` 没有为旧值提供自定义名称，所以默认值 `oldValue` 表示旧值的参数名。
+
+>注意
+>
+>如果将属性通过 in-out 方式传入函数，`willSet` 和 `didSet` 也会调用。这是因为 in-out 参数采用了拷入拷出模式：即在函数内部使用的是参数的 copy，函数结束后，又对参数重新赋值。关于 in-out 参数详细的介绍，请参考[输入输出参数](../chapter3/05_Declarations.html#in-out_parameters)
+
+
+##全局变量和局部变量
+
+计算属性和属性观察器所描述的功能也可以用于*全局变量*和*局部变量*。全局变量是在函数、方法、闭包或任何类型之外定义的变量。局部变量是在函数、方法或闭包内部定义的变量。
+
+前面章节提到的全局或局部变量都属于存储型变量，跟存储属性类似，它为特定类型的值提供存储空间，并允许读取和写入。
+
+另外，在全局或局部范围都可以定义计算型变量和为存储型变量定义观察器。计算型变量跟计算属性一样，返回一个计算结果而不是存储值，声明格式也完全一样。
+
+> 注意
+> 全局的常量或变量都是延迟计算的，跟[延迟存储属性](#lazy_stored_properties)相似，不同的地方在于，全局的常量或变量不需要标记`lazy`修饰符。
+> 局部范围的常量或变量从不延迟计算。
+
+
+##类型属性
+
+实例属性属于一个特定类型的实例，每创建一个实例，实例都拥有属于自己的一套属性值，实例之间的属性相互独立。
+
+也可以为类型本身定义属性，无论创建了多少个该类型的实例，这些属性都只有唯一一份。这种属性就是*类型属性*。
+
+类型属性用于定义某个类型所有实例共享的数据，比如所有实例都能用的一个常量（就像 C 语言中的静态常量），或者所有实例都能访问的一个变量（就像 C 语言中的静态变量）。
+
+存储型类型属性可以是变量或常量，计算型类型属性跟实例的计算型属性一样只能定义成变量属性。
+
+> 注意
+> 跟实例的存储型属性不同，必须给存储型类型属性指定默认值，因为类型本身没有构造器，也就无法在初始化过程中使用构造器给类型属性赋值。
+> 存储型类型属性是延迟初始化的，它们只有在第一次被访问的时候才会被初始化。即使它们被多个线程同时访问，系统也保证只会对其进行一次初始化，并且不需要对其使用 `lazy` 修饰符。
+
+
+###类型属性语法
+
+在 C 或 Objective-C 中，与某个类型关联的静态常量和静态变量，是作为全局（*global*）静态变量定义的。但是在 Swift 中，类型属性是作为类型定义的一部分写在类型最外层的花括号内，因此它的作用范围也就在类型支持的范围内。
+
+使用关键字 `static` 来定义类型属性。在为类定义计算型类型属性时，可以改用关键字 `class` 来支持子类对父类的实现进行重写。下面的例子演示了存储型和计算型类型属性的语法：
+
+```swift
+struct SomeStructure {
+ static var storedTypeProperty = "Some value."
+ static var computedTypeProperty: Int {
+ return 1
+ }
+}
+enum SomeEnumeration {
+ static var storedTypeProperty = "Some value."
+ static var computedTypeProperty: Int {
+ return 6
+ }
+}
+class SomeClass {
+ static var storedTypeProperty = "Some value."
+ static var computedTypeProperty: Int {
+ return 27
+ }
+ class var overrideableComputedTypeProperty: Int {
+ return 107
+ }
+}
+```
+
+> 注意
+> 例子中的计算型类型属性是只读的，但也可以定义可读可写的计算型类型属性，跟计算型实例属性的语法相同。
+
+
+###获取和设置类型属性的值
+
+跟实例属性一样，类型属性也是通过点运算符来访问。但是，类型属性是通过类型本身来访问，而不是通过实例。比如：
+
+```swift
+print(SomeStructure.storedTypeProperty)
+// 输出 "Some value."
+SomeStructure.storedTypeProperty = "Another value."
+print(SomeStructure.storedTypeProperty)
+// 输出 "Another value.”
+print(SomeEnumeration.computedTypeProperty)
+// 输出 "6"
+print(SomeClass.computedTypeProperty)
+// 输出 "27"
+```
+
+下面的例子定义了一个结构体，使用两个存储型类型属性来表示两个声道的音量，每个声道具有 `0` 到 `10` 之间的整数音量。
+
+下图展示了如何把两个声道结合来模拟立体声的音量。当声道的音量是 `0`，没有一个灯会亮；当声道的音量是 `10`，所有灯点亮。本图中，左声道的音量是 `9`，右声道的音量是 `7`：
+
+
+
+上面所描述的声道模型使用 `AudioChannel` 结构体的实例来表示：
+
+```swift
+struct AudioChannel {
+ static let thresholdLevel = 10
+ static var maxInputLevelForAllChannels = 0
+ var currentLevel: Int = 0 {
+ didSet {
+ if currentLevel > AudioChannel.thresholdLevel {
+ // 将当前音量限制在阀值之内
+ currentLevel = AudioChannel.thresholdLevel
+ }
+ if currentLevel > AudioChannel.maxInputLevelForAllChannels {
+ // 存储当前音量作为新的最大输入音量
+ AudioChannel.maxInputLevelForAllChannels = currentLevel
+ }
+ }
+ }
+}
+```
+
+结构 `AudioChannel` 定义了 2 个存储型类型属性来实现上述功能。第一个是 `thresholdLevel`，表示音量的最大上限阈值，它是一个值为 `10` 的常量，对所有实例都可见，如果音量高于 `10`，则取最大上限值 `10`（见后面描述）。
+
+第二个类型属性是变量存储型属性 `maxInputLevelForAllChannels`，它用来表示所有 `AudioChannel` 实例的最大音量，初始值是`0`。
+
+`AudioChannel` 也定义了一个名为 `currentLevel` 的存储型实例属性，表示当前声道现在的音量，取值为 `0` 到 `10`。
+
+属性 `currentLevel` 包含 `didSet` 属性观察器来检查每次设置后的属性值，它做如下两个检查：
+
+- 如果 `currentLevel` 的新值大于允许的阈值 `thresholdLevel`，属性观察器将 `currentLevel` 的值限定为阈值 `thresholdLevel`。
+- 如果修正后的 `currentLevel` 值大于静态类型属性 `maxInputLevelForAllChannels` 的值，属性观察器就将新值保存在 `maxInputLevelForAllChannels` 中。
+
+> 注意
+> 在第一个检查过程中，`didSet` 属性观察器将 `currentLevel` 设置成了不同的值，但这不会造成属性观察器被再次调用。
+
+可以使用结构体 `AudioChannel` 创建两个声道 `leftChannel` 和 `rightChannel`，用以表示立体声系统的音量：
+
+```swift
+var leftChannel = AudioChannel()
+var rightChannel = AudioChannel()
+```
+
+如果将左声道的 `currentLevel` 设置成 `7`，类型属性 `maxInputLevelForAllChannels` 也会更新成 `7`：
+
+```swift
+leftChannel.currentLevel = 7
+print(leftChannel.currentLevel)
+// 输出 "7"
+print(AudioChannel.maxInputLevelForAllChannels)
+// 输出 "7"
+```
+
+如果试图将右声道的 `currentLevel` 设置成 `11`，它会被修正到最大值 `10`，同时 `maxInputLevelForAllChannels` 的值也会更新到 `10`：
+
+```swift
+rightChannel.currentLevel = 11
+print(rightChannel.currentLevel)
+// 输出 "10"
+print(AudioChannel.maxInputLevelForAllChannels)
+// 输出 "10"
+```
diff --git a/source/chapter2/11_Methods.md b/source/chapter2/11_Methods.md
index 1f775c78..437d533c 100755
--- a/source/chapter2/11_Methods.md
+++ b/source/chapter2/11_Methods.md
@@ -9,7 +9,10 @@
> 翻译+校对：[DianQK](https://github.com/DianQK)
> 2.1
-> 翻译：[DianQK](https://github.com/DianQK)，[Realank](https://github.com/Realank) 校对：[shanks](http://codebuild.me)，2016-01-18
+> 翻译：[DianQK](https://github.com/DianQK)，[Realank](https://github.com/Realank) 校对：[shanks](http://codebuild.me)，2016-01-18
+>
+> 2.2
+> 校对：[SketchK](https://github.com/SketchK) 2016-05-13
本页包含内容：
@@ -33,7 +36,7 @@
class Counter {
var count = 0
func increment() {
- ++count
+ count += 1
}
func incrementBy(amount: Int) {
count += amount
@@ -112,7 +115,7 @@ counter.incrementBy(5, numberOfTimes: 3)
```swift
func increment() {
- self.count++
+ self.count += 1
}
```
@@ -224,7 +227,7 @@ ovenLight.next()
```swift
class SomeClass {
- static func someTypeMethod() {
+ class func someTypeMethod() {
// type method implementation goes here
}
}
diff --git a/source/chapter2/12_Subscripts.md b/source/chapter2/12_Subscripts.md
index 8b2f89f2..8c48dfa6 100755
--- a/source/chapter2/12_Subscripts.md
+++ b/source/chapter2/12_Subscripts.md
@@ -9,7 +9,10 @@
> 翻译+校对：[shanks](http://codebuild.me)
> 2.1
-> 翻译+校对：[shanks](http://codebuild.me)，[Realank](https://github.com/Realank)
+> 翻译+校对：[shanks](http://codebuild.me)，[Realank](https://github.com/Realank)
+
+> 2.2
+> 校对：[SketchK](https://github.com/SketchK) 2016-05-13
本页包含内容：
diff --git a/source/chapter2/13_Inheritance.md b/source/chapter2/13_Inheritance.md
index 17c8f717..64028c3d 100755
--- a/source/chapter2/13_Inheritance.md
+++ b/source/chapter2/13_Inheritance.md
@@ -6,11 +6,14 @@
> 校对：[menlongsheng](https://github.com/menlongsheng)
> 2.0，2.1
-> 翻译+校对：[shanks](http://codebuild.me)
+> 翻译+校对：[shanks](http://codebuild.me)
+>
+> 2.2
+> 校对：[SketchK](https://github.com/SketchK) 2016-05-13
本页包含内容：
-- [定义一个基类（Base class）](#defining_a_base_class)
+- [定义一个基类（Defining a Base Class）](#defining_a_base_class)
- [子类生成（Subclassing）](#subclassing)
- [重写（Overriding）](#overriding)
- [防止重写（Preventing Overrides）](#preventing_overrides)
@@ -22,7 +25,7 @@
可以为类中继承来的属性添加属性观察器（property observers），这样一来，当属性值改变时，类就会被通知到。可以为任何属性添加属性观察器，无论它原本被定义为存储型属性（stored property）还是计算型属性（computed property）。
-## 定义一个基类（Base class）
+## 定义一个基类（Defining a Base Class）
不继承于其它类的类，称之为*基类（base class）*。
@@ -233,6 +236,6 @@ print("AutomaticCar: \(automatic.description)")
你可以通过把方法，属性或下标标记为*`final`*来防止它们被重写，只需要在声明关键字前加上`final`修饰符即可（例如：`final var`，`final func`，`final class func`，以及`final subscript`）。
-如果你重写了`final`方法，属性或下标，在编译时会报错。在类扩展中的方法，属性或下标也可以在扩展的定义里标记为 final 的。
+如果你重写了带有`final`标记的方法，属性或下标，在编译时会报错。在类扩展中的方法，属性或下标也可以在扩展的定义里标记为 final 的。
你可以通过在关键字`class`前添加`final`修饰符（`final class`）来将整个类标记为 final 的。这样的类是不可被继承的，试图继承这样的类会导致编译报错。
diff --git a/source/chapter2/14_Initialization.md b/source/chapter2/14_Initialization.md
index 65ac194d..16f73f68 100755
--- a/source/chapter2/14_Initialization.md
+++ b/source/chapter2/14_Initialization.md
@@ -12,6 +12,10 @@
> 翻译：[Channe](https://github.com/Channe)，[Realank](https://github.com/Realank)
> 校对：[shanks](http://codebuild.me)，2016-1-23
+> 2.2
+> 翻译：[pmst](https://github.com/colourful987)
+> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-14
+
本页包含内容：
- [存储属性的初始赋值](#setting_initial_values_for_stored_properties)
@@ -277,9 +281,9 @@ let twoByTwo = Size(width: 2.0, height: 2.0)
构造器代理的实现规则和形式在值类型和类类型中有所不同。值类型（结构体和枚举类型）不支持继承，所以构造器代理的过程相对简单，因为它们只能代理给自己的其它构造器。类则不同，它可以继承自其它类（请参考[继承](./13_Inheritance.html)），这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。这些责任将在后续章节[类的继承和构造过程](#class_inheritance_and_initialization)中介绍。
-对于值类型，你可以使用`self.init`在自定义的构造器中引用类型中的其它构造器。并且你只能在构造器内部调用`self.init`。
+对于值类型，你可以使用`self.init`在自定义的构造器中引用相同类型中的其它构造器。并且你只能在构造器内部调用`self.init`。
-如果你为某个值类型定义了一个自定义的构造器，你将无法访问到默认构造器（如果是结构体，还将无法访问逐一成员构造器）。这个限制可以防止你为值类型定义了一个进行额外必要设置的复杂构造器之后，别人还是错误地使用了一个自动生成的构造器。
+如果你为某个值类型定义了一个自定义的构造器，你将无法访问到默认构造器（如果是结构体，还将无法访问逐一成员构造器）。这种限制可以防止你为值类型增加了一个额外的且十分复杂的构造器之后,仍然有人错误的使用自动生成的构造器
> 注意
假如你希望默认构造器、逐一成员构造器以及你自己的自定义构造器都能用来创建实例，可以将自定义的构造器写到扩展（`extension`）中，而不是写在值类型的原始定义中。想查看更多内容，请查看[扩展](./21_Extensions.html)章节。
@@ -486,7 +490,7 @@ Swift 编译器将执行 4 种有效的安全检查，以确保两段式构造
### 构造器的继承和重写
-跟 Objective-C 中的子类不同，Swift 中的子类默认情况下不会继承父类的构造器。Swift 的这种机制可以防止一个父类的简单构造器被一个更专业的子类继承，并被错误地用来创建子类的实例。
+跟 Objective-C 中的子类不同，Swift 中的子类默认情况下不会继承父类的构造器。Swift 的这种机制可以防止一个父类的简单构造器被一个更精细的子类继承，并被错误地用来创建子类的实例。
> 注意
父类的构造器仅会在安全和适当的情况下被继承。具体内容请参考后续章节[构造器的自动继承](#automatic_initializer_inheritance)。
@@ -606,7 +610,7 @@ let mysteryMeat = Food()
// mysteryMeat 的名字是 [Unnamed]
```
-类层级中的第二个类是`Food`的子类`RecipeIngredient`。`RecipeIngredient`类构建了食谱中的一味调味剂。它引入了`Int`类型的属性`quantity`（以及从`Food`继承过来的`name`属性），并且定义了两个构造器来创建`RecipeIngredient`实例：
+类层级中的第二个类是`Food`的子类`RecipeIngredient`。`RecipeIngredient`类用来表示食谱中的一项原料。它引入了`Int`类型的属性`quantity`（以及从`Food`继承过来的`name`属性），并且定义了两个构造器来创建`RecipeIngredient`实例：
```swift
class RecipeIngredient: Food {
@@ -643,7 +647,7 @@ let oneBacon = RecipeIngredient(name: "Bacon")
let sixEggs = RecipeIngredient(name: "Eggs", quantity: 6)
```
-类层级中第三个也是最后一个类是`RecipeIngredient`的子类，叫做`ShoppingListItem`。这个类构建了购物单中出现的某一种调味料。
+类层级中第三个也是最后一个类是`RecipeIngredient`的子类，叫做`ShoppingListItem`。这个类构建了购物单中出现的某一种食谱原料。
购物单中的每一项总是从未购买状态开始的。为了呈现这一事实，`ShoppingListItem`引入了一个布尔类型的属性`purchased`，它的默认值是`false`。`ShoppingListItem`还添加了一个计算型属性`description`，它提供了关于`ShoppingListItem`实例的一些文字描述：
@@ -807,46 +811,6 @@ if unknownUnit == nil {
// 打印 "This is not a defined temperature unit, so initialization failed."
```
-
-### 类的可失败构造器
-
-值类型（也就是结构体或枚举）的可失败构造器，可以在构造过程中的任意时间点触发构造失败。比如在前面的例子中，结构体`Animal`的可失败构造器在构造过程一开始就触发了构造失败，甚至在`species`属性被初始化前。
-
-而对类而言，可失败构造器只能在类引入的所有存储型属性被初始化后，以及构造器代理调用完成后，才能触发构造失败。
-
-下面例子展示了如何在类的可失败构造器中使用隐式解包可选类型来满足上述要求：
-
-```swift
-class Product {
- let name: String!
- init?(name: String) {
- self.name = name
- if name.isEmpty { return nil }
- }
-}
-```
-
-上面定义的`Product`类和之前的`Animal`结构体很相似。`Product`类有一个不能为空字符串的常量属性`name`。为了强制这个要求，`Product`类使用了可失败构造器确保这个属性的值不是空字符串后，才允许构造成功。
-
-毕竟，`Product`是一个类而不是结构体，这意味着不同于`Animal`，`Product`类的所有可失败构造器必须给`name`属性一个初始值，然后才能触发构造失败。
-
-上面的例子中，`Product`类的`name`属性被定义为隐式解包可选字符串类型（`String!`）。因为它是一个可选类型，所以它在构造过程中被赋值前，具有默认值`nil`。这个默认值`nil`意味着`Product`类引入的所有存储型属性都有一个有效的初始值。因此，一旦传入一个空字符串，该可失败构造器可以在`name`属性被赋值前触发构造失败。
-
-> 译者注
-> 上面的示例代码和描述并不相符，根据描述，`if name.isEmpty { return nil }`这句代码应该在`self.name = name`之前，而这却会导致编译错误`error: all stored properties of a class instance must be initialized before returning nil from an initializer`，除非将`let name: String!`改为`var name: String!`。
->
-> 根据前面的介绍和实测，常量存储属性，只能被初始化一次。上面的代码，在构造器中有初始化常量属性`name`的过程，所以在此之前不会被赋予默认值`nil`，而在构造器的初始化`name`过程之前，因为并不是所有存储型属性都被初始化，是不可以返回`nil`的；而如果将`name`声明为变量存储属性，那么就可以被多次赋值，所以在执行构造器方法之前，就会获得默认值`nil`，和构造器中的再次赋值并不冲突，所以此时，`if name.isEmpty { return nil }`才可以放在构造器前面。英文原文在这里表述有误
-
-因为`name`属性是一个常量，所以一旦构造成功，`name`属性肯定有一个非`nil`的值。即使它被定义为隐式解包可选类型，也完全可以放心大胆地直接访问，而不用检查`name`属性的值是否为`nil`：
-
-```swift
-if let bowTie = Product(name: "bow tie") {
- // 不需要检查 bowTie.name 是否为 nil
- print("The product's name is \(bowTie.name)")
-}
-// 打印 "The product's name is bow tie"
-```
-
### 构造失败的传递
@@ -859,36 +823,38 @@ if let bowTie = Product(name: "bow tie") {
下面这个例子，定义了一个名为`CartItem`的`Product`类的子类。这个类建立了一个在线购物车中的物品的模型，它有一个名为`quantity`的常量存储型属性，并确保该属性的值至少为`1`：
+
```swift
+class Product {
+ let name: String
+ init?(name: String) {
+ if name.isEmpty { return nil }
+ self.name = name
+ }
+}
+
class CartItem: Product {
- let quantity: Int!
+ let quantity: Int
init?(name: String, quantity: Int) {
+ if quantity < 1 { return nil }
self.quantity = quantity
super.init(name: name)
- if quantity < 1 { return nil }
}
}
```
-和`Product`类中的`name`属性类似，`CartItem`类中的`quantity`属性也是隐式解包可选类型。这意味着在构造过程中，该属性在被赋予特定的值之前能有一个默认的初始值`nil`。
+`CartItem` 可失败构造器首先验证接收的 `quantity` 值是否大于等于 1 。倘若 `quantity` 值无效，则立即终止整个构造过程，返回失败结果，且不再执行余下代码。同样地，`Product` 的可失败构造器首先检查 `name` 值，假如 `name` 值为空字符串，则构造器立即执行失败。
-该可失败构造器以向上代理到父类的可失败构造器`init(name:)`开始。这满足了可失败构造器在触发构造失败前必须总是完成构造器代理调用这个条件。
-
-如果由于`name`的值为空字符串而导致父类的可失败构造器构造失败，则`CartIem`类的整个构造过程都将立即失败，之后的构造代码将不会再被执行。如果父类构造成功，`CartIem`的可失败构造器会进一步验证`quantity`的值是否不小于`1`。
-
-> 译者注
-> 上面的示例代码和描述也不相符，`name`属性在被赋予特定的值之前不能获得一个默认的初始值`nil`，并且根据描述，`self.quantity = quantity`这句代码应该放在最后一行，而这却会导致编译错误`error: property 'self.quantity' not initialized at super.init call`，除非将`let quantity: Int!`改为`var quantity: Int!`。
-
-如果你构造一个`name`的值为非空字符串，`quantity`的值不小于`1`的`CartItem`实例，则可成功构造：
+如果你通过传入一个非空字符串 `name` 以及一个值大于等于 1 的 `quantity` 来创建一个 `CartItem` 实例，那么构造方法能够成功被执行：
```swift
if let twoSocks = CartItem(name: "sock", quantity: 2) {
print("Item: \(twoSocks.name), quantity: \(twoSocks.quantity)")
}
-// 打印 "Item: sock, quantity: 2"
+// 打印 "Item: sock, quantity: 2”
```
-如果你试图构造一个`quantity`的值为`0`的`CartItem`实例, 则`CartItem`的可失败构造器会触发构造失败：
+倘若你以一个值为 0 的 `quantity` 来创建一个 `CartItem` 实例，那么将导致 `CartItem` 构造器失败：
```swift
if let zeroShirts = CartItem(name: "shirt", quantity: 0) {
@@ -896,10 +862,10 @@ if let zeroShirts = CartItem(name: "shirt", quantity: 0) {
} else {
print("Unable to initialize zero shirts")
}
-// 打印 "Unable to initialize zero shirts"
-```
+// 打印 "Unable to initialize zero shirts”
+```
-类似的，如果你试图构造一个`name`的值为空字符串的`CartItem`实例，则父类`Product`的可失败构造器会触发构造失败：
+同样地，如果你尝试传入一个值为空字符串的 `name`来创建一个 `CartItem` 实例，那么将导致父类 `Product` 的构造过程失败：
```swift
if let oneUnnamed = CartItem(name: "", quantity: 1) {
@@ -907,7 +873,7 @@ if let oneUnnamed = CartItem(name: "", quantity: 1) {
} else {
print("Unable to initialize one unnamed product")
}
-// 打印 "Unable to initialize one unnamed product"
+// 打印 "Unable to initialize one unnamed product”
```
@@ -971,7 +937,7 @@ class UntitledDocument: Document {
### 可失败构造器 init!
-通常来说我们通过在`init`关键字后添加问号的方式（`init?`）来定义一个可失败构造器，但你也可以通过在`init`后面添加惊叹号的方式来定义一个可失败构造器（`(init!)`），该可失败构造器将会构建一个对应类型的隐式解包可选类型的对象。
+通常来说我们通过在`init`关键字后添加问号的方式（`init?`）来定义一个可失败构造器，但你也可以通过在`init`后面添加惊叹号的方式来定义一个可失败构造器（`init!`），该可失败构造器将会构建一个对应类型的隐式解包可选类型的对象。
你可以在`init?`中代理到`init!`，反之亦然。你也可以用`init?`重写`init!`，反之亦然。你还可以用`init`代理到`init!`，不过，一旦`init!`构造失败，则会触发一个断言。
@@ -1027,7 +993,7 @@ class SomeClass {
下面例子中定义了一个结构体`Checkerboard`，它构建了西洋跳棋游戏的棋盘：
-
+
西洋跳棋游戏在一副黑白格交替的`10x10`的棋盘中进行。为了呈现这副游戏棋盘，`Checkerboard`结构体定义了一个属性`boardColors`，它是一个包含`100`个`Bool`值的数组。在数组中，值为`true`的元素表示一个黑格，值为`false`的元素表示一个白格。数组中第一个元素代表棋盘上左上角的格子，最后一个元素代表棋盘上右下角的格子。
@@ -1038,8 +1004,8 @@ struct Checkerboard {
let boardColors: [Bool] = {
var temporaryBoard = [Bool]()
var isBlack = false
- for i in 1...10 {
- for j in 1...10 {
+ for i in 1...8 {
+ for j in 1...8 {
temporaryBoard.append(isBlack)
isBlack = !isBlack
}
@@ -1048,7 +1014,7 @@ struct Checkerboard {
return temporaryBoard
}()
func squareIsBlackAtRow(row: Int, column: Int) -> Bool {
- return boardColors[(row * 10) + column]
+ return boardColors[(row * 8) + column]
}
}
```
@@ -1059,6 +1025,6 @@ struct Checkerboard {
let board = Checkerboard()
print(board.squareIsBlackAtRow(0, column: 1))
// 打印 "true"
-print(board.squareIsBlackAtRow(9, column: 9))
+print(board.squareIsBlackAtRow(7, column: 7))
// 打印 "false"
```
diff --git a/source/chapter2/15_Deinitialization.md b/source/chapter2/15_Deinitialization.md
index 31e191a9..f55b48aa 100755
--- a/source/chapter2/15_Deinitialization.md
+++ b/source/chapter2/15_Deinitialization.md
@@ -10,6 +10,9 @@
> 2.1
> 校对：[shanks](http://codebuild.me)，2015-10-31
+>
+> 2.2
+> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-14
本页包含内容：
@@ -38,13 +41,13 @@ deinit {
##析构器实践
-这是一个析构器实践的例子。这个例子描述了一个简单的游戏，这里定义了两种新类型，分别是`Bank`和`Player`。`Bank`类管理一种虚拟硬币，确保流通的硬币数量永远不可能超过 10,000。在游戏中有且只能有一个`Bank`存在，因此`Bank`用类来实现，并使用静态属性和静态方法来存储和管理其当前状态。
+这是一个析构器实践的例子。这个例子描述了一个简单的游戏，这里定义了两种新类型，分别是`Bank`和`Player`。`Bank`类管理一种虚拟硬币，确保流通的硬币数量永远不可能超过 10,000。在游戏中有且只能有一个`Bank`存在，因此`Bank`用类来实现，并使用类型属性和类型方法来存储和管理其当前状态。
```swift
class Bank {
static var coinsInBank = 10_000
- static func vendCoins(var numberOfCoinsToVend: Int) -> Int {
- numberOfCoinsToVend = min(numberOfCoinsToVend, coinsInBank)
+ static func vendCoins(numberOfCoinsRequested: Int) -> Int {
+ let numberOfCoinsToVend = min(numberOfCoinsRequested, coinsInBank)
coinsInBank -= numberOfCoinsToVend
return numberOfCoinsToVend
}
@@ -56,7 +59,7 @@ class Bank {
`Bank`使用`coinsInBank`属性来跟踪它当前拥有的硬币数量。`Bank`还提供了两个方法，`vendCoins(_:)`和`receiveCoins(_:)`，分别用来处理硬币的分发和收集。
-`vendCoins(_:)`方法在`Bank`对象分发硬币之前检查是否有足够的硬币。如果硬币不足，`Bank`对象会返回一个比请求时小的数字（如果`Bank`对象中没有硬币了就返回`0`）。`vendCoins`方法声明`numberOfCoinsToVend`为一个变量参数，这样就可以在方法体内部修改分发的硬币数量，而不需要定义一个新的变量。`vendCoins`方法返回一个整型值，表示提供的硬币的实际数量。
+`vendCoins(_:)`方法在`Bank`对象分发硬币之前检查是否有足够的硬币。如果硬币不足，`Bank`对象会返回一个比请求时小的数字（如果`Bank`对象中没有硬币了就返回`0`）。`vendCoins`方法返回一个整型值，表示提供的硬币的实际数量。
`receiveCoins(_:)`方法只是将`Bank`对象接收到的硬币数目加回硬币存储中。
diff --git a/source/chapter2/16_Automatic_Reference_Counting.md b/source/chapter2/16_Automatic_Reference_Counting.md
index ca61cb18..319ec3a3 100755
--- a/source/chapter2/16_Automatic_Reference_Counting.md
+++ b/source/chapter2/16_Automatic_Reference_Counting.md
@@ -10,7 +10,10 @@
> 2.1
> 翻译：[Channe](https://github.com/Channe)
-> 校对：[shanks](http://codebuild.me)，[Realank](https://github.com/Realank) ，2016-01-23
+> 校对：[shanks](http://codebuild.me)，[Realank](https://github.com/Realank) ，2016-01-23
+>
+> 2.2
+> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-14
本页包含内容：
diff --git a/source/chapter2/17_Optional_Chaining.md b/source/chapter2/17_Optional_Chaining.md
index 3cb7ce4b..3c5d2ac8 100755
--- a/source/chapter2/17_Optional_Chaining.md
+++ b/source/chapter2/17_Optional_Chaining.md
@@ -10,7 +10,10 @@
> 翻译+校对：[lyojo](https://github.com/lyojo)
> 2.1
-> 校对：[shanks](http://codebuild.me)，2015-10-31
+> 校对：[shanks](http://codebuild.me)，2015-10-31
+>
+> 2.2
+> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-15
本页包含内容：
@@ -50,9 +53,9 @@ class Residence {
}
```
-`Residence`有一个`Int`类型的属性`numberOfRooms`，其默认值为`1`。`Person`具有一个可选的`residence`属性，其类型为`Residence?`。
-
-如果创建一个新的`Person`实例，因为它的`residence`属性是可选的，`john`属性将初始化为`nil`：
+`Residence`有一个`Int`类型的属性`numberOfRooms`，其默认值为`1`。`Person`具有一个可选的`residence`属性，其类型为`Residence?`。
+
+假如你创建了一个新的`Person`实例,它的`residence`属性由于是是可选型而将初始化为`nil`,在下面的代码中,`john`有一个值为`nil`的`residence`属性：
```swift
let john = Person()
@@ -314,7 +317,7 @@ if let firstRoomName = john.residence?[0].name {
```swift
var testScores = ["Dave": [86, 82, 84], "Bev": [79, 94, 81]]
testScores["Dave"]?[0] = 91
-testScores["Bev"]?[0]++
+testScores["Bev"]?[0] += 1
testScores["Brian"]?[0] = 72
// "Dave" 数组现在是 [91, 82, 84]，"Bev" 数组现在是 [80, 94, 81]
```
diff --git a/source/chapter2/18_Error_Handling.md b/source/chapter2/18_Error_Handling.md
index 0fa9ff1c..a501ca6f 100755
--- a/source/chapter2/18_Error_Handling.md
+++ b/source/chapter2/18_Error_Handling.md
@@ -3,7 +3,10 @@
> 2.1
> 翻译+校对：[lyojo](https://github.com/lyojo) [ray16897188](https://github.com/ray16897188) 2015-10-23
-> 校对：[shanks](http://codebuild.me) 2015-10-24
+> 校对：[shanks](http://codebuild.me) 2015-10-24
+>
+> 2.2
+> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-15
本页包含内容：
@@ -18,7 +21,7 @@
举个例子，假如有个从磁盘上的某个文件读取数据并进行处理的任务，该任务会有多种可能失败的情况，包括指定路径下文件并不存在，文件不具有可读权限，或者文件编码格式不兼容。区分这些不同的失败情况可以让程序解决并处理某些错误，然后把它解决不了的错误报告给用户。
> 注意
-Swift 中的错误处理涉及到错误处理模式，这会用到 Cocoa 和 Objective-C 中的`NSError`。关于这个类的更多信息请参见 [Using Swift with Cocoa and Objective-C (Swift 2.1)](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216) 中的[错误处理](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/AdoptingCocoaDesignPatterns.html#//apple_ref/doc/uid/TP40014216-CH7-ID10)。
+Swift 中的错误处理涉及到错误处理模式，这会用到 Cocoa 和 Objective-C 中的`NSError`。关于这个类的更多信息请参见 [Using Swift with Cocoa and Objective-C (Swift 2.2)](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216) 中的[错误处理](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/AdoptingCocoaDesignPatterns.html#//apple_ref/doc/uid/TP40014216-CH7-ID10)。
##表示并抛出错误
@@ -35,7 +38,7 @@ enum VendingMachineError: ErrorType {
}
```
-抛出一个错误可以让你表明有意外情况发生，导致正常的执行流程无法继续执行。抛出错误使用`throws`关键字。例如，下面的代码抛出一个错误，提示贩卖机还需要`5`个硬币：
+抛出一个错误可以让你表明有意外情况发生，导致正常的执行流程无法继续执行。抛出错误使用`throw`关键字。例如，下面的代码抛出一个错误，提示贩卖机还需要`5`个硬币：
```swift
throw VendingMachineError.InsufficientFunds(coinsNeeded: 5)
@@ -68,7 +71,7 @@ func cannotThrowErrors() -> String
> 注意
只有 throwing 函数可以传递错误。任何在某个非 throwing 函数内部抛出的错误只能在函数内部处理。
-下面的例子中，`VendingMechine`类有一个`vend(itemNamed:)`方法，如果请求的物品不存在、缺货或者花费超过了投入金额，该方法就会抛出一个相应的`VendingMachineError`：
+下面的例子中，`VendingMechine`类有一个`vend(itemNamed:)`方法，如果请求的物品不存在、缺货或者投入金额小于物品价格，该方法就会抛出一个相应的`VendingMachineError`：
```swift
struct Item {
@@ -88,7 +91,7 @@ class VendingMachine {
}
func vend(itemNamed name: String) throws {
- guard var item = inventory[name] else {
+ guard let item = inventory[name] else {
throw VendingMachineError.InvalidSelection
}
@@ -101,8 +104,11 @@ class VendingMachine {
}
coinsDeposited -= item.price
- --item.count
- inventory[name] = item
+
+ var newItem = item
+ newItem.count -= 1
+ inventory[name] = newItem
+
dispenseSnack(name)
}
}
@@ -124,7 +130,20 @@ func buyFavoriteSnack(person: String, vendingMachine: VendingMachine) throws {
}
```
-上例中，`buyFavoriteSnack(_:vendingMachine:)`函数会查找某人最喜欢的零食，并通过调用`vend(itemNamed:)`方法来尝试为他们购买。因为`vend(itemNamed:)`方法能抛出错误，所以在调用的它时候在它前面加了`try`关键字。
+上例中，`buyFavoriteSnack(_:vendingMachine:)`函数会查找某人最喜欢的零食，并通过调用`vend(itemNamed:)`方法来尝试为他们购买。因为`vend(itemNamed:)`方法能抛出错误，所以在调用的它时候在它前面加了`try`关键字。
+
+throwing构造器能像throwing函数一样传递错误.例如下面代码中的`PurchasedSnack`构造器在构造过程中调用了throwing函数,并且通过传递到它的调用者来处理这些错误。
+
+```swift
+struct PurchasedSnack {
+ let name: String
+ init(name: String, vendingMachine: VendingMachine) throws {
+ try vendingMachine.vend(itemNamed: name)
+ self.name = name
+ }
+}
+```
+
###用 Do-Catch 处理错误
@@ -166,7 +185,7 @@ do {
###将错误转换成可选值
-可以使用`try?`通过将错误转换成一个可选值来处理错误。如果在评估`try?`表达式时一个错误被抛出，那么表达式的值就是`nil`。例如下面代码中的`x`和`y`具有相同的值：
+可以使用`try?`通过将错误转换成一个可选值来处理错误。如果在评估`try?`表达式时一个错误被抛出，那么表达式的值就是`nil`。例如,在下面的代码中,`x`和`y`有着相同的数值和等价的含义：
```swift
func someThrowingFunction() throws -> Int {
@@ -197,7 +216,7 @@ func fetchData() -> Data? {
### 禁用错误传递
-有时你知道某个 throwing 函数实际上在运行时是不会抛出错误的，在这种情况下，你可以在表达式前面写`try!`来禁用错误传递，这会把调用包装在一个断言不会有错误抛出的运行时断言中。如果实际上抛出了错误，你会得到一个运行时错误。
+有时你知道某个 throwing 函数实际上在运行时是不会抛出错误的，在这种情况下，你可以在表达式前面写`try!`来禁用错误传递，这会把调用包装在一个不会有错误抛出的运行时断言中。如果真的抛出了错误，你会得到一个运行时错误。
例如，下面的代码使用了`loadImage(_:)`函数，该函数从给定的路径加载图片资源，如果图片无法载入则抛出一个错误。在这种情况下，因为图片是和应用绑定的，运行时不会有错误抛出，所以适合禁用错误传递：
diff --git a/source/chapter2/19_Type_Casting.md b/source/chapter2/19_Type_Casting.md
index 4f663ddf..8eef424b 100644
--- a/source/chapter2/19_Type_Casting.md
+++ b/source/chapter2/19_Type_Casting.md
@@ -10,6 +10,9 @@
> 2.1
> 校对：[shanks](http://codebuild.me)，2015-11-01
+>
+> 2.2
+> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-16
本页包含内容：
@@ -89,9 +92,9 @@ var songCount = 0
for item in library {
if item is Movie {
- ++movieCount
+ movieCount += 1
} else if item is Song {
- ++songCount
+ songCount += 1
}
}
@@ -164,12 +167,10 @@ Swift 为不确定类型提供了两种特殊的类型别名：
### `AnyObject` 类型
-当在工作中使用 Cocoa APIs 时，我们经常会接收到一个 `[AnyObject]` 类型的数组，或者说“一个任意类型对象的数组”。这是因为 Objective-C 没有明确的类型化数组。但是，你常常可以从 API 提供的信息来确定数组中对象的类型。
+当我们使用 Cocoa APIs 时，我们会接收到一个 `[AnyObject]` 类型的数组，或者说“一个任意类型对象的数组”。Objective-C现在支持明确的数组类型，但早期版本的Objective-C并没有这个功能。不管怎样，你都可以确信API提供的信息能够正确的表明数组中的元素类型。
-> 译者注
-> 这段文档似乎没有及时更新，从 Xcode 7 和 Swift 2.0 开始，由于 Objective-C 引入了轻量泛型，集合类型已经可以类型化了，在 Swift 中使用 Cocoa API 也越来越少遇到 `AnyObject` 类型了。详情请参阅 [Lightweight Generics](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/InteractingWithObjective-CAPIs.html#//apple_ref/doc/uid/TP40014216-CH4-ID173) 和 [Collection Classes](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/WorkingWithCocoaDataTypes.html#//apple_ref/doc/uid/TP40014216-CH6-ID69)。
-在这些情况下，你可以使用强制形式的类型转换（`as`）来下转数组中的每一项到比 `AnyObject` 更明确的类型，不需要可选解包（optional unwrapping）。
+在这些情况下，你可以使用强制形式的类型转换（`as!`）来下转数组中的每一项到比 `AnyObject` 更明确的类型，不需要可选解包（optional unwrapping）。
下面的示例定义了一个 `[AnyObject]` 类型的数组并填入三个 `Movie` 类型的实例：
diff --git a/source/chapter2/20_Nested_Types.md b/source/chapter2/20_Nested_Types.md
index 1e01fa25..a4578df9 100755
--- a/source/chapter2/20_Nested_Types.md
+++ b/source/chapter2/20_Nested_Types.md
@@ -9,14 +9,17 @@
> 翻译+校对：[SergioChan](https://github.com/SergioChan)
> 2.1
-> 校对：[shanks](http://codebuild.me)，2015-11-01
+> 校对：[shanks](http://codebuild.me)，2015-11-01
+>
+> 2.2
+> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-16
本页包含内容：
- [嵌套类型实践](#nested_types_in_action)
- [引用嵌套类型](#referring_to_nested_types)
-枚举常被用于为特定类或结构体实现某些功能。类似的，也能够在某个复杂的类型中，方便地定义工具类或结构体来使用。为了实现这种功能，Swift 允许你定义嵌套类型，可以在支持的类型中定义嵌套的枚举、类和结构体。
+枚举常被用于为特定类或结构体实现某些功能。类似的，枚举可以方便的定义工具类或结构体，从而为某个复杂的类型所使用。为了实现这种功能，Swift 允许你定义嵌套类型，可以在支持的类型中定义嵌套的枚举、类和结构体。
要在一个类型中嵌套另一个类型，将嵌套类型的定义写在其外部类型的`{}`内，而且可以根据需要定义多级嵌套。
diff --git a/source/chapter2/21_Extensions.md b/source/chapter2/21_Extensions.md
index f05c7f95..1ed93023 100644
--- a/source/chapter2/21_Extensions.md
+++ b/source/chapter2/21_Extensions.md
@@ -10,6 +10,9 @@
> 2.1
> 校对：[shanks](http://codebuild.me)
+>
+> 2.2
+> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-16
本页包含内容：
@@ -106,7 +109,7 @@ print("A marathon is \(aMarathon) meters long")
扩展能为类添加新的便利构造器，但是它们不能为类添加新的指定构造器或析构器。指定构造器和析构器必须总是由原始的类实现来提供。
> 注意
-如果你使用扩展为一个值类型添加构造器，且该值类型的原始实现中未定义任何定制的构造器时，你可以在扩展中的构造器里调用逐一成员构造器。如果该值类型为所有存储型属性提供了默认值，你还可以在扩展中的构造器里调用默认构造器。
+如果你使用扩展为一个值类型添加构造器，同时该值类型的原始实现中未定义任何定制的构造器且所有存储属性提供了默认值，那么我们就可以在扩展中的构造器里调用默认构造器和逐一成员构造器。
正如在[值类型的构造器代理](./14_Initialization.html#initializer_delegation_for_value_types)中描述的，如果你把定制的构造器写在值类型的原始实现中，上述规则将不再适用。
下面的例子定义了一个用于描述几何矩形的结构体 `Rect`。这个例子同时定义了两个辅助结构体 `Size` 和 `Point`，它们都把 `0.0` 作为所有属性的默认值：
@@ -223,11 +226,10 @@ someInt.square()
```swift
extension Int {
- subscript(var digitIndex: Int) -> Int {
+ subscript(digitIndex: Int) -> Int {
var decimalBase = 1
- while digitIndex > 0 {
+ for _ in 0..+> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*标识符*](02_Lexical_Structure.md#identifier) **(** [*参数名称*](#argument-names) **)** +> + +> *参数名称* → [*参数名*](#argument-name) [*参数名称*](#argument-names)可选
+ +> *参数名* → [*标识符*](02_Lexical_Structure.md#identifier) **:** ### 后缀 self 表达式 -后缀 `self` 表达式由某个表达式紧跟 `.self` 组成，形式如下： +后缀 `self` 表达式由某个表达式或类型名紧跟 `.self` 组成，其形式如下： > `表达式`.self > `类型`.self 第一种形式返回表达式的值。例如：`x.self` 返回 `x`。 -第二种形式返回表示对应类型的值。我们可以用它来动态地获取某个实例的类型。例如，`SomeClass.self` 会返回 `SomeClass` 类型本身，你可以将其传递给相应函数或者方法作为参数。 +第二种形式返回相应的类型。我们可以用它来获取某个实例的类型作为一个值来使用。例如，`SomeClass.self` 会返回 `SomeClass` 类型本身，你可以将其传递给相应函数或者方法作为参数。 > 后缀 self 表达式语法 @@ -670,11 +766,11 @@ t.0 = t.1 ### dynamicType 表达式 -`dynamicType` 表达式由某个表达式紧跟 `.dynamicType` 组成，形式如下： +dynamicType 表达式由类似[函数调用表达式(Function Call Expression)](#function-call-expression)的特殊语法表达式组成,形式如下: -> `表达式`.dynamicType +> type(of:`表达式`) -上述形式中的表达式不能是类型名。`dynamicType` 表达式会返回某个实例在运行时的类型，具体请看下面的列子： +上述形式中的表达式不能是类型名。type(of:) 表达式会返回某个实例在运行时的类型，具体请看下面的例子： ```swift class SomeBaseClass { @@ -690,13 +786,13 @@ class SomeSubClass: SomeBaseClass { let someInstance: SomeBaseClass = SomeSubClass() // someInstance 在编译时的静态类型为 SomeBaseClass， // 在运行时的动态类型为 SomeSubClass -someInstance.dynamicType.printClassName() +type(of: someInstance).printClassName() // 打印 “SomeSubClass” ``` > 动态类型表达式语法 -> *动态类型表达式* → [*后缀表达式*](#postfix-expression) **.** **dynamicType** +> *动态类型表达式* → type(of:表达式) **.** **dynamicType** ### 下标表达式 @@ -705,7 +801,7 @@ someInstance.dynamicType.printClassName() > `表达式`[`索引表达式`] -要获取下标表达式的值，可将索引表达式作为下标表达式的参数，调用表达式类型的下标 getter。下标 setter 的调用方式与之一样。 +要获取下标表达式的值，可将索引表达式作为下标表达式的参数来调用下标 getter。下标 setter 的调用方式与之一样。 关于下标的声明，请参阅 [协议下标声明](05_Declarations.md#protocol_subscript_declaration)。 @@ -745,11 +841,11 @@ someDictionary["a"]![0] = 100 > `表达式`? -后缀 `?` 根据表达式生成可选链表达式，而不会改变表达式的值。 +后缀 `?` 运算符会根据表达式生成可选链表达式而不会改变表达式的值。 -如果某个后缀表达式包含可选链表达式，那么它的执行过程会比较特殊。如果该可选链表达式的值是 `nil`，整个后缀表达式会直接返回 `nil`。如果该可选链表达式的值不是 `nil`，则返回可选链表达式解包后的值，并用于后缀表达式中剩余的表达式。在这两种情况下，整个后缀表达式的值都会是可选类型。 +如果某个后缀表达式包含可选链表达式，那么它的执行过程会比较特殊。如果该可选链表达式的值是 `nil`，整个后缀表达式会直接返回 `nil`。如果该可选链表达式的值不是 `nil`，则返回可选链表达式解包后的值，并将该值用于后缀表达式中剩余的表达式。在这两种情况下，整个后缀表达式的值都会是可选类型。 -如果某个后缀表达式中包含了可选链表达式，那么只有最外层的表达式会返回一个可选类型。例如，在下面的例子中，如果 `c` 不是 `nil`，那么它的值会被解包，然后通过 `.property` 访问它的属性，接着进一步通过 `.performAction()` 调用相应方法。整个 `c?.property.performAction()` 表达式返回一个可选类型的值。 +如果某个后缀表达式中包含了可选链表达式，那么只有最外层的表达式会返回一个可选类型。例如，在下面的例子中，如果 `c` 不是 `nil`，那么它的值会被解包，然后通过 `.property` 访问它的属性，接着进一步通过 `.performAction()` 调用相应方法。整个 `c?.property.performAction()` 表达式返回一个可选类型的值，而不是多重可选类型。 ```swift var c: SomeClass? diff --git a/source/chapter3/05_Declarations.md b/source/chapter3/05_Declarations.md index f43a0156..3e8f602a 100755 --- a/source/chapter3/05_Declarations.md +++ b/source/chapter3/05_Declarations.md @@ -1,1297 +1,1247 @@ - -# 声明（Declarations） ------------------ - -> 1.0 -> 翻译：[marsprince](https://github.com/marsprince) [Lenhoon](https://github.com/marsprince)[(微博)](http://www.weibo.com/lenhoon) -> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai) - -> 2.0 -> 翻译+校对：[Lenhoon](https://github.com/Lenhoon), -> [BridgeQ](https://github.com/WXGBridgeQ) - -> 2.1 -> 翻译：[mmoaay](https://github.com/mmoaay), [shanks](http://codebuild.me) -> 校对：[shanks](http://codebuild.me) - -本页包含内容： - -- [顶级代码](#top-level_code) -- [代码块](#code_blocks) -- [导入声明](#import_declaration) -- [常量声明](#constant_declaration) -- [变量声明](#variable_declaration) - - [存储型变量和存储型变量属性](#stored_variables_and_stored_variable_properties) - - [计算型变量和计算型属性](#computed_variables_and_computed_properties) - - [存储型变量观察器和属性观察器](#stored_variable_observers_and_property_observers) - - [类型变量属性](#type_variable_properties) -- [类型别名声明](#type_alias_declaration) -- [函数声明](#function_declaration) - - [参数名](#parameter_names) - - [输入输出参数](#in-out_parameters) - - [特殊参数](#special_kinds_of_parameters) - - [特殊方法](#special_kinds_of_methods) - - [柯里化函数](#curried_functions) - - [抛出错误的函数和方法](#throwing_functions_and_methods) - - [重新抛出错误的函数和方法](#rethrowing_functions_and_methods) -- [枚举声明](#enumeration_declaration) - - [包含任意类型用例的枚举](#enumerations_with_cases_of_any_type) - - [递归枚举](#enumerations_with_indirection) - - [包含原始值类型的枚举](#enumerations_with_cases_of_a_raw-value_type) - - [访问枚举用例](#accessing_enumeration_cases) -- [结构体声明](#structure_declaration) -- [类声明](#class_declaration) -- [协议声明](#protocol_declaration) - - [协议属性声明](#protocol_property_declaration) - - [协议方法声明](#protocol_method_declaration) - - [协议构造器声明](#protocol_initializer_declaration) - - [协议下标声明](#protocol_subscript_declaration) - - [协议关联类型声明](#protocol_associated_type_declaration) -- [构造器声明](#initializer_declaration) - - [可失败构造器](#failable_initializers) -- [析构器声明](#deinitializer_declaration) -- [扩展声明](#extension_declaration) -- [下标声明](#subscript_declaration) -- [运算符声明](#operator_declaration) -- [声明修饰符](#declaration_modifiers) - - [访问控制级别](#access_control_levels) - -声明可以在程序里引入新的名字或者构造。举例来说，可以使用声明来引入函数和方法，变量和常量，或者来定义新的命名的枚举，结构，类和协议类型。还可以使用声明来扩展一个已经存在的命名的类型的行为，或者在程序里引入在其它地方声明的符号。 - -在 Swift 中，大多数声明在某种意义上讲也是定义，实现或初始化往往伴随着声明。这意味着，由于协议往往并不提供实现，大多数协议仅仅只是声明而已。为了方便起见，也因为这些区别在 Swift 中不是很重要，“声明”这个术语同时包含了声明和定义。 - -> 声明语法 - -> *声明* → [*导入声明*](#import-declaration) -> *声明* → [*常量声明*](#constant-declaration) -> *声明* → [*变量声明*](#variable-declaration) -> *声明* → [*类型别名声明*](#typealias-declaration) -> *声明* → [*函数声明*](#function-declaration) -> *声明* → [*枚举声明*](#enum-declaration) -> *声明* → [*结构体声明*](#struct-declaration) -> *声明* → [*类声明*](#class-declaration) -> *声明* → [*协议声明*](#protocol-declaration) -> *声明* → [*构造器声明*](#initializer-declaration) -> *声明* → [*析构器声明*](#deinitializer-declaration) -> *声明* → [*扩展声明*](#extension-declaration) -> *声明* → [*下标声明*](#subscript-declaration) -> *声明* → [*运算符声明*](#operator-declaration) - -> *多条声明* → [*声明*](#declaration) [*多条声明*](#declarations)可选 - - -## 顶级代码 - -Swift 的源文件中的顶级代码由零个或多个语句，声明和表达式组成。默认情况下，在一个源文件的顶层声明的变量，常量和其他命名的声明语句可以被同一模块中的每一个源文件中的代码访问。可以使用一个访问级别修饰符来标记声明，从而覆盖默认行为，请参阅 [访问控制级别](#access_control_levels)。 - -> 顶级声明语法 -> *顶级声明* → [*多条语句*](10_Statements.md#statements)可选 - - -## 代码块 - -代码块可以将一些声明和控制结构组织在一起。它有如下的形式： - -```swift -{ - 语句 -} -``` - -代码块中的语句包括声明，表达式和各种其他类型的语句，它们按照在源码中的出现顺序被依次执行。 - -> 代码块语法 - -> *代码块* → **{** [*多条语句*](10_Statements.md#statements)可选 **}** - - -## 导入声明 - -导入声明让你可以使用在其他文件中声明的内容。导入语句的基本形式是导入整个模块，它由 `import` 关键字开始，后面紧跟一个模块名： - -> import `模块` - -可以对导入提供更细致的控制，如指定一个特殊的子模块或者指定一个模块或子模块中的某个声明。提供了这些限制后，在当前作用域中，只有导入的符号是可用的，而不是整个模块。 - -> import `导入类型` `模块`.`符号名` -> import `模块`.`子模块` - - -> 导入声明语法 - -> *导入声明* → [*特性列表*](06_Attributes.md#attributes)可选 **import** [*导入类型*](#import-kind)可选 [*导入路径*](#import-path) - -> *导入类型* → **typealias** | **struct** | **class** | **enum** | **protocol** | **var** | **func** - -> *导入路径* → [*导入路径标识符*](#import-path-identifier) | [*导入路径标识符*](#import-path-identifier) **.** [*导入路径*](#import-path) - -> *导入路径标识符* → [*标识符*](02_Lexical_Structure.md#identifier) | [*运算符*](02_Lexical_Structure.md#operator) - - -## 常量声明 - -常量声明可以在程序中命名一个常量。常量以关键字 `let` 来声明，遵循如下的格式： - -> let `常量名称`: `类型` = `表达式` - -当常量的值被给定后，常量就将常量名称和表达式的值绑定在了一起，不能更改。 - -这意味着，如果常量以类对象来初始化，对象本身的内容是可以改变的，但是常量和该对象之间的结合关系是不能改变的。 - -当一个常量被声明为全局变量，它必须被给定一个初始值。在类或者结构体中声明一个常量时，它被认为是一个常量属性。常量声明不能是计算型属性，因此也没有存取方法。 - -如果常量名称是元组形式，元组中的每一项的名称会和对应的初始化表达式的值绑定。 - -```swift -let (firstNumber, secondNumber) = (10, 42) -``` - -在上例中，`firstNumber` 是一个值为 `10` 的常量，`secnodeName` 是一个值为 `42` 的常量。所有常量都可以独立的使用： - -```swift -print("The first number is \(firstNumber).") -// 打印 “The first number is 10.” -print("The second number is \(secondNumber).") -// 打印 “The second number is 42.” -``` - -当常量名称的类型可以被推断出时，类型标注在常量声明中是一个可选项，正如 [类型推断](03_Types.md#type_inference) 中所描述的。 - -声明一个常量类型属性要使用 `static` 声明修饰符。类型属性在 [类型属性](../chapter2/10_Properties.md#type_properties)中有介绍。 - -如果还想获得更多关于常量的信息或者想在使用中获得帮助，请参阅 [常量和变量](../chapter2/01_The_Basics.md#constants_and_variables) 和 [存储属性](../chapter2/10_Properties.md#stored_properties)。 - - -> 常量声明语法 - -> *常量声明* → [*特性列表*](06_Attributes.md#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **let** [*模式构造器列表*](pattern-initializer-list) - -> *模式构造器列表* → [*模式构造器*](#pattern-initializer) | [*模式构造器*](#pattern-initializer) **,** [*模式构造器列表*](#pattern-initializer-list) - -> *模式构造器* → [*模式*](07_Patterns.md#pattern) [*构造器*](#initializer)可选 - -> *构造器* → **=** [*表达式*](04_Expressions.md#expression) - - -## 变量声明 - -变量声明可以在程序中声明一个变量，它以关键字 `var` 来声明。 - -变量声明有几种不同的形式，可以声明不同种类的命名值和可变值，如存储型和计算型变量和属性，属性观察器，以及静态变量属性。所使用的声明形式取决于变量声明的适用范围和打算声明的变量类型。 - -> 注意 -> 也可以在协议声明的上下文中声明属性，详情请参阅 [协议属性声明](#protocol_property_declaration)。 - -可以在子类中使用 `override` 声明修饰符来标记继承来的属性的声明，从而重写属性，详情请参阅 [重写](../chapter2/13_Inheritance.md#overriding)。 - - -### 存储型变量和存储型变量属性 - -使用如下形式声明一个存储型变量或存储型变量属性： - -> var `变量名称`: `类型` = `表达式` - -可以在全局范围，函数内部，或者在类和结构体的声明中使用这种形式来声明一个变量。当变量以这种形式在全局范围或者函数内部被声明时，它代表一个存储型变量。当它在类或者结构体中被声明时，它代表一个存储型变量属性。 - -用于初始化的表达式不可以在协议的声明中出现，在其他情况下，该表达式是可选的。如果没有初始化表达式，那么变量声明必须包含类型标注。 - -对于常量的声明，如果变量名称是一个元组，元组中每一项的名称都要和初始化表达式中的相应值绑定。 - -正如名字一样，存储型变量和存储型变量属性的值会存储在内存中。 - - -### 计算型变量和计算型属性 - -使用如下形式声明一个计算型变量或计算型属性： - -```swift -var 变量名称: 类型 { - get { - 语句 - } - set(setter 名称) { - 语句 - } -} -``` - -可以在全局范围，函数内部，以及类，结构体，枚举，扩展声明的上下文中使用这种形式的声明。当变量以这种形式在全局范围或者函数内部被声明时，它代表一个计算型变量。当它在类，结构体，枚举，扩展声明的上下文中被声明时，它代表一个计算型属性。 - -getter 用来读取变量值，setter 用来写入变量值。setter 子句是可选的，getter 子句是必须的。也可以将这些子句都省略，直接返回请求的值，正如在 [只读计算型属性](../chapter2/10_Properties.md#computed_properties) 中描述的那样。但是如果提供了一个 setter 子句，也必须提供一个 getter 子句。 - -圆括号内的 setter 的名称是可选的。如果提供了一个 setter 名称，它就会作为 setter 的参数名称使用。如果不提供 setter 名称，setter 的参数的默认名称为 `newValue`，正如在 [便捷 setter 声明](../chapter2/10_Properties.md#shorthand_setter_declaration) 中描述的那样。 - -与存储型变量和存储型属性不同，计算型变量和计算型属性的值不存储在内存中。 - -要获得更多关于计算型属性的信息和例子，请参阅 [计算型属性](../chapter2/10_Properties.md#computed_properties)。 - - -### 存储型变量观察器和属性观察器 - -可以在声明存储型变量或属性时提供 `willSet` 和 `didSet` 观察器。一个包含观察器的存储型变量或属性以如下形式声明： - -```swift -var 变量名称: 类型 = 表达式 { - willSet(setter 名称) { - 语句 - } - didSet(setter 名称) { - 语句 - } -} -``` - -可以在全局范围，函数内部，或者类，结构体声明的上下文中使用这种形式的声明。当变量以这种形式在全局范围或者函数内部被声明时，观察器代表一个存储型变量观察器。当它在类，结构体声明的上下文中被声明时，观察器代表一个属性观察器。 - -可以为任何存储型属性添加观察器。也可以通过重写父类属性的方式为任何继承的属性（无论是存储型还是计算型的）添加观察器 -，正如 [重写属性观察器](../chapter2/13_Inheritance.md#overriding_property_observers) 中所描述的。 - -用于初始化的表达式在一个类或者结构体的声明中是可选的，但是在其他地方是必须的。如果类型可以从初始化表达式中推断而来，那么这个类型标注是可选的。 - -当变量或属性的值被改变时，`willSet` 和 `didSet` 观察器提供了一种观察方法。观察器不会在变量或属性第一次初始化时被调用，它们仅当值在初始化环境之外被改变时才会被调用。 - -`willSet` 观察器只在变量或属性的值被改变之前调用。新的值作为一个常量传入 `willSet` 观察器，因此不可以在 `willSet` 中改变它。`didSet` 观察器在变量或属性的值被改变后立即调用。和 `willSet` 观察器相反，为了方便获取旧值，旧值会传入 `didSet` 观察器。这意味着，如果在变量或属性的 `didiset` 观察器中设置值，设置的新值会取代刚刚在 `willSet` 观察器中传入的那个值。 - -在 `willSet` 和 `didSet` 中，圆括号以及其中的 setter 名称是可选的。如果提供了一个 setter 名称，它就会作为 `willSet` 和 `didSet` 的参数被使用。如果不提供 setter 名称，`willSet` 观察器的默认参数名为 `newValue`，`didSet` 观察器的默认参数名为 `oldValue`。 - -提供了 `willSet` 时，`didSet` 是可选的。同样的，提供了 `didSet` 时，`willSet` 则是可选的。 - -要获得更多信息以及查看如何使用属性观察器的例子，请参阅 [属性观察器](../chapter2/10_Properties.md#property_observers)。 - - -### 类型变量属性 - -要声明一个类型变量属性，用 `static` 声明修饰符标记该声明。类可以改用 `class` 声明修饰符标记类的类型计算型属性从而允许子类重写超类的实现。类型属性在 [类型属性](../chapter2/10_Properties.md#type_properties) 章节有详细讨论。 - -> 注意 -> 在一个类声明中，使用关键字 `static` 与同时使用 `class` 和 `final` 去标记一个声明的效果相同。 - - -> 变量声明语法 - - -> *变量声明* → [*变量声明头*](#variable-declaration-head) [*模式构造器列表*](#pattern-initializer-list) -> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*代码块*](#code-block) -> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*getter-setter代码块*](#getter-setter-block) -> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*getter-setter关键字代码块*](#getter-setter-keyword-block) -> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*构造器*](#initializer) [*willSet-didSet代码块*](#willSet-didSet-block) -> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*构造器*](#initializer)可选 [*willSet-didSet代码块*](#willSet-didSet-block) - - -> *变量声明头* → [*特性列表*](06_Attributes.md#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **var** - -> *变量名称* → [*标识符*](02_Lexical_Structure.md#identifier) - - -> *getter-setter 代码块* → [*代码块*](#code-block) -> *getter-setter 代码块* → **{** [*getter子句*](#getter-clause) [*setter子句*](#setter-clause)可选 **}** -> *getter-setter 代码块* → **{** [*setter子句*](#setter-clause) [*getter子句*](#getter-clause) **}** - -> *getter 子句* → [*特性列表*](06_Attributes.md#attributes)可选 **get** [*代码块*](#code-block) - -> *setter 子句* → [*特性列表*](06_Attributes.md#attributes)可选 **set** [*setter名称*](#setter-name)可选 [*代码块*](#code-block) - -> *setter 名称* → **(** [*标识符*](02_Lexical_Structure.md#identifier) **)** - - -> *getter-setter 关键字代码块* → **{** [*getter关键字子句*](#getter-keyword-clause) [*setter关键字子句*](#setter-keyword-clause)可选 **}** -> *getter-setter 关键字代码块* → **{** [*setter关键字子句*](#setter-keyword-clause) [*getter关键字子句*](#getter-keyword-clause) **}** - -> *getter 关键字子句* → [*特性列表*](06_Attributes.md#attributes)可选 **get** - -> *setter 关键字子句* → [*特性列表*](06_Attributes.md#attributes)可选 **set** - - -> *willSet-didSet 代码块* → **{** [*willSet子句*](#willSet-clause) [*didSet子句*](#didSet-clause)可选 **}** -> *willSet-didSet 代码块* → **{** [*didSet子句*](#didSet-clause) [*willSet子句*](#willSet-clause)可选 **}** - -> *willSet 子句* → [*特性列表*](06_Attributes.md#attributes)可选 **willSet** [*setter名称*](#setter-name)可选 [*代码块*](#code-block) - -> *didSet 子句* → [*特性列表*](06_Attributes.md#attributes)可选 **didSet** [*setter名称*](#setter-name)可选 [*代码块*](#code-block) - - -## 类型别名声明 - -类型别名声明可以在程序中为一个现存类型声明一个别名。类型别名声明语句使用关键字 `typealias` 声明，遵循如下的形式： - -> `类型别名` = `现存类型` - -当声明一个类型的别名后，可以在程序的任何地方使用别名来代替现存类型。现存类型可以是命名类型或者混合类型。类型别名不产生新的类型，它只是可以使用别名来引用现存类型。 - -另请参阅 [协议关联类型声明](#protocol_associated_type_declaration)。 - - -> 类型别名声明语法 - -> *类型别名声明* → [*类型别名头*](#typealias-head) [*类型别名赋值*](#typealias-assignment) - -> *类型别名头* → [*特性列表*](06_Attributes.md#attributes)可选 [*访问级别修饰符*](#access-level-modifier)可选 **typealias** [*类型别名名称*](#typealias-name) - -> *类型别名名称* → [*标识符*](02_Lexical_Structure.md#identifier) - -> *类型别名赋值* → **=** [*类型*](03_Types.md#type) - - -## 函数声明 - -使用函数声明在程序中引入新的函数或者方法。当一个函数被声明在类，结构体，枚举，或者协议的上下文中，会作为一个方法。函数声明使用关键字 `func`，遵循如下的形式： - -```swift -func 函数名称(参数列表) -> 返回类型 { - 语句 -} -``` - -如果函数返回 `Void` 类型，返回类型可以省略，如下所示： - -```swift -func 函数名称(参数列表) { - 语句 -} -``` - -每个参数的类型都要标明，它们不能被推断出来。虽然函数的参数默认是常量，也可以在参数名前添加 `let` 来强调这一行为。在参数名前面添加 `var` 则会使它们成为变量，作用域内任何对变量的改变只在函数体内有效，或者用 `inout` 使这些改变可以在调用域内生效。更多关于 `inout` 参数的讨论，请参阅 [输入输出参数](#in-out_parameters)。 - -函数可以使用元组类型作为返回类型来返回多个值。 - -函数定义可以出现在另一个函数声明内。这种函数被称作嵌套函数。更多关于嵌套函数的讨论，请参阅 [嵌套函数](../chapter2/06_Functions.md#Nested_Functions)。 - - -### 参数名 - -函数的参数列表由一个或多个函数参数组成，参数间以逗号分隔。函数调用时的参数顺序必须和函数声明时的参数顺序一致。最简单的参数列表有着如下的形式： - -> `参数名称`: `参数类型` - -一个参数有一个内部名称，这个内部名称可以在函数体内被使用。同样也可以作为外部名称，当调用函数时这个外部名称被作为实参的标签来使用。默认情况下，第一个参数的外部名称省略不写，第二个和之后的参数使用它们的内部名称作为它们的外部名称。例如： - -```swift -func f(x: Int, y: Int) -> Int { return x + y } -f(1, y: 2) // 参数 y 有标签，参数 x 则没有 -``` - -可以按照如下两种形式之一，重写参数名称的默认行为： - -> `外部参数名称` `内部参数名称`: `参数类型` -> _ `内部参数名称`: `参数类型` - -在内部参数名称前的名称赋予这个参数一个外部名称，这个名称可以和内部参数的名称不同。外部参数名称在函数被调用时必须被使用。对应的参数在方法或函数被调用时必须有外部名。 - -内部参数名称前的下划线（`_`）使该参数在函数被调用时没有名称。在函数或方法调用时，对应的参数必须没有名字。 - -```swift -func f(x x: Int, withY y: Int, _ z: Int) -> Int { return x + y + z } -f(x: 1, withY: 2, 3) // 参数 x 和 y 是有标签的，参数 z 则没有 -``` - - -### 输入输出参数 - -输入输出参数被传递时遵循如下规则： - -1. 函数调用时，参数的值被拷贝。 -2. 函数体内部，拷贝后的值被修改。 -3. 函数返回后，拷贝后的值被赋值给原参数。 - -这种行为被称为拷入拷出（copy-in copy-out）或值结果调用（call by value result）。例如，当一个计算型属性或者一个具有属性观察器的属性被用作函数的输入输出参数时，其 getter 会在函数调用时被调用，而其 setter 会在函数返回时被调用。 - -作为一种优化手段，当参数值存储在内存中的物理地址时，在函数体内部和外部均会使用同一内存位置。这种优化行为被称为引用调用（call by reference），它满足了拷入拷出模型的所有需求，而消除了复制带来的开销。不要依赖于拷入拷出与引用调用之间的行为差异。 - -不要使用传递给输入输出参数的值，即使原始值在当前作用域中依然可用。当函数返回时，你对原始值所做的更改会被拷贝的值所覆盖。不要依赖于引用调用的优化机制来试图阻止这种覆盖。 - -你不能将同一个值传递给多个输入输出参数，因为多个输入输出参数引发的拷贝与覆盖行为的顺序是不确定的，因此原始值的最终值也将无法确定。例如： - -```swift -var x = 10 -func f(inout a: Int, inout _ b: Int) { - a += 1 - b += 10 -} -f(&x, &x) // 编译报错 error: inout arguments are not allowed to alias each other -``` - -如果嵌套函数在外层函数返回后才调用，嵌套函数对输入输出参数造成的任何改变将不会影响到原始值。例如： - -```swift -func outer(inout a: Int) -> () -> Void { - func inner() { - a += 1 - } - return inner -} - -var x = 10 -let f = outer(&x) -f() -print(x) -// 打印 “10” -``` - -调用嵌套函数 `inner()` 对 `a` 递增后，`x` 的值并未发生改变，因为 `inner()` 在外层函数 `outer()` 返回后才被调用。若要改变 `x` 的值，必须在 `outer()` 返回前调用 `inner()`。 - -关于输入输出参数的详细讨论，请参阅 [输入输出参数](../chapter2/06_Functions.md#in_out_parameters)。 - - -### 特殊参数 - -参数可以被忽略，参数的数量可变，并且还可以提供默认值，使用形式如下： - -> _ : `参数类型` -> `参数名称`: `参数类型`... -> `参数名称`: `参数类型` = `默认参数值` - -以下划线（`_`）命名的参数是被显式忽略的，无法在函数体内使用。 - -一个参数的基础类型名称如果紧跟着三个点（`...`），会被视为可变参数。一个函数至多可以拥有一个可变参数，且必须是最后一个参数。可变参数会作为该参数类型的数组。举例来讲，可变参数 `Int...` 被看作 `[Int]`。关于使用可变参数的例子，请参阅 [可变参数](../chapter2/06_Functions.md#variadic_parameters)。 - -如果在参数类型后面有一个以等号（`=`）连接的表达式，该参数会拥有默认值，即给定表达式的值。当函数被调用时，给定的表达式会被求值。如果参数在函数调用时被省略了，就会使用其默认值。 - -```swift -func f(x: Int = 42) -> Int { return x } -f() // 有效，使用默认值 -f(7) // 有效，提供了值 -f(x: 7) // 无效，该参数没有外部名称 -``` - - -### 特殊方法 - -枚举或结构体的方法如果会修改 `self` 属性，必须以 `mutating` 声明修饰符标记。 - -子类重写超类中的方法必须以 `override` 声明修饰符标记。重写方法时不使用 `override` 修饰符，或者使用了 `override` 修饰符却并没有重写超类方法，都会产生一个编译时错误。 - -枚举或者结构体中的类型方法，要以 `static` 声明修饰符标记，而对于类中的类型方法，除了使用 `static`，也可使用 `class` 声明修饰符标记。 - - -### 柯里化函数 - -可以将一个带有多个参数的函数重写为一个等价的函数，这个重写后的函数只有一个参数并且返回一个函数。这个返回的函数接受下一个参数，并且返回另外一个函数。如此一直持续到再没有剩余的参数，最终返回的函数返回最初的多参函数要返回的原始值。这种重写的函数被称为柯里化函数。例如，可以为 `addTwoInts(a:b:)` 函数重写一个等价的 `addTwoIntsCurried(a:)(b:)` 函数： - -```swift -func addTwoInts(a a: Int, b: Int) -> Int { - return a + b -} - -func addTwoIntsCurried(a a: Int) -> (Int -> Int) { - func addTheOtherInt(b: Int) -> Int { - return a + b - } - return addTheOtherInt -} -``` - -`addTwoInts(a:b:)` 函数接受两个整型值并且返回它们的和。`addTwoIntsCurried(a:)(b:)` 函数接受一个整型值，并且返回另外一个接受第二个整型值的函数，该函数会将其参数和第一个整型值相加。（这个嵌套函数会从外层函数中捕获第一个整型值）。 - -在 Swift 中，可以通过以下语法非常简明地编写一个柯里化函数： - -```swift -func 函数名称(参数)(参数) -> 返回类型 { - 语句 -} -``` - -举例来说，下面的两个声明是等价的: - -```swift -func addTwoIntsCurried(a a: Int)(b: Int) -> Int { - return a + b -} - -func addTwoIntsCurried(a a: Int) -> (Int -> Int) { - func addTheOtherInt(b: Int) -> Int { - return a + b - } - return addTheOtherInt -} -``` - -为了像使用非柯里化函数一样的方式使用 `addTwoIntsCurried(a:)(b:)` 函数，必须用第一个整型参数调用 `addTwoIntsCurried(a:)(b:)`，紧接着用第二个整型参数调用其返回的函数： - -```swift -addTwoInts(a: 4, b: 5) -// 返回值为 9 -addTwoIntsCurried(a: 4)(b: 5) -// 返回值为 9 -``` - -调用一个非柯里化函数时必须一次性提供所有的参数，而使用函数的柯里化形式则可以分多次提供参数，每次调用提供一个（甚至可以在代码中的不同地方）。这被称为偏函数应用。例如，可以为 `addTwoIntsCurried(a:)(b:)` 函数提供整形参数 `1`，然后把返回的函数赋值给常量 `plusOne`： - -```swift -let plusOne = addTwoIntsCurried(a: 1) -// plusOne 是类型为 Int -> Int 的函数 -``` - -因为 `plusOne` 是函数 `addTwoIntsCurried(a:)(b:)` 的首个参数为 `1` 时返回的函数，所以可以调用 `plusOne` 并传入一个整型值使其和 `1` 相加。 - -```swift -plusOne(b: 10) -// 返回值为 11 -``` - - -### 抛出错误的函数和方法 - -可以抛出错误的函数或方法必须使用 `throws` 关键字标记。这类函数和方法被称为抛出函数和抛出方法。它们有着下面的形式: - -```swift -func 函数名称(参数列表) throws -> 返回类型 { - 语句 -} -``` - -抛出函数或抛出方法的调用必须包裹在 `try` 或者 `try!` 表达式中（也就是说，在作用域内使用 `try` 或者 `try!` 运算符）。 - -`throws` 关键字是函数的类型的一部分，非抛出函数是抛出函数的子类型。所以，可以在使用抛出函数的地方使用非抛出函数。对于柯里化函数，`throws` 关键字仅应用于最内层的函数。 - -不能仅基于函数能否抛出错误来进行函数重载。也就是说，可以基于函数的函数类型的参数能否抛出错误来进行函数重载。 - -抛出方法不能重写非抛出方法，而且抛出方法不能满足协议对于非抛出方法的要求。也就是说，非抛出方法可以重写抛出方法，而且非抛出方法可以满足协议对于抛出方法的要求。 - - -### 重新抛出错误的函数和方法 - -函数或方法可以使用 `rethrows` 关键字来声明，从而表明仅当该函数或方法的一个函数类型的参数抛出错误时，该函数或方法才抛出错误。这类函数和方法被称为重抛函数和重抛方法。重新抛出错误的函数或方法必须至少有一个参数的类型为抛出函数。 - -```swift -func functionWithCallback(callback: () throws -> Int) rethrows { - try callback() -} -``` - -抛出方法不能重写重抛方法，而且抛出方法不能满足协议对于重抛方法的要求。也就是说，重抛方法可以重写抛出方法，而且重抛方法可以满足协议对于抛出方法的要求。 - - -> 函数声明语法 - - -> *函数声明* → [*函数头*](#function-head) [*函数名*](#function-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [*函数签名*](#function-signature) [*函数体*](#function-body)可选 - - -> *函数头* → [*特性列表*](06_Attributes.md#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **func** - -> *函数名* → [*标识符*](02_Lexical_Structure.md#identifier) | [*运算符*](02_Lexical_Structure.md#operator) - - -> *函数签名* → [*参数子句列表*](#parameter-clauses) **throws**可选 [*函数结果*](#function-result)可选 -> *函数签名* → [*参数子句列表*](#parameter-clauses) **rethrows** [*函数结果*](#function-result)可选 - -> *函数结果* → **->** [*特性列表*](06_Attributes.md#attributes)可选 [*类型*](03_Types.md#type) - -> *函数体* → [*代码块*](#code-block) - - -> *参数子句列表* → [*参数子句*](#parameter-clause) [*参数子句列表*](#parameter-clauses)可选 - -> *参数子句* → **(** **)** | **(** [*参数列表*](#parameter-list) **)** - -> *参数列表* → [*参数*](#parameter) | [*参数*](#parameter) **,** [*参数列表*](#parameter-list) - -> *参数* → **let**可选 [*外部参数名*](#external-parameter-name)可选 [*内部参数名*](#local-parameter-name) [*类型标注*](03_Types.md#type-annotation) [*默认参数子句*](#default-argument-clause)可选 -> *参数* → **var** [*外部参数名*](#external-parameter-name)可选 [*内部参数名*](#local-parameter-name) [*类型标注*](03_Types.md#type-annotation) [*默认参数子句*](#default-argument-clause)可选 -> *参数* → **inout** [*外部参数名*](#external-parameter-name)可选 [*内部参数名*](#local-parameter-name) [*类型标注*](03_Types.md#type-annotation) -> *参数* → [*外部参数名*](#external-parameter-name)可选 [*内部参数名*](#local-parameter-name) [*类型标注*](03_Types.md#type-annotation) **...** - -> *外部参数名* → [*标识符*](02_Lexical_Structure.md#identifier) | **_** - -> *内部参数名* → [*标识符*](02_Lexical_Structure.md#identifier) | **_** - -> *默认参数子句* → **=** [*表达式*](04_Expressions.md#expression) - - -## 枚举声明 - -在程序中使用枚举声明来引入一个枚举类型。 - -枚举声明有两种基本形式，使用关键字 `enum` 来声明。枚举声明体包含零个或多个值，称为枚举用例，还可包含任意数量的声明，包括计算型属性，实例方法，类型方法，构造器，类型别名，甚至其他枚举，结构体，和类。枚举声明不能包含析构器或者协议声明。 - -枚举类型可以采纳任意数量的协议，但是枚举不能从类，结构体和其他枚举继承。 - -不同于类或者结构体，枚举类型并不提供隐式的默认构造器，所有构造器必须显式声明。一个构造器可以委托给枚举中的其他构造器，但是构造过程仅当构造器将一个枚举用例指定给 `self` 后才算完成。 - -和结构体类似但是和类不同，枚举是值类型。枚举实例在被赋值到变量或常量时，或者传递给函数作为参数时会被复制。更多关于值类型的信息，请参阅 [结构体和枚举是值类型](../chapter2/09_Classes_and_Structures.md#structures_and_enumerations_are_value_types)。 - -可以扩展枚举类型，正如在 [扩展声明](#extension_declaration) 中讨论的一样。 - - -### 包含任意类型用例的枚举 - -如下的形式声明了一个包含任意类型枚举用例的枚举变量： - -```swift -enum 枚举名称: 采纳的协议 { - case 枚举用例1 - case 枚举用例2(关联值类型) -} -``` - -这种形式的枚举声明在其他语言中有时被叫做可识别联合。 - -在这种形式中，每个用例块由关键字 `case` 开始，后面紧接一个或多个以逗号分隔的枚举用例。每个用例名必须是独一无二的。每个用例也可以指定它所存储的指定类型的值，这些类型在关联值类型的元组中被指定，紧跟用例名之后。 - -具有关联值的枚举用例可以像函数一样使用，从而通过指定的关联值创建一个枚举实例。和真正的函数一样，你可以获取一个枚举用例的引用，然后在后续代码中调用它。 - -```swift -enum Number { - case Integer(Int) - case Real(Double) -} - -// f 的类型为 (Int) -> Number -let f = Number.Integer - -// 利用 f 把一个整数数组转成 Number 数组 -let evenInts: [Number] = [0, 2, 4, 6].map(f) -``` - -要获得更多关于具有关联值的枚举用例的信息和例子，请参阅 [关联值](../chapter2/08_Enumerations.md#associated_values)。 - - -### 递归枚举 - -枚举类型可以具有递归结构，就是说，枚举用例的关联值类型可以是枚举类型自身。然而，枚举类型的实例具有值语义，这意味着它们在内存中有着固定的位置。为了支持递归，编译器必须插入一个间接层。 - -要让某个枚举用例支持递归，使用 `indirect` 声明修饰符标记该用例。 - -```swift -enum Tree