按校对规则大致修改

2014-06-11 13:13:30 +08:00
parent 80113e117f
commit 318665111f
2 changed files with 134 additions and 119 deletions
--- a/source/chapter2/02_Basic_Operators.md
+++ b/source/chapter2/02_Basic_Operators.md
@ -1,28 +1,38 @@
 # 基本运算符
+-----------------
+
+本页包含内容：
+
+- [术语](#terminology) 
+- [赋值运算符](#assignment_operator) 
+- [数值运算符](#arithmetic_operators) 
+- [组合赋值运算符(Compound Assignment Operators)](#compound_assignment_operators) 
+- [比较运算符](#comparison_operators) 
+- [三目条件运算符(Ternary Conditional Operator)](#ternary_conditional_operator) 
+- [区间运算符](#range_operators) 
+- [逻辑运算符](#logical_operators) 

 运算符是检查，改变，合并值的特殊符号或短语。例如，加号`+`把计算两个数的和(如 `let i = 1 + 2`)。复杂些的运行算包括逻辑与`&&`(如 `if enteredDoorCode && passedRetinaScan`)，还有自增运算符`++i`这样让自身加一的便捷运算。

-Swift支持大部分标准C语言的运算符，且改进许多特性来减少常规编码错误。如，赋值符`=`不返回值，以防止错把等号`==`写成赋值号`=`而导致Bug。数值运算符(`+`，`-`，`*`，`/`，`%`等)会检测并不允许值溢出，以此来避免保存变量时由于变量大于或小于其类型所能承载的范围时导致的异常结果。当然允许你选择使用Swift的溢出运算符来玩溢出。具体使用请移步[溢出运算符](Overflow Operators)。
+Swift支持大部分标准C语言的运算符，且改进许多特性来减少常规编码错误。如，赋值符`=`不返回值，以防止错把等号`==`写成赋值号`=`而导致Bug。数值运算符(`+`，`-`，`*`，`/`，`%`等)会检测并不允许值溢出，以此来避免保存变量时由于变量大于或小于其类型所能承载的范围时导致的异常结果。当然允许你选择使用Swift的溢出运算符来玩溢出。具体使用请移步[溢出运算符](23_Advanced_Operators.html#overflow_operators)。

 区别于C语言，在Swift中你可以对浮点数进行取余运算(`%`)，还提供了C语言没有的表达两数之间的值的区间运算符，(`a..b`和`a...b`)，这方便我们表达一个区间内的数值。

-本章节只描述了Swift中的基本运算符，[高级运算符](http：//#)包含了高级运算符，及如何自定义运算符，及如何进行自定义类型的运算符重载。
+本章节只描述了Swift中的基本运算符，[高级运算符](23_Advanced_Operators.html)包含了高级运算符，及如何自定义运算符，及如何进行自定义类型的运算符重载。

-# 术语
+<a name="terminology"></a>
+## 术语

 运算符有一目，双目和三目运算符。

-一目运算符对单一操作对象操作，如`-a`。
+- 一目运算符对单一操作对象操作，如`-a`。一目运算符分前置符和后置运算符，前置运算符需紧排操作对象之前，如`!b`，后置运算符需紧跟操作对象之后，如`i++`，
+- 双目运算符操作两个操作对象，如 `2 + 3`。是中置的，因为它们出现在两个操作对象之间。
+- 三目运算符操作三个操作对象，和C语言一样，Swift只有一个三目运算符，就是三目条件运算符 `a？b：c`。

-一目运算符分前置符和后置运算符，前置运算符需紧排操作对象之前，如`!b`，后置运算符需紧跟操作对象之后，如`i++`，
+受运算符影响的值叫操作数，在表达式`1 + 2`中，加号`+`是双目运算符，它的两个操作数是值`1`和`2`。

-双目运算符操作两个操作对象，如 `2 + 3`。是中置的，因为它们出现在两个操作对象之间。
-
-三目运算符操作三个操作对象，和C语言一样，Swift只有一个三目运算符，就是三目条件运算符 `a？b：c`。
-
-受运算符影响的值叫操作数，在表达式 `1 + 2` 中，加号`+`是双目运算符，它的两个操作数是值`1`和`2`。
-
-# 赋值运算符
+<a name="assignment_operator"></a>
+## 赋值运算符

 赋值运算 `a = b`，表示用`b`的值来初始化或更新`a`的值。

@ -48,7 +58,8 @@ if x = y {

 这个特性使得你不无法把`==`错写成`=`了，由于`if x = y`是错误代码，Swift从底层帮你避免了这些代码错误。

-# 数值运算
+<a name="arithmetic_operators"></a>
+## 数值运算

 Swift让所有数值类型都支持了基本的四则运算：

@ -64,7 +75,7 @@ Swift让所有数值类型都支持了基本的四则运算：
 10.0 / 2.5  // 等于 4.0
 ```

-与C语言和Objective-C不同的是，Swift默认不允许在数值运算中出现溢出情况。但你可以使用Swift的溢出运算符来达到你有目的的溢出，(如 `a &+ b`)。详情请移步：[溢出运算符](Overflow Operators)。
+与C语言和Objective-C不同的是，Swift默认不允许在数值运算中出现溢出情况。但你可以使用Swift的溢出运算符来达到你有目的的溢出，(如 `a &+ b`)。详情请移步：[溢出运算符](23_Advanced_Operators.html#overflow_operators)。

 加法操作`+`也用于字符串的拼接：

@ -81,38 +92,21 @@ let dogCow = dog + cow
 // 译者注: 原谅的引号内是很可爱的小狗和小牛, 但win os下不支持表情字符, 所以改成了普通字符
 // dogCow 现在是 "dc"
 ```
-详细请点击[字符，字符串的拼接](http：//#)。
+详细请点击[字符，字符串的拼接](03_Strings_and_Characters.html#concatenating_strings_and_characters)。

-# 求余运算
+### 求余运算

 求余运算 `a % b` 是计算`b`的多少倍刚刚好可以容入`a`，多出来的那部分叫余数。

-> 注意
+>注意：
+求余运算(%)在其他语言也叫取模运算。然而严格说来，我们看该运算符对负数的操作结果，"求余"比"取模"更合适些。

-> 求余运算(%)在其他语言也叫取模运算。然而严格说来，我们看该运算符对负数的操作结果，`求余` 比 `取模` 更合适些。
+我们来谈谈取余是怎么回事，计算`9 % 4`，你先计算出4的多少倍会刚好可以容入`9`中。

-我们来谈谈取余是怎么回事，计算 `9 % 4`，你先计算出4的多少倍会刚好可以容入`9`中。
+2倍，非常好，那余数是1(用橙色标出)

-2倍，非常好，那余数是1(用'*'标出)

-<table>
-  <tr>
-    <td>1 </td>
-    <td>2 </td>
-    <td>3 </td>
-    <td>4 </td>
-    <td>5 </td>
-    <td>6 </td>
-    <td>7 </td>
-    <td>8 </td>
-    <td>9 </td>
-  </tr>
-  <tr>
-    <td colspan="4">4</td>
-    <td colspan="4">4</td>
-    <td>1*</td>
-  </tr>
-</table>
+![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")

 在Swift中这么来表达

@ -121,9 +115,9 @@ let dogCow = dog + cow
 ```

 为了得到 `a % b` 的结果，`%`计算了以下等式，并输出`余数`作为结果：
-```
-a = (b × 倍数) + 余数
-```
+
+*a = (b × 倍数) + 余数*
+
 当`倍数`取最大值的时候，就会刚好可以容入`a`中。

 把`9`和`4`代入等式中，我们得`1`：
@ -147,7 +141,7 @@ a = (b × 倍数) + 余数

 在对负数`-b`求余时，`-b`的符号会被忽略。这意味着 `a % b` 和 `a % -b`的结果是相同的。

-## 浮点数求余计算
+### 浮点数求余计算

 不同于C和Objective-C，Swift中是可以对浮点数进行求余的。

@ -155,9 +149,11 @@ a = (b × 倍数) + 余数
 8 % 2.5 // 等于 0.5
 ```

-这个例子中，8除于2。5等于3余0。5，所以结果是0。5。
+这个例子中，8除于2.5等于3余0.5，所以结果是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")
+
+### 自增和自增运算

 和C一样，Swift也提供了方便对变量本身加1或减1的自增`++`和自减`--`的运算符。其操作对象可以是整形和浮点型。
 ‌
@ -192,7 +188,7 @@ let c = a++ // a 现在 2, 但 c 是 a 自增前的值 1
 除非你需要使用`i++`的特性，不然推荐你使用`++i`和`--i`，因为先修改后返回这样的行为更符合我们的逻辑。


-# 单目负号
+### 单目负号

 数值的正负号可以使用前缀`-`(即单目负号)来切换：

@ -204,7 +200,7 @@ let plusThree = -minusThree   // plusThree 等于 3, 或 "负负3"

 单目负号写在操作数之前，中间没有空格。

-# 单目正号
+### 单目正号

 单目正号`+`不做任何改变地返回操作数的值。

@ -215,7 +211,8 @@ let alsoMinusSix = +minusSix  // alsoMinusSix 等于 -6
 虽然单目`+`做无用功，但当你在使用单目负号来表达负数时，你可以使用单目正号来表达正数，如此你的代码会具有对称美。


-# 复合赋值
+<a name="compound_assignment_operators"></a>
+## 复合赋值

 如同强大的C语言，Swift也提供把其他运算符和赋值运算`=`组合的复合赋值运算符，加赋运算`+=`是其中一个例子：

@ -226,13 +223,13 @@ a += 2 // a 现在是 3

 表达式 `a += 2` 是 `a = a + 2` 的简写，一个加赋运算就把加法和赋值两件事完成了。

-> 注意：
+>注意：
+复合赋值运算没有返回值，`let b = a += 2` 这类代码是错误。这不同于上面提到的自增和自减运算符。

-> 复合赋值运算没有返回值，`let b = a += 2` 这类代码是错误。这不同于上面提到的自增和自减运算符。
-
-[表达式](http：//#)里有复合运算符的完整列表。
+在[表达式](../chapter3/04_Expressions.html)章节里有复合运算符的完整列表。
 ‌
-# 比较运算
+<a name="comparison_operators"></a>
+## 比较运算

 所有标准C中的比较运算都可以在Swift中使用。

@ -244,8 +241,7 @@ a += 2 // a 现在是 3
 - 小于等于 `a <= b`

 > 注意：
-
-> Swift也提供恒等`===`和不恒等`!==`这两个比较符来判断两个对象是否引用同一个对象实例。更多细节在[类与结构](Classes and Structures)。
+Swift也提供恒等`===`和不恒等`!==`这两个比较符来判断两个对象是否引用同一个对象实例。更多细节在[类与结构](09_Classes_and_Structures.html)。

 每个比较运算都返回了一个标识表达式是否成立的布尔值：

@ -270,9 +266,10 @@ if name == "world" {
 // 输出 "hello, world", 因为 `name` 就是等于 "world"
 ```

-关于`if`语句，请看[控制流](Control Flow)。
+关于`if`语句，请看[控制流](05_Control_Flow.html)。

-# 三目条件运算
+<a name="ternary_conditional_operator"></a>
+## 三目条件运算

 三目条件运算的特殊在于它是有三个操作数的运算符，它的原型是 `问题？答案1：答案2`。它简洁地表达根据 `问题` 成立与否作出二选一的操作。如果 `问题` 成立，返回 `答案1` 的结果; 如果不成立，返回 `答案2` 的结果。

@ -314,11 +311,12 @@ if hasHeader {

 三目条件运算提供有效率且便捷的方式来表达二选一的选择。需要注意的事，过度使用三目条件运算就会由简洁的代码变成难懂的代码。我们应避免在一个组合语句使用多个三目条件运算符。

-# 区间运算符
+<a name="range_operators"></a>
+## 区间运算符

 Swift提供了两个方便表达一个区间的值的运算符。

-## 闭区间运算符
+### 闭区间运算符
 闭区间运算符`a...b`定义一个包含从`a`到`b`(包括`a`和`b`)的所有值的区间。
 ‌
 闭区间运算符在迭代一个区间的所有值时是非常有用的，如在`for-in`循环中：
@ -334,9 +332,9 @@ for index in 1...5 {
 // 5 * 5 = 25
 ```

-关于`for-in`，请看[控制流](Control Flow)。
+关于`for-in`，请看[控制流](05_Control_Flow.html)。

-## 半闭区间
+### 半闭区间

 半闭区间`a..b`定义一个从`a`到`b`但不包括`b`的区间。
 之所以称为半闭区间，是因为该区间包含第一个值而不包括最后的值。
@ -355,9 +353,11 @@ for i in 0..count {
 // 第 4 个人叫 Jack
 ```

-> 注意：数组有4个元素，但`0..count`只数到 3(最后一个元素的下标)，因为它是半闭区间。关于数组，请查阅[数组](Arrays)。
+> 注意：
+数组有4个元素，但`0..count`只数到 3(最后一个元素的下标)，因为它是半闭区间。关于数组，请查阅[数组](04_Collection_Types.html#arrays)。

-# 逻辑运算
+<a name="logical_operators"></a>
+## 逻辑运算

 逻辑运算的操作对象是逻辑布尔值。Swift支持基于C语言的三个标准逻辑运算。

@ -365,7 +365,7 @@ for i in 0..count {
 - 逻辑与 `a && b`
 - 逻辑或 `a || b`

-## 逻辑非
+### 逻辑非

 逻辑非运算`!a`对一个布尔值取反，使得`true`变`false`，`false`变`true`。

@ -383,7 +383,7 @@ if !allowedEntry {

 在示例代码中，小心地选择布尔常量或变量有助于代码的可读性，并且避免使用双重逻辑非运算，或混乱的逻辑语句。

-## 逻辑与
+### 逻辑与
 逻辑与 `a && b` 表达了只有`a`和`b`的值都为`true`时，整个表达式的值才会是`true`。

 只要任意一个值为`false`，整个表达式的值就为`false`。事实上，如果第一个值为`false`，那么是不去计算第二个值的，因为它已经不可能影响整个表达式的结果了。这被称做 "短路计算"。
@ -401,7 +401,7 @@ if enteredDoorCode && passedRetinaScan {
 // 输出 "ACCESS DENIED
 ```

-## 逻辑或
+### 逻辑或
 逻辑或 `a || b` 是一个由两个连续的`|`组成的中置运算符。它表示了两个逻辑表达式的其中一个为`true`，整个表达式就为`true`。

 同逻辑与运算类似，逻辑或也是"短路计算"的，当左端的表达式为`true`时，将不计算右边的表达式了，因为它不可能改变整个表达式的值了。
@ -419,7 +419,7 @@ if hasDoorKey || knowsOverridePassword {
 // 输出 "Welcome!"
 ```

-## 组合逻辑
+### 组合逻辑

 我们可以组合多个逻辑运算来表达一个复合逻辑：

@ -438,7 +438,7 @@ if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {

 前两种情况，我们都不满足，所以前两个简单逻辑的结果是`false`，但是我们是知道紧急情况下重置的密码的，所以整个复杂表达式的值还是`true`。

-## 使用括号来明确优先级
+### 使用括号来明确优先级

 为了一个复杂表达式更容易读懂，在合适的地方使用括号来明确优先级是很有效的，虽然它并非必要的。在上个关于门的权限的例子中，我们给第一个部分加个括号，使用它看起来逻辑更明确。