梁杰
@ -96,11 +96,8 @@ println("A marathon is \(aMarathon) meters long")
|
||||
扩展能向类中添加新的便利构造器，但是它们不能向类中添加新的指定构造器或析构函数。指定构造器和析构函数必须总是由原始的类实现来提供。
|
||||
|
||||
> 注意：
|
||||
如果你使用扩展向一个值类型添加一个构造器，该构造器向所有的存储属性提供默认值，而且没有定义任何定制构造器（custom initializers），那么对于来自你的扩展构造器中的值类型，你可以调用默认构造器(default initializers)和逐一成员构造器(memberwise initializers)。
|
||||
正如在值类型的构造器授权中描述的，如果你已经把构造器写成值类型原始实现的一部分，上述规则不再适用。
|
||||
如果你使用扩展向一个值类型添加一个构造器，在该值类型已经向所有的存储属性提供默认值，而且没有定义任何定制构造器（custom initializers）时，你可以在值类型的扩展构造器中调用默认构造器(default initializers)和逐一成员构造器(memberwise initializers)。
|
||||
|
||||
|
||||
如果你使用扩展向一个值类型添加一个构造器，如果该值类型已经向所有的存储属性提供默认值，而且没有定义任何定制构造器（custom initializers），那么你可以在值类型的扩展构造器中调用默认构造器(default initializers)和逐一成员构造器(memberwise initializers)。
|
||||
正如在值类型的构造器委托中描述的，如果你已经把构造器写成值类型原始实现的一部分，上述规则不再适用。
|
||||
|
||||
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
|
||||
|
||||
> 翻译：[takalard](https://github.com/takalard)
|
||||
> 校对：[lifedim](https://github.com/lifedim)
|
||||
|
||||
@ -320,9 +320,9 @@ let stringIndex = findIndex(["Mike", "Malcolm", "Andrea"], "Andrea")
|
||||
```
|
||||
|
||||
<a name="associated_types"></a>
|
||||
##关联类型
|
||||
##关联类型(Associated Types)
|
||||
|
||||
当定义一个协议时，有的时候声明一个或多个关联类型作为协议定义的一部分是非常有用的。一个关联类型给定作用于协议部分的类型一个节点名（或*别名*）。作用于关联类型上实际类型是不需要指定的，直到该协议接受。关联类型被指定为`typealias`关键字。
|
||||
当定义一个协议时，有的时候声明一个或多个关联类型作为协议定义的一部分是非常有用的。一个关联类型作为协议的一部分，给定了类型的一个占位名（或别名）。作用于关联类型上实际类型在协议被实现前是不需要指定的。关联类型被指定为`typealias`关键字。
|
||||
|
||||
### 关联类型行为
|
||||
|
||||
@ -343,19 +343,19 @@ protocol Container {
|
||||
- 必须可能通过使用`count`属性获取容器里items的数量，并返回一个`Int`值；
|
||||
- 必须可能通过容器的`Int`索引值下标可以检索到每一个item。
|
||||
|
||||
这个协议没有指定容器里item是如何存储的或何种类型是允许的。这个协议只指定三个任何遵循`Container`类型所必须支持的功能点。一个遵循的类型也可以提供其他额外的功能，只要满足这三个条件。
|
||||
这个协议没有指定容器里item是如何存储的或何种类型是允许的。这个协议只指定三个任何遵循`Container`类型所必须支持的功能点。一个遵循的类型在满足这三个条件的情况下也可以提供其他额外的功能。
|
||||
|
||||
任何遵循`Container`协议的类型必须指定存储在其里面的值类型，必须保证只有正确类型的items可以加进容器里，必须明确可以通过其下标返回item类型。
|
||||
|
||||
为了定义这三个条件，`Container`协议需要一个方法指定容器里的元素将会保留，而不需要知道特定容器的类型。`Container`协议需要指定任何通过`append`方法添加到容器里的值和容器里元素是相同类型，并且通过容器下标返回的容器元素类型的值的类型是相同类型。
|
||||
|
||||
为了达到此目的，`Container`协议声明了一个ItemType的关联类型，写作`typealias ItemType`。这个协议不会定义`ItemType`是什么的别名，这个信息留给了任何遵循协议的类型来提供。尽管如此，`ItemType`别名支持一种方法识别在一个容器里的items类型，以及定义一种使用在`append`方法和下标中的类型，以便保证任何期望的`Container`的行为是强制性的。
|
||||
为了达到此目的，`Container`协议声明了一个ItemType的关联类型，写作`typealias ItemType`。这个协议不会定义`ItemType`是什么的别名，这个信息将由任何遵循协议的类型来提供。尽管如此，`ItemType`别名提供了一种识别Container中Items类型的方法，并且用于`append`方法和`subscript`方法的类型定义，以便保证任何`Container`期望的行为能够被执行。
|
||||
|
||||
这里是一个早前IntStack类型的非泛型版本，适用于遵循Container协议：
|
||||
这里是一个早前IntStack类型的非泛型版本，遵循Container协议：
|
||||
|
||||
```swift
|
||||
struct IntStack: Container {
|
||||
// original IntStack implementation
|
||||
// IntStack的原始实现
|
||||
var items = Int[]()
|
||||
mutating func push(item: Int) {
|
||||
items.append(item)
|
||||
@ -363,7 +363,7 @@ struct IntStack: Container {
|
||||
mutating func pop() -> Int {
|
||||
return items.removeLast()
|
||||
}
|
||||
// conformance to the Container protocol
|
||||
// 遵循Container协议的实现
|
||||
typealias ItemType = Int
|
||||
mutating func append(item: Int) {
|
||||
self.push(item)
|
||||
@ -427,13 +427,13 @@ extension Array: Container {}
|
||||
<a name="where_clauses"></a>
|
||||
## Where 语句
|
||||
|
||||
[类型约束](#type_constraints)中描述的类型约束确保你定义关于类型参数的需求和一泛型函数或类型有关联。
|
||||
[类型约束](#type_constraints)能够确保类型符合泛型函数或类的定义约束。
|
||||
|
||||
对于关联类型的定义需求也是非常有用的。你可以通过这样去定义*where语句*作为一个类型参数队列的一部分。一个`where`语句使你能够要求一个关联类型遵循一个特定的协议，以及（或）那个特定的类型参数和关联类型可以是相同的。你可写一个`where`语句，通过紧随放置`where`关键字在类型参数队列后面，其后跟着一个或者多个针对关联类型的约束，以及（或）一个或多个类型和关联类型的等于关系。
|
||||
对关联类型定义约束是非常有用的。你可以在参数列表中通过*where*语句定义参数的约束。一个`where`语句能够使一个关联类型遵循一个特定的协议，以及（或）那个特定的类型参数和关联类型可以是相同的。你可以写一个`where`语句，紧跟在在类型参数列表后面，where语句后跟一个或者多个针对关联类型的约束，以及（或）一个或多个类型和关联类型间的等价(equality)关系。
|
||||
|
||||
下面的列子定义了一个名为`allItemsMatch`的泛型函数，用来检查是否两个`Container`单例包含具有相同顺序的相同元素。如果匹配到所有的元素，那么返回一个为`true`的`Boolean`值，反之，则相反。
|
||||
下面的例子定义了一个名为`allItemsMatch`的泛型函数，用来检查两个`Container`实例是否包含相同顺序的相同元素。如果所有的元素能够匹配，那么返回一个为`true`的`Boolean`值，反之则为`false`。
|
||||
|
||||
这两个容器可以被检查出是否是相同类型的容器（虽然它们可以是），但它们确实拥有相同类型的元素。这个需求通过一个类型约束和`where`语句结合来表示：
|
||||
被检查的两个`Container`可以不是相同类型的容器（虽然它们可以是），但它们确实拥有相同类型的元素。这个需求通过一个类型约束和`where`语句结合来表示：
|
||||
|
||||
```swift
|
||||
func allItemsMatch<
|
||||
@ -441,19 +441,19 @@ func allItemsMatch<
|
||||
where C1.ItemType == C2.ItemType, C1.ItemType: Equatable>
|
||||
(someContainer: C1, anotherContainer: C2) -> Bool {
|
||||
|
||||
// check that both containers contain the same number of items
|
||||
// 检查两个Container的元素个数是否相同
|
||||
if someContainer.count != anotherContainer.count {
|
||||
return false
|
||||
}
|
||||
|
||||
// check each pair of items to see if they are equivalent
|
||||
// 检查两个Container相应位置的元素彼此是否相等
|
||||
for i in 0..someContainer.count {
|
||||
if someContainer[i] != anotherContainer[i] {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
// all items match, so return true
|
||||
// 如果所有元素检查都相同则返回true
|
||||
return true
|
||||
|
||||
}
|
||||
@ -506,7 +506,7 @@ if allItemsMatch(stackOfStrings, arrayOfStrings) {
|
||||
// 输出 "All items match."
|
||||
```
|
||||
|
||||
上面的例子创建一个`Stack`单例来存储`String`，然后压了三个字符串进栈。这个例子也创建了一个`Array`单例，并初始化包含三个同栈里一样的原始字符串。即便栈和数组否是不同的类型，但它们都遵循`Container`协议，而且它们都包含同样的类型值。你因此可以调用`allItemsMatch`函数，用这两个容器作为它的参数。在上面的例子中，`allItemsMatch`函数正确的显示了所有的这两个容器的`items`匹配。
|
||||
上面的例子创建一个`Stack`单例来存储`String`，然后压了三个字符串进栈。这个例子也创建了一个`Array`单例，并初始化包含三个同栈里一样的原始字符串。即便栈和数组是不同的类型，但它们都遵循`Container`协议，而且它们都包含同样的类型值。因此你可以调用`allItemsMatch`函数，用这两个容器作为它的参数。在上面的例子中，`allItemsMatch`函数正确的显示了所有的这两个容器的`items`匹配。
|
||||
|
||||
[1]: ../chapter2/06_Functions.html
|
||||
[2]: https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/stackPushPop_2x.png
|
||||
@ -515,4 +515,4 @@ if allItemsMatch(stackOfStrings, arrayOfStrings) {
|
||||
[5]: ../chapter2/04_Collection_Types.html
|
||||
[6]: ../chapter2/21_Protocols.html
|
||||
[7]: ../chapter2/21_Protocols.html
|
||||
[8]: #type_constraints
|
||||
[8]: #type_constraints
|
||||
|
||||
@ -12,18 +12,18 @@
|
||||
- [运算符函数(Operator Functions)](#operator_functions)
|
||||
- [自定义运算符](#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中，你可以为你创建的所有类型定制运算符的操作。
|
||||
|
||||
可定制的运算符并不限于那些预设的运算符，自定义有个性的中置，前置，后置及赋值运算符，当然还有优先级和结合性。这些运算符的实现可以运用预设的运算符，也可以运用之前定制的运算符。
|
||||
可定制的运算符并不限于那些预设的运算符，你可以自定义中置，前置，后置及赋值运算符，当然还有优先级和结合性。这些运算符在代码中可以像预设的运算符一样使用，你也可以扩展已有的类型以支持你自定义的运算符。
|
||||
|
||||
<a name="bitwise_operators"></a>
|
||||
## 位运算符
|
||||
|
||||
位操作符通常在诸如图像处理和创建设备驱动等底层开发中使用，使用它可以单独操作数据结构中原始数据的比特位。在使用一个自定义的协议进行通信的时候，运用位运算符来对原始数据进行编码和解码也是非常有效的。
|
||||
位操作符可以操作数据结构中原始数据的每个比特位。位操作符通常在诸如图像处理和创建设备驱动等底层开发中使用，位操作符在同外部资源的数据进行交互的时候也很有用，比如在使用用户协议进行通信的时候，运用位运算符来对原始数据进行编码和解码。
|
||||
|
||||
Swift支持如下所有C语言的位运算符：
|
||||
|
||||
@ -33,7 +33,7 @@ Swift支持如下所有C语言的位运算符：
|
||||
|
||||
|
||||
|
||||
这个运算符是前置的，所以请不加任何空格地写着操作数之前。
|
||||
这个运算符是前置的，所以请不加任何空格地写在操作数之前。
|
||||
|
||||
```swift
|
||||
let initialBits: UInt8 = 0b00001111
|
||||
@ -124,9 +124,9 @@ let blueComponent = pink & 0x0000FF // blueComponent 是 0x99, 即 153
|
||||
|
||||
对`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`。
|
||||
|
||||
@ -160,7 +160,7 @@ let blueComponent = pink & 0x0000FF // blueComponent 是 0x99, 即 153
|
||||
|
||||
第二，由于使用二进制补码表示，我们可以和正数一样对负数进行按位左移右移的，同样也是左移1位时乘于`2`，右移1位时除于`2`。要达到此目的，对有符整型的右移有一个特别的要求：
|
||||
|
||||
对有符整型按位右移时，使用符号位(正数为`0`，负数为`1`)填充空白位。
|
||||
对有符整型按位右移时，不使用0填充空白位，而是根据符号位(正数为`0`，负数为`1`)填充空白位。
|
||||
|
||||
|
||||
|
||||
@ -200,7 +200,7 @@ potentialOverflow += 1
|
||||
var willOverflow = UInt8.max
|
||||
// willOverflow 等于UInt8的最大整数 255
|
||||
willOverflow = willOverflow &+ 1
|
||||
// 这时候 willOverflow 等于 0
|
||||
// 此时 willOverflow 等于 0
|
||||
```
|
||||
|
||||
`willOverflow`用`Int8`所能承载的最大值`255`(二进制`11111111`)，然后用`&+`加1。然后`UInt8`就无法表达这个新值的二进制了，也就导致了这个新值上溢出了，大家可以看下图。溢出后，新值在`UInt8`的承载范围内的那部分是`00000000`，也就是`0`。
|
||||
@ -234,7 +234,7 @@ willUnderflow = willUnderflow &- 1
|
||||
var signedUnderflow = Int8.min
|
||||
// signedUnderflow 等于最小的有符整数 -128
|
||||
signedUnderflow = signedUnderflow &- 1
|
||||
// 如今 signedUnderflow 等于 127
|
||||
// 此时 signedUnderflow 等于 127
|
||||
```
|
||||
|
||||
### 除零溢出
|
||||
@ -400,7 +400,7 @@ let afterIncrement = ++toIncrement
|
||||
```
|
||||
|
||||
>注意：
|
||||
默认的赋值符是不可重载的。只有组合赋值符可以重载。三目条件运算符 `a？b：c` 也是不可重载。
|
||||
默认的赋值符(=)是不可重载的。只有组合赋值符可以重载。三目条件运算符 `a？b：c` 也是不可重载。
|
||||
|
||||
### 比较运算符
|
||||
|
||||
@ -451,7 +451,7 @@ operator prefix +++ {}
|
||||
}
|
||||
```
|
||||
|
||||
`Vector2D` 的 `+++` 的实现和 `++` 的实现很接近, 唯一不同的前者是加自己, 后者是加值为 `(1.0, 1.0)` 的向量.
|
||||
`Vector2D` 的 `+++` 的实现和 `++` 的实现很接近, 唯一不同的是前者是加自己, 后者是加值为 `(1.0, 1.0)` 的向量.
|
||||
|
||||
```swift
|
||||
var toBeDoubled = Vector2D(x: 1.0, y: 4.0)
|
||||
|
||||
Reference in New Issue
Block a user