From 09e5a89cde9d7e4cbc0c3448cbfc4b6bf1fb0a0d Mon Sep 17 00:00:00 2001
From: 949478479 <949478479@qq.com>
Date: Mon, 30 Nov 2015 22:45:01 +0800
Subject: [PATCH] =?UTF-8?q?=E6=A0=A1=E5=AF=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
source/chapter2/25_Advanced_Operators.md | 123 ++++++++++++-----------
1 file changed, 63 insertions(+), 60 deletions(-)
diff --git a/source/chapter2/25_Advanced_Operators.md b/source/chapter2/25_Advanced_Operators.md
index 2fc08b6c..1bee1eb0 100644
--- a/source/chapter2/25_Advanced_Operators.md
+++ b/source/chapter2/25_Advanced_Operators.md
@@ -15,162 +15,165 @@
- [位运算符](#bitwise_operators)
- [溢出运算符](#overflow_operators)
-- [优先级和结合性(Precedence and Associativity)](#precedence_and_associativity)
-- [运算符函数(Operator Functions)](#operator_functions)
+- [优先级和结合性](#precedence_and_associativity)
+- [运算符函数](#operator_functions)
- [自定义运算符](#custom_operators)
除了在之前介绍过的[基本运算符](./02_Basic_Operators.html)，Swift 中还有许多可以对数值进行复杂操作的高级运算符。这些高级运算符包含了在 C 和 Objective-C 中已经被大家所熟知的位运算符和移位运算符。
-与C语言中的算术运算符不同，Swift 中的算术运算符默认是不会溢出的。所有溢出行为都会被捕获并报告为错误。如果想让系统允许溢出行为，可以选择使用 Swift 中另一套默认支持溢出的运算符，比如溢出加法运算符(`&+`)。所有的这些溢出运算符都是以 `&` 开头的。
+与 C 语言中的算术运算符不同，Swift 中的算术运算符默认是不会溢出的。所有溢出行为都会被捕获并报告为错误。如果想让系统允许溢出行为，可以选择使用 Swift 中另一套默认支持溢出的运算符，比如溢出加法运算符（`&+`）。所有的这些溢出运算符都是以 `&` 开头的。
-在定义自有的结构体、类和枚举时，最好也同时为它们提供标准Swift运算符的实现。Swift简化了运算符的自定义实现，也使判断不同类型所对应的行为更为简单。
+自定义结构体、类和枚举时，如果也为它们提供标准 Swift 运算符的实现，将会非常有用。在 Swift 中自定义运算符非常简单，运算符也会针对不同类型使用对应实现。
-我们不用被预定义的运算符所限制。在 Swift 当中可以自由地定义中缀、前缀、后缀和赋值运算符，以及相应的优先级与结合性。这些运算符在代码中可以像预设的运算符一样使用，我们甚至可以扩展已有的类型以支持自定义的运算符。
+我们不用被预定义的运算符所限制。在 Swift 中可以自由地定义中置、前置、后置和赋值运算符，以及相应的优先级与结合性。这些运算符在代码中可以像预定义的运算符一样使用，我们甚至可以扩展已有的类型以支持自定义的运算符。
## 位运算符
-位运算符(`Bitwise operators`)可以操作一个数据结构中每个独立的位。它们通常被用在底层开发中，比如图形编程和创建设备驱动。位运算符在处理外部资源的原始数据时也十分有用，比如对自定义通信协议传输的数据进行编码和解码。
+位运算符可以操作数据结构中每个独立的比特位。它们通常被用在底层开发中，比如图形编程和创建设备驱动。位运算符在处理外部资源的原始数据时也十分有用，比如对自定义通信协议传输的数据进行编码和解码。
-Swift 支持C语言中的全部位运算符，具体如下：
+Swift 支持 C 语言中的全部位运算符，接下来会一一介绍。
-### 按位取反运算符(Bitwise NOT Operator)
+### 按位取反运算符
-按位取反运算符(`~`) 可以对一个数值的全部位进行取反：
+按位取反运算符（`~`）可以对一个数值的全部比特位进行取反：
-按位取反操作符是一个前置运算符，需要直接放在操作数的之前，并且它们之间不能添加任何空格。
+按位取反运算符是一个前置运算符，需要直接放在操作数的之前，并且它们之间不能添加任何空格：
```
let initialBits: UInt8 = 0b00001111
-let invertedBits = ~initialBits // 等于 0b11110000
+let invertedBits = ~initialBits // 等于 0b11110000
```
-`UInt8` 类型的整数有 8 个比特位，可以存储 0 ~ 255之间的任意整数。这个例子初始化了一个 `UInt8` 类型的整数，并赋值为二进制的 `00001111`，它的前 4 位都为`0`，后 4 位都为`1`。这个值等价于十进制的 `15` 。
+`UInt8` 类型的整数有 8 个比特位，可以存储 `0 ~ 255` 之间的任意整数。这个例子初始化了一个 `UInt8` 类型的整数，并赋值为二进制的 `00001111`，它的前 4 位都为 `0`，后 4 位都为 `1`。这个值等价于十进制的 `15`。
接着使用按位取反运算符创建了一个名为 `invertedBits` 的常量，这个常量的值与全部位取反后的 `initialBits` 相等。即所有的 `0` 都变成了 `1`，同时所有的 `1` 都变成 `0`。`invertedBits` 的二进制值为 `11110000`，等价于无符号十进制数的 `240`。
-### 按位与运算符(Bitwise AND Operator)
+### 按位与运算符
-按位与运算符(`&`)可以对两个数的比特位进行合并。它返回一个新的数，只有当两个操作数的对应位*都*为 `1` 的时候，该数的对应位才为 `1`。
+按位与运算符（`&`）可以对两个数的比特位进行合并。它返回一个新的数，只有当两个操作数的对应位都为 `1` 的时候，新数的对应位才为 `1`：
-
+
-在下面的示例当中，`firstSixBits` 和 `lastSixBits` 中间 4 个位的值都为 1 。按位与运算符对它们进行了运算，得到二进制数值 `00111100`，等价于无符号十进制数的 `60`：
+在下面的示例当中，`firstSixBits` 和 `lastSixBits` 中间 4 个位的值都为 `1`。按位与运算符对它们进行了运算，得到二进制数值 `00111100`，等价于无符号十进制数的 `60`：
```
let firstSixBits: UInt8 = 0b11111100
let lastSixBits: UInt8 = 0b00111111
-let middleFourBits = firstSixBits & lastSixBits // 等于 00111100
+let middleFourBits = firstSixBits & lastSixBits // 等于 00111100
```
-
-### 按位或运算符(Bitwise OR Operator)
-按位或运算符(`|`)可以对两个数的比特位进行比较。它返回一个新的数，只要两个操作数的对应位中有*任意*一个为 `1` 时，该数的对应位就为 `1`。
+
+### 按位或运算符
+
+按位或运算符（`|`）可以对两个数的比特位进行比较。它返回一个新的数，只要两个操作数的对应位中有任意一个为 `1` 时，新数的对应位就为 `1`：
-在下面的示例当中，`someBits` 和 `moreBits` 将不同的位设置为 `1`。接位或运算符对它们进行了运算，得到二进制数值 `11111110`，等价于无符号十进制数的 `254`：
+在下面的示例中，`someBits` 和 `moreBits` 不同的位会被设置为 `1`。接位或运算符对它们进行了运算，得到二进制数值 `11111110`，等价于无符号十进制数的 `254`：
```
let someBits: UInt8 = 0b10110010
let moreBits: UInt8 = 0b01011110
-let combinedbits = someBits | moreBits // 等于 11111110
+let combinedbits = someBits | moreBits // 等于 11111110
```
-
-### 按位异或运算符(Bitwise XOR Opoerator)
-按位异或运算符(`^`)可以对两个数的比特位进行比较。它返回一个新的数，当两个操作数的对应位不相同时，该数的对应位就为 `1`：
+
+### 按位异或运算符
+
+按位异或运算符（`^`）可以对两个数的比特位进行比较。它返回一个新的数，当两个操作数的对应位不相同时，新数的对应位就为 `1`：
-在下面的示例当中，`firstBits` 和 `otherBits` 都有一个自己设置为 `1` 而对方设置为 `0` 的位。 按位异或运算符将这两个位都设置为 `1`，同时将其它位都设置为 `0`：
+在下面的示例当中，`firstBits` 和 `otherBits` 都有一个自己的位为 `1` 而对方的对应位为 `0` 的位。 按位异或运算符将新数的这两个位都设置为 `1`，同时将其它位都设置为 `0`：
```
let firstBits: UInt8 = 0b00010100
let otherBits: UInt8 = 0b00000101
-let outputBits = firstBits ^ otherBits // 等于 00010001
+let outputBits = firstBits ^ otherBits // 等于 00010001
```
-
-### 按位左移/右移运算符(Bitwise Left and Right Shift Operators)
-按位左移运算符(`<<`)和按位右移运算符(`>>`)可以对一个数进行指定位数的左移和右移，但是需要遵守下面定义的规则。
+
+### 按位左移、右移运算符
+
+按位左移运算符（`<<`）和按位右移运算符（`>>`）可以对一个数的所有位进行指定位数的左移和右移，但是需要遵守下面定义的规则。
对一个数进行按位左移或按位右移，相当于对这个数进行乘以 2 或除以 2 的运算。将一个整数左移一位，等价于将这个数乘以 2，同样地，将一个整数右移一位，等价于将这个数除以 2。
-#### 无符号整型的移位操作
+#### 无符号整数的移位操作
-对无符号整型进行移位的规则如下：
+对无符号整数进行移位的规则如下：
-1. 已经存在的比特位按指定的位数进行左移和右移。
-2. 任何移动超出整型存储边界的位都会被丢弃。
-3. 用 0 来填充移动后产生的空白位。
+1. 已经存在的位按指定的位数进行左移和右移。
+2. 任何因移动而超出整型存储范围的位都会被丢弃。
+3. 用 `0` 来填充移位后产生的空白位。
-这种方法称为逻辑移位(`logical shift`)。
+这种方法称为逻辑移位。
-以下这张图展示了 `11111111 << 1`(即把 `11111111` 向左移动 1 位)，和 `11111111 >> 1`(即把 `11111111` 向右移动 1 位) 的结果。蓝色的部分是被移位的，灰色的部分是被抛弃的，橙色的部分则是被填充进来的。
+以下这张图展示了 `11111111 << 1`（即把 `11111111` 向左移动 `1` 位），和 `11111111 >> 1`（即把 `11111111` 向右移动 `1` 位）的结果。蓝色的部分是被移位的，灰色的部分是被抛弃的，橙色的部分则是被填充进来的：
下面的代码演示了 Swift 中的移位操作：
```
-let shiftBits: UInt8 = 4 // 即二进制的00000100
-shiftBits << 1 // 00001000
-shiftBits << 2 // 00010000
-shiftBits << 5 // 10000000
-shiftBits << 6 // 00000000
-shiftBits >> 2 // 00000001
+let shiftBits: UInt8 = 4 // 即二进制的 00000100
+shiftBits << 1 // 00001000
+shiftBits << 2 // 00010000
+shiftBits << 5 // 10000000
+shiftBits << 6 // 00000000
+shiftBits >> 2 // 00000001
```
可以使用移位操作对其他的数据类型进行编码和解码：
```
let pink: UInt32 = 0xCC6699
-let redComponent = (pink & 0xFF0000) >> 16 // redComponent 是 0xCC, 即 204
-let greenComponent = (pink & 0x00FF00) >> 8 // greenComponent 是 0x66, 即 102
-let blueComponent = pink & 0x0000FF // blueComponent 是 0x99, 即 153
+let redComponent = (pink & 0xFF0000) >> 16 // redComponent 是 0xCC，即 204
+let greenComponent = (pink & 0x00FF00) >> 8 // greenComponent 是 0x66， 即 102
+let blueComponent = pink & 0x0000FF // blueComponent 是 0x99，即 153
```
-这个示例使用了一个命名为 `pink` 的 `UInt32` 型常量来存储层叠样式表(`CSS`)中粉色的颜色值。该 `CSS` 的十六进制颜色值 `#CC6699`， 在 Swift 中表示为 `0xCC6699`。然后利用按位与运算符(`&`)和按位右移运算符(`>>`)从这个颜色值中分解出红(`CC`)、绿(`66`)以及蓝(`99`)三个部分。
+这个示例使用了一个命名为 `pink` 的 `UInt32` 型常量来存储 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` 和 `0x0000FF` 进行按位与运算得到 `0x000099`。并且不需要进行向右移位，所以结果为 `0x99` ，也就是十进制数值的 `153`。
+最后，蓝色部分通过对 `0xCC6699` 和 `0x0000FF` 进行按位与运算得到 `0x000099`。这里不需要再向右移位，所以结果为 `0x99` ，也就是十进制数值的 `153`。
-#### 有符号整型的移位操作
+#### 有符号整数的移位操作
-对比无符号整型来说，有符整型的移位操作相对复杂得多，这种复杂性源于有符号整数的二进制表现形式。(为了简单起见，以下的示例都是基于 8 位有符号整数的，但是其中的原理对任何位数的有符号整数都是通用的。)
+对比无符号整数，有符号整数的移位操作相对复杂得多，这种复杂性源于有符号整数的二进制表现形式。（为了简单起见，以下的示例都是基于 8 比特位的有符号整数的，但是其中的原理对任何位数的有符号整数都是通用的。）
-有符号整数使用第 1 个比特位(通常被称为符号位)来表示这个数的正负。符号位为 `0` 代表正数，为 `1` 代表负数。
+有符号整数使用第 1 个比特位（通常被称为符号位）来表示这个数的正负。符号位为 `0` 代表正数，为 `1` 代表负数。
-其余的比特位(通常被称为数值位)存储了这个数的真实值。有符号正整数和无符号数的存储方式是一样的，都是从 `0` 开始算起。这是值为 `4` 的 `Int8` 型整数的二进制位表现形式：
+其余的比特位（通常被称为数值位）存储了实际的值。有符号正整数和无符号数的存储方式是一样的，都是从 `0` 开始算起。这是值为 `4` 的 `Int8` 型整数的二进制位表现形式：
符号位为 `0`，说明这是一个正数，另外 7 位则代表了十进制数值 `4` 的二进制表示。
-负数的存储方式略有不同。它存储的是 `2` 的 n 次方减去它的真实值绝对值，这里的 n 为数值位的位数。一个 8 位的数有 7 个数值位，所以是 2 的 7 次方，即 128。
+负数的存储方式略有不同。它存储的值的绝对值等于 `2` 的 `n` 次方减去它的实际值（也就是数值位表示的值），这里的 `n` 为数值位的比特位数。一个 8 比特位的数有 7 个比特位是数值位，所以是 `2` 的 `7` 次方，即 `128`。
这是值为 `-4` 的 `Int8` 型整数的二进制位表现形式：
-这次的符号位为 `1`，说明这是一个负数，另外 7 个位则代表了数值 `124`(即 `128 - 4`) 的二进制表示。
+这次的符号位为 `1`，说明这是一个负数，另外 7 个位则代表了数值 `124`（即 `128 - 4`）的二进制表示：
-负数的表示通常被称为二进制补码(`two's complement`)表示法。用这种方法来表示负数乍看起来有点奇怪，但它有几个优点。
+负数的表示通常被称为二进制补码表示。用这种方法来表示负数乍看起来有点奇怪，但它有几个优点。
首先，如果想对 `-1` 和 `-4` 进行加法操作，我们只需要将这两个数的全部 8 个比特位进行相加，并且将计算结果中超出 8 位的数值丢弃：
@@ -178,13 +181,13 @@ let blueComponent = pink & 0x0000FF // blueComponent 是 0x99, 即 153
其次，使用二进制补码可以使负数的按位左移和右移操作得到跟正数同样的效果，即每向左移一位就将自身的数值乘以 2，每向右一位就将自身的数值除以 2。要达到此目的，对有符号整数的右移有一个额外的规则：
-* 当对正整数进行按位右移操作时，遵循与无符号整数相同的规则，但是对于移位产生的空白位使用*符号位*进行填充，而不是用 0。
+* 当对正整数进行按位右移操作时，遵循与无符号整数相同的规则，但是对于移位产生的空白位使用符号位进行填充，而不是用 `0`。
-这个行为可以确保有符号整数的符号位不会因为右移操作而改变，这通常被称为算术移位(`arithmetic shift`)。
+这个行为可以确保有符号整数的符号位不会因为右移操作而改变，这通常被称为算术移位。
-由于正数和负数的特殊存储方式，在对它们进行右移的时候，会使它们越来越接近 0。在移位的过程中保持符号位不变，意味着负整数在接近 `0` 的过程中会一直保持为负。
+由于正数和负数的特殊存储方式，在对它们进行右移的时候，会使它们越来越接近 `0`。在移位的过程中保持符号位不变，意味着负整数在接近 `0` 的过程中会一直保持为负。
## 溢出运算符