2020-07-09 23:06:21

docs/swift/12.md

@@ -80,7 +80,7 @@ Value Smaller
 
 * * *
 
-根据运算符执行的**操作，**可以分类为：
+根据执行的**操作**，运算符可以分类为：
 
 ## 1.赋值运算符
 
@@ -120,7 +120,7 @@ iOS
 
 上面的示例将整数值 10 分配给常数`age`。 因此，语句`print(age)`在控制台中输出 10。
 
-同样，语句`let platform = "iOS"`将字符串文字`"iOS"`分配给常量`platform`。 因此，语句`print(platform)`在控制台中输出 **iOS** 。
+同样，语句`let platform = "iOS"`将字符串文字`"iOS"`分配给常量`platform`。 因此，语句`print(platform)`在控制台中输出`iOS`。
 
 ### 示例 5：复合赋值运算符
 
@@ -153,7 +153,7 @@ Swift Arithmetic Operators
 | + | 加法（也用于字符串连接） |
 | - | 减法运算符 |
 | * | 乘法运算符 |
-| / | 部门运营商 |
+| / | 部门运算符 |
 | % | 余数运算符 |
 
 ### 示例 6：简单的算术运算

docs/swift/13.md

@@ -16,21 +16,21 @@
 
 Swift Standard Library Precedence Groups (Highest to Lowest)
 
-| 运营商集团 | 例子 |
+| 运算符分组 | 例子 |
 | --- | --- |
-| 按位移位优先 | > > & < < & > > > > |
-| 乘法优先级 | & *％& * / |
-| 加法优先级 | &#124; & + &-+-^ |
-| 范围形成优先 | .. < ... |
-| 投放优先 | 就像 |
-| 无推论优先 | ?? |
-| 比较优先级 | ！= > < > = < = === == |
-| 逻辑合取优先 | & & |
-| 逻辑析取优先级 | &#124;&#124; |
-| 默认优先级 | 〜> |
-| 三元优先 | ?: |
-| 功能箭头优先 | ( ) |
-| 分配优先级 | &#124; =％= / = & < < = & > > = & = * = > > = < < = ^ = + = -= |
+| 按位移位优先级 | `& | ^ ~ >> << >>>` |
+| 乘法优先级 | `* % /` |
+| 加法优先级 | `+ - + -` |
+| 范围优先级 | `..< ...` |
+| 转换优先级 | `as` |
+| NIL 推断优先级 | `??` |
+| 比较优先级 | `!= > < >= <= === ==` |
+| 逻辑合取优先级 | `&&` |
+| 逻辑析取优先级 | <code>&#124;&#124;</code> |
+| 默认优先级 | `~>` |
+| 三元优先级 | `?:` |
+| 函数箭头优先级 | `()` |
+| 赋值优先级 | <code>&#124;= %= /= <<=  >>= &= *= >>= <<= ^= += -=</code> |
 
 * * *
 
@@ -51,7 +51,7 @@ print(x)
 
 Execution Steps
 
-| 步骤 | 运算符 | 表达 | 表达式返回的值 |
+| 步骤 | 运算符 | 表达式 | 表达式返回的值 |
 | --- | --- | --- | --- |
 | 1 | `*` | `5 * 5` | **25** |
 | 2 | `+` | `4 + 25` | **29** |
@@ -81,11 +81,11 @@ print(y)
 
 Execution Steps
 
-| 脚步 | 运算符 | 表达 | 表达式返回的值 |
-| 1 | = | var y = 15 | **15** |
-| 2 | * | 2 * 3 | **6** |
-| 3 | - | 10 - 6 | **4** |
-| 4 | += | 15 + 4 | **19** |
+| 步骤 | 运算符 | 表达式 | 表达式返回的值 |
+| 1 | `=` | `var y = 15` | **15** |
+| 2 | `*` | `2 * 3` | **6** |
+| 3 | `-` | `10 - 6` | **4** |
+| 4 | `+=` | `15 + 4` | **19** |
 
 * * *
 
@@ -105,8 +105,8 @@ Swift Standard Library Associativity (Precedence Highest to Lowest)
 
 | Operator Groups | Examples | 关联性 |
 | --- | --- | --- |
-| Bitwise shift precedence | >> &<< &>> >> | 没有 |
-| Multiplication precedence | &* % & * / | 剩下 |
+| Bitwise shift precedence | `>> &<< &>> >>` | 没有 |
+| Multiplication precedence | `* % /` | 剩下 |
 | Addition precedence | &#124; &+ &- + -  ^ | left |
 | Range Formation Precedence | ..< ... | none |
 | Casting Precedence | is as | none |

docs/swift/15.md

@@ -93,7 +93,7 @@ print(invertedNumber)
 
 编译器使用[二进制补码](https://en.wikipedia.org/wiki/Two%27s_complement "Two's complement")表示整数。 要获得整数的二进制补码负号，您应该首先以二进制形式写出数字，然后反转数字，然后在结果中加一个。
 
-**找出-2** 的二进制补码的步骤：
+**找出 -2** 的二进制补码的步骤：
 
 1.  以二进制形式写 2：`00000010`
 2.  反转数字。 0 变成 1，而 1 变成 0：`11111101`
@@ -278,9 +278,9 @@ print(someBits << 1)
 
 在上面的程序中，我们使用了左移运算符。 使用`<<` 1 表示将位向左移动 1。 这些数字向左移动一个位置，右侧的最后一个数字填充零。
 
-您还可以看到丢失的数字**从左侧“移出”** 。 它不会从右侧再次缠绕。 将其向左移动一位将二进制文件中的 1 删除，向右添加 0 以填充移位后的值，其余的其他位则向左移动 1。
+您还可以看到丢失的数字**从左侧“移出”**。 它不会从右侧再次缠绕。 将其向左移动一位将二进制文件中的 1 删除，向右添加 0 以填充移位后的值，其余的其他位则向左移动 1。
 
-这将返回`10001000`，它等效于`UInt8`中的`136`。 因此，`print(someBits << 1)`语句在屏幕上输出 **136** 。
+这将返回`10001000`，它等效于`UInt8`中的`136`。 因此，`print(someBits << 1)`语句在屏幕上输出 **136**。
 
 * * *
 

docs/swift/18.md

@@ -79,9 +79,9 @@ switch dayOfWeek {
 Wednesday
 ```
 
-在上述程序中，`switch`语句通过将`dayOfWeek`值与**情况 1** 匹配来开始。 由于`dayOfWeek`值与第一个案例值 1 不匹配，因此它会降到下一个案例，直到一个匹配。
+在上述程序中，`switch`语句通过将`dayOfWeek`值与`case 1`匹配来开始。 由于`dayOfWeek`值与第一个案例值 1 不匹配，因此它会降到下一个案例，直到一个匹配。
 
-由于**情况 4** 与`switch`表达式匹配，因此执行该案例中的语句`print("Wednesday")`并终止`switch case`。 如果没有大小写匹配，则执行`default`内部的语句。
+由于`case 4`与`switch`表达式匹配，因此执行该案例中的语句`print("Wednesday")`并终止`switch case`。 如果没有大小写匹配，则执行`default`内部的语句。
 
 * * *
 
@@ -126,7 +126,7 @@ Wednesday
 Thursday
 ```
 
-在上述程序中，**情况 4** 执行语句`print("Wednesday")`，`fallthrough`关键字进入`case 5`。 即使大小写与`switch`表达式不匹配，`case 5`中的语句`print("Thursday")`也会执行。 因此，您可以在控制台中看到星期四的输出。
+在上述程序中，`case 4`执行语句`print("Wednesday")`，`fallthrough`关键字进入`case 5`。 即使大小写与`switch`表达式不匹配，`case 5`中的语句`print("Thursday")`也会执行。 因此，您可以在控制台中看到星期四的输出。
 
 * * *
 

docs/swift/19.md

@@ -61,7 +61,7 @@ for <value> in <range> {
 ## 它是如何工作的？
 
 *   被迭代的序列是`<range>`。
-*   `<value>`设置为该范围内的第一个数字，并且执行> 的循环 **<内部的语句。**
+*   `<value>`设置为该范围内的第一个数字，并且执行**循环内部的语句**。
 *   执行该语句后，`<value>`被更新为`<range>`语句包含的第二个值，`<some work here>`再次被执行。
 *   该过程一直持续到到达范围的终点并停止循环。
 
@@ -130,8 +130,8 @@ For-in loop execution steps without range values
 
 | Iteration | 范围返回的值 | Output |
 | --- | --- | --- |
-| 1 | 舍弃 | **世界您好！** |
-| 2 | Discarded | **Hello world!** |
+| 1 | 舍弃 | **`Hello world!`** |
+| 2 | 舍弃 | **`Hello world!`** |
 
 * * *
 
@@ -276,7 +276,7 @@ for (index, language) in programmingLanguages.enumerated() {
 
 ## 如何在`for-in`循环中使用`where`子句过滤元素？
 
-您也可以使用**从中循环过滤内容，其中**子句为
+您也可以使用`for-in`循环和`where`子句过滤内容：
 
 ```swift
 for value in "I♥Swift!" where value != "!" {
@@ -306,13 +306,13 @@ t
 
 Filter using for-in loop execution steps
 
-| Iteration | 值 | 值！=“！” | Output |
+| 迭代 | 值 | `value != "!"` | 输出 |
 | --- | --- | --- | --- |
-| 1 | 一世 | 真正 | I |
-| 2 | **♥** | true | **♥** |
-| 3 | 小号 | true | S |
-| 4 | 在 | true | w |
-| 5 | 一世 | true | i |
-| 6 | F | true | f |
-| 7 | Ť | true | t |
-| 8 | ! | 假 |
\ No newline at end of file
+| 1 | `I` | `true` | `I` |
+| 2 | `♥` | `true` | `♥` |
+| 3 | `S` | `true` | `S` |
+| 4 | `w` | `true` | `w` |
+| 5 | `i` | `true` | `i` |
+| 6 | `f` | `true` | `f` |
+| 7 | `t` | `true` | `t` |
+| 8 | `!` | `false` | |
\ No newline at end of file

docs/swift/22.md

@@ -51,7 +51,7 @@ The end
 
 该循环还包含带有表达式`i == 4`的`if`语句。 当表达式为真（第 4 次迭代）时，将执行`break`语句，并且[`for-in`循环](/swift-programming/for-in-loop)终止。
 
-然后，它跳出循环以打印**末尾**。
+然后，它跳出循环以打印`The end`。
 
 * * *
 
@@ -121,9 +121,9 @@ j = 2
 
 * * *
 
-## 带中断的标记语句
+## 带中断的带标签语句
 
-前缀为（`label: Statement`）形式的语句称为带标签的语句。 标签是一个标识符，您可以稍后在`break`或`continue`语句中引用它。 要了解有关标记语句的更多信息，请访问 *Swift 标记语句*。
+前缀为（`label: Statement`）形式的语句称为带标签的语句。 标签是一个标识符，您可以稍后在`break`或`continue`语句中引用它。 要了解有关带标签语句的更多信息，请访问 *Swift 带标签语句*。
 
 ### 带标签`break`语句如何工作？
 

docs/swift/23.md

@@ -122,7 +122,7 @@ i = 5
 
 ## 带标签`continue`的语句
 
-前缀为（`label:Statement`）形式的语句称为带标签的语句。 标签是一个标识符，您可以稍后在`break`或`continue`语句中引用它。 要了解有关标记语句的更多信息，请访问 *Swift 标记语句*。
+前缀为（`label:Statement`）形式的语句称为带标签的语句。 标签是一个标识符，您可以稍后在`break`或`continue`语句中引用它。 要了解有关带标签语句的更多信息，请访问 *Swift 带标签语句*。
 
 ### 带标签`continue`的语句如何工作？
 

docs/swift/24.md

@@ -55,7 +55,7 @@ print("Condition met")
 Condition met
 ```
 
-在上面的程序中，`guard`包含一个布尔值`true`（满足条件）。 由于`guard`语句仅在不满足条件时运行，因此不会执行`guard`内的语句。 这就是执行`print("Condition met")`并在屏幕上输出**条件满足**的原因。
+在上面的程序中，`guard`包含一个布尔值`true`（满足条件）。 由于`guard`语句仅在不满足条件时运行，因此不会执行`guard`内的语句。 这就是执行`print("Condition met")`并在屏幕上输出`Condition met`的原因。
 
 现在，将条件更改为`false`：
 
@@ -72,7 +72,7 @@ print("Condition met")
 
 在以上程序中，保护条件求值为`false`。 因此，`else`内部的`print("Condition not met")`语句应执行。 但是您会收到一个错误消息，说`guard`主体可能不会退出，请考虑使用`return`或`throw`退出示波器。
 
-简单的错误消息表示，您需要使用`return`，`break`，`continue`或`throw`语句从保护语句转移程序控制。 现在，我们将使用`return`。 并且由于`return`语句只能在函数内部使用，因此我们将上述代码包装在 *Swift Functions* 中。
+简单的错误消息表示，您需要使用`return`，`break`，`continue`或`throw`语句从保护语句转移程序控制。 现在，我们将使用`return`。 并且由于`return`语句只能在函数内部使用，因此我们将上述代码包装在 *Swift 函数*中。
 
 * * *
 
@@ -101,9 +101,9 @@ Condition not met
 Hello after function call 
 ```
 
-在上述程序中，保护条件的计算结果为`false`，因此执行保护内部的语句。 第一个语句`print("Condition not met")`输出**在控制台中不满足**的条件。
+在上述程序中，保护条件的计算结果为`false`，因此执行保护内部的语句。 第一个语句`print("Condition not met")`在控制台输出`Condition not met`。
 
-并且语句`return`终止函数的执行，并且执行函数调用后的语句`print("Hello, after function call")`在控制台中输出`Hello after function call `。
+并且语句`return`终止函数的执行，并且执行函数调用后的语句`print("Hello, after function call")`在控制台中输出`Hello after function call`。
 
 * * *
 

docs/swift/26.md

@@ -48,7 +48,7 @@ let emptyIntArr:Array<Int> = Array()
 print(emptyIntArr) 
 ```
 
-**OR**
+**或**
 
 由于 swift 是一种类型推断语言，因此您也可以直接创建数组而无需指定数据类型，但是必须使用一些值进行初始化，以便编译器可以将其类型推断为：
 
@@ -84,7 +84,7 @@ print(arrWithRepeatingValues)
 ["Hello, World", "Hello, World", "Hello, World", "Hello, World"]
 ```
 
-在上面的程序中，我们定义了一个常量`arrWithRepeatingValues`，该常量存储字符串`"Hello, World"`**的数组** ，并将相同的值重复 4 次，如`count`中指定的那样 ]。
+在上面的程序中，我们定义了一个常量`arrWithRepeatingValues`，该常量存储字符串`"Hello, World"`的**数组** ，并将相同的值重复 4 次，如`count`中指定的那样 ]。
 
 **注意**：在 Swift 中，不能像在其他编程语言中一样创建固定长度大小的数组。 固定长度大小的数组意味着，数组中的元素不能超过初始化期间定义的元素。
 

docs/swift/28.md

@@ -46,7 +46,7 @@ print(emptyDic)
 
 在上面的程序中，我们用类型为`Int`的键和类型为`String`的值声明了类型字典的常量`emptyDic`，并使用 0 值对其进行了初始化。
 
-**OR**
+**或**
 
 由于 Swift 是一种类型推断语言，因此您也可以不指定数据类型而直接创建字典，但是必须使用一些值进行初始化，以便编译器可以将其类型推断为：
 
@@ -281,7 +281,7 @@ Optional("Kathmandu")
 ["India": "NewDelhi", "China": "Beijing"] 
 ```
 
-同样，您也可以使用 **removeAll** 函数清空字典。
+同样，您也可以使用`removeAll`函数清空字典。
 
 * * *
 
@@ -303,7 +303,7 @@ print(val)
 nil
 ```
 
-在上述程序中，没有键**日本**。 因此，当您尝试访问键“日本”的值时，将获得`nil`值。
+在上述程序中，没有键`Japan`。 因此，当您尝试访问键“日本”的值时，将获得`nil`值。
 
 **2\.** 同样，键值在 Swift 中区分大小写，因此您必须确保使用正确的大小写键/值。 否则，您将获得`nil`值。 让我们在示例中看一下：
 
@@ -321,7 +321,7 @@ print(val)
 nil
 ```
 
-在以上程序中，没有**尼泊尔语**。 因此，当您尝试访问键“尼泊尔”的值时，您将获得`nil`值。
+在以上程序中，没有`nepal`。 因此，当您尝试访问键“尼泊尔”的值时，您将获得`nil`值。
 
 **3\.** 如果给定键的值不存在，则还有一种方法可以提供默认值。 让我们在示例中看一下：
 

docs/swift/3.md

@@ -4,7 +4,7 @@
 
 #### 在本文中，您将通过编写 HelloWorld 来深入研究 Swift 编程。 程序。 您将学习工作的 Swift 程序的基本语法。
 
-“你好，世界！” 是一种计算机程序，通常用于说明具有工作程序的编程语言的基本语法。 该程序输出世界，您好！ 屏幕上。
+HelloWorld 是一种计算机程序，通常用于说明具有工作程序的编程语言的基本语法。 该程序输出世界，您好！ 屏幕上。
 
 如果要在计算机上运行此程序，请确保正确安装了 Swift 和 Xcode。 为此，请检查*如何在计算机上运行 Swift？*
 
@@ -28,7 +28,7 @@ print("Hello, World!")
 Hello, World!
 ```
 
-## 斯威夫特：“你好，世界！” 程序有效吗？
+## 斯威夫特：HelloWorld 程序有效吗？
 
 1.  `// Hello, World! Program`
 
@@ -46,7 +46,7 @@ Hello, World!
 
 * * *
 
-## “你好，世界！” 终端程序
+## HelloWorld 终端程序
 
 1.  开放终端
 2.  输入`swift`，然后按`Enter`（返回）。 这将给您一个欢迎消息，如**欢迎使用 Apple Swift 版本 x.x.x**。

docs/swift/30.md

@@ -71,7 +71,7 @@ func function_name(args...) -> ReturnType {
 *   `->`该运算符用于指示函数的返回类型。
 *   `ReturnType`定义可以从函数返回的值的类型。 例如。`Int`，`String`等
 *   `return`关键字用于将程序的控制权转移到函数调用，并从函数返回值。
-    即使您未指定 **return** 关键字，该函数也会在执行完最后一条语句后自动返回。
+    即使您未指定`return`关键字，该函数也会在执行完最后一条语句后自动返回。
 *   `value`表示从函数返回的实际数据。 值类型必须与`ReturnType`匹配。
 
 * * *
@@ -108,7 +108,7 @@ func greet(user:String) {
 
 ## 调用函数
 
-创建函数后，可以在程序中调用它以执行函数内部声明的语句。 要调用一个函数，您只需编写函数名称，后接**（）**，然后将输入参数传递为：
+创建函数后，可以在程序中调用它以执行函数内部声明的语句。 要调用一个函数，您只需编写函数名称，后接`()`，然后将输入参数传递为：
 
 ```swift
 greet(user: "Isac")

docs/swift/31.md

@@ -78,7 +78,7 @@ Good Morning!
 
 `return "Good Morning!"`语句从该函数返回`String`类型的值。 请注意，返回类型和值必须匹配。
 
-您还可以将返回值分配给变量或常量。`let msg =`将返回值分配给常数`msg`。 因此，语句`print(msg)`输出**早上好！ 控制台中的**。
+您还可以将返回值分配给变量或常量。`let msg =`将返回值分配给常数`msg`。 因此，语句`print(msg)`输出`"Good Morning!"`。
 
 如果您想忽略该值，则可以简单地将`_`用作`let _ =`。
 
@@ -113,7 +113,7 @@ Good Morning!
 
 您可以通过向函数传递参数名称为`greetUser(msg: "Good Morning!")`的字符串值来调用该函数。`msg`参数名称仅在函数`greetUser()`内部可见。
 
-因此，语句`print(msg)`输出**早上好！ 控制台中的**。
+因此，语句`print(msg)`输出`"Good Morning!"`。
 
 * * *
 

docs/swift/33.md

@@ -50,7 +50,7 @@ Countdown:
 0
 ```
 
-在上述程序中，语句`print("Countdown:")`在控制台中输出 **Countdown**：。 语句`countDownToZero(num:3)`调用带有参数`Integer`的函数。
+在上述程序中，语句`print("Countdown:")`在控制台中输出`Countdown`。 语句`countDownToZero(num:3)`调用带有参数`Integer`的函数。
 
 执行函数`countDownToZero()`内的语句，如果满足条件`num > 0`，则再次调用函数`countDownToZero()`作为`countDownToZero(num: num - 1)`。
 
@@ -63,9 +63,9 @@ Execution steps
 | 步骤 | 函数调用 | 打印 | `num > 0`？ |
 | --- | --- | --- | --- |
 | 1 | `countDownToZero(3)` | **3** | 是 |
-| 2 | `countDownToZero(2)` | **2** | Yes |
-| 3 | `countDownToZero(1)` | **1** | Yes |
-| 4 | `countDownToZero(0)` | **0** | 否（完） |
+| 2 | `countDownToZero(2)` | **2** | 是 |
+| 3 | `countDownToZero(1)` | **1** | 是 |
+| 4 | `countDownToZero(0)` | **0** | 否（结束） |
 
 * * *
 

docs/swift/37.md

@@ -87,7 +87,7 @@ Hello, World!
 
 在上述程序中，闭包的类型`(String) -> ()`声明闭包接受的类型为`String`，但不返回值。您可以通过在闭包的语句中放置参数`name`，后跟`in`关键字来使用传递的值。
 
-请记住，`in`关键字的使用是将参数名称与语句分开。 由于闭包接受`String`，因此在将闭包称为`simpleClosure("Hello, World")`时需要传递字符串。 这将在闭包内部执行语句并输出**世界，您好！ 控制台中的**。
+请记住，`in`关键字的使用是将参数名称与语句分开。 由于闭包接受`String`，因此在将闭包称为`simpleClosure("Hello, World")`时需要传递字符串。 这将在闭包内部执行语句并输出`"Hello, World"`。
 
 * * *
 
@@ -143,7 +143,7 @@ Function Called
 
 现在，当调用函数`someSimpleFunction()`时，您可以将闭包`{ print("Hello World! from closure") }`作为参数传递。
 
-函数调用触发函数内部的`print("Function Called")`语句，该语句在屏幕上输出**被调用的**函数。 但是，由于尚未调用闭包，因此不会执行闭包语句。
+函数调用触发函数内部的`print("Function Called")`语句，该语句在屏幕上输出`Function Called`。 但是，由于尚未调用闭包，因此不会执行闭包语句。
 
 您可以简单地以`someClosure()`的形式调用闭包，它在闭包内执行语句。
 
@@ -303,7 +303,7 @@ Good Morning
 
 在上面的程序中，我们定义了一个不带参数但返回`String`（`()->(String)`）的函数。 我们将自动关闭功能**“早上好”** 传递给了该功能。 这也是闭包的返回值。
 
-因此，当我们在函数内部调用`someClosure()`时，它返回了**早安**值。
+因此，当我们在函数内部调用`someClosure()`时，它返回了`Good Morning`值。
 
 ### 示例 9：带参数的自动闭包
 
@@ -496,12 +496,12 @@ print("Other statements")
 执行步骤如下：
 
 1.  `doSomeWork()`调用在函数内部执行语句的函数
-2.  `print("function called")`在控制台中输出称为的**功能。**
+2.  `print("function called")`在控制台中输出`"function called"`。
 3.  您可以在函数内部执行一些工作。 目前，仅`print("some work here")`语句在控制台中的输出为**。**
 4.  对闭包的简单调用为`completion()`，它将发送回调并将程序的控制权转移到闭包内的语句。
-    因此，执行`print("call back received")`，在控制台中输出接收到的**回调**。
-5.  之后，程序控制再次返回到关闭调用，并执行语句`print("after calling callback")`，该语句在控制台中调用回调后输出**。**
-6.  函数内部的语句执行后，程序将控制权转移到函数调用`doSomeWork()`，然后执行下一个语句`print("Other statements")`，该语句在控制台中输出**其他语句**。
+    因此，执行`print("call back received")`，在控制台中输出`"call back received"`。
+5.  之后，程序控制再次返回到关闭调用，并执行语句`print("after calling callback")`，该语句在控制台中输出`"after calling callback"`。
+6.  函数内部的语句执行后，程序将控制权转移到函数调用`doSomeWork()`，然后执行下一个语句`print("Other statements")`，该语句在控制台中输出`"Other statements"`。
 
 让我们来看一个更实际的示例，将闭包用作完成处理器。
 

docs/swift/4.md

@@ -110,7 +110,7 @@ Programiz.com
 
 在 Swift 中，我们使用`let`关键字声明一个变量。
 
-**Example:**
+**示例**：
 
 ```swift
 let siteName:String
@@ -125,7 +125,7 @@ print(siteName)
 
 ### 如何在 Swift 中为常量分配值？
 
-您可以使用赋值运算符（=）在与变量相同的**常量**中分配值。
+您可以使用赋值运算符（`=`）在与变量相同的**常量**中分配值。
 
 #### 示例 4：声明并将值分配给常量
 
@@ -232,9 +232,9 @@ print(1231)
 1231
 ```
 
-在上面的程序中，有两个整数字面值`0b11111111`（二进制字面值）和`1231`（十进制字面值）。`11111111`的十进制值为 **255** ，因此`print(binaryNumber)`语句在屏幕上输出 255。
+在上面的程序中，有两个整数字面值`0b11111111`（二进制字面值）和`1231`（十进制字面值）。`11111111`的十进制值为 **255**，因此`print(binaryNumber)`语句在屏幕上输出 255。
 
-同样，`print(1231)`在控制台中输出十进制值 **255** 。
+同样，`print(1231)`在控制台中输出十进制值 **255**。
 
 * * *
 

docs/swift/5.md

@@ -29,7 +29,7 @@ var playerName:String = "Jack"
 var highScore:Int = "Jack"
 ```
 
-您将得到一个编译时错误，指出 ***无法将类型'String'的值转换为指定的类型'Int'*** 。
+您将得到一个编译时错误，指出**无法将类型`String`的值转换为指定的类型`Int`**。
 
 这是因为您声明了`highScore`存储整数值，但在其中放置了字符串。 此错误可确保`highScore`仅能存储数字，而不能存储玩家的姓名。
 
@@ -39,7 +39,7 @@ var highScore:Int = "Jack"
 
 数据类型的另一个重要部分是其大小。 这指定了可以存储在给定变量或常量中的数据大小。
 
-**类型的**大小以位为单位进行测量，最多可以存储`2^bit`的值。 如果您不了解`bit`，请将其视为 0 或 1 的值。
+**类型**的大小以位为单位进行测量，最多可以存储`2^bit`的值。 如果您不了解`bit`，请将其视为 0 或 1 的值。
 
 因此，对于大小为 1 位的**类型**，它最多只能存储`2^1 = 2`，两个值：0 或 1。所以 1 字母程序的位系统可以将 0 解释为`a / 0`，将 1 解释为`b / 1.0`。
 
@@ -247,7 +247,7 @@ J
 
 *   声明为`String`类型的变量或常量可以存储字符集合。
 *   **默认值**：`""`（空字符串）
-*   它是值类型。 请参见*快速值和引用类型*。
+*   它是值类型。 请参见*值和引用类型简介*。
 *   您可以使用`for-in`循环遍历字符串。 *参见* [Swift `for-in`循环](/swift-programming/for-in-loop "Swift for-in loop")。
 *   Swift 还支持一些特殊的转义序列以在字符串中使用它们。 例如，
     *   `\0`（空字符），
@@ -281,7 +281,7 @@ Jack
 
 请参阅 [Swift 字符和字符串](/swift-programming/characters-strings "Swift characters and strings")，以了解有关字符和字符串的声明，操作和示例的更多信息。
 
-除此数据类型外，Swift 中还有其他高级数据类型，例如**元组**，**可选**，**范围**，**类**，**结构**等，您将在后面的章节中学习。
+除此数据类型外，Swift 中还有其他高级数据类型，例如**元组**，**可选项**，**范围**，**类**，**结构**等，您将在后面的章节中学习。
 
 * * *
 
@@ -289,7 +289,7 @@ Jack
 
 1.由于 Swift 是一种类型推断语言，因此变量或常量可以根据存储的值自动推断类型。 因此，您可以在创建变量或常量时跳过类型。 但是，出于可读性考虑，您可以考虑编写该类型，但不建议这样做。
 
-**示例 9：类型推断的变量/常量**
+**示例 9：变量/常量的类型推断**
 
 ```swift
 let playerName = "Jack"

docs/swift/6.md

@@ -105,7 +105,7 @@ var someValue:Int!
 var unwrappedValue:Int = someValue //crashes due to this line 
 ```
 
-当您运行该程序时，您会因**致命错误而崩溃：在解开可选项**时意外发现`nil`，因为代码`unwrappedValue:Int = someValue`试图将可选`someValue`中的值赋给变量`unwrappedValue`。
+当您运行该程序时，您会因**致命错误**而崩溃：在解开可选项时意外发现`nil`，因为代码`unwrappedValue:Int = someValue`试图将可选`someValue`中的值赋给变量`unwrappedValue`。
 
 但是，`somevalue`是包含`nil`值的`Optional`类型。 尝试将`nil`值分配给变量`unwrappedValue`（这不是可选的）会导致崩溃。
 
@@ -117,7 +117,7 @@ var unwrappedValue:Int = someValue //crashes due to this line
 
 为了使用可选项，需要将其解包。 使用可选项的更好方法是通过条件展开而不是使用`!`运算符强制展开。
 
-这是因为有条件的展开询问**检查此变量是否具有值？** 。 如果是，请提供该值，否则将处理`nil`情况。
+这是因为有条件的展开询问**检查此变量是否具有值？**。 如果是，请提供该值，否则将处理`nil`情况。
 
 相反，强制展开表示**该变量在使用时确实有一个值**。 因此，当您强制解开一个`nil`的变量时，您的程序将在解开可选异常并抛出的同时抛出**意外发现的`nil`**。 下面说明了一些用于条件展开的技术：
 

docs/swift/8.md

@@ -32,7 +32,7 @@ Hello, World!
 I love Swift. 
 ```
 
-在上述程序中，`print("Hello, World!")`输出字符串文字**您好，世界！ 控制台中的**。
+在上述程序中，`print("Hello, World!")`输出字符串字面值`"Hello, World!"`。
 
 您可以看到，在打印`"I love Swift."`时，它还会更改行（添加换行符）。因为打印方法的参数`terminator`具有默认值`\n`（新行）。
 
@@ -40,7 +40,7 @@ I love Swift.
 
 * * *
 
-### 示例 2：打印常量，变量和文字
+### 示例 2：打印常量，变量和字面值
 
 ```swift
 var helloMsg = "Hello, World!"
@@ -57,13 +57,13 @@ Hello, World!
 
 您可以通过直接在打印功能中添加变量或常量名称来打印变量或常量的值。 在上面的程序中`print(helloMsg)`输出变量`helloMsg`的值`Hello, World!`。
 
-您也可以在`print`语句中插入文字。 在语句`print(123.45)`中，它采用不带双引号的浮点文字`123.45`并将其打印出来。
+您也可以在`print`语句中插入字面值。 在语句`print(123.45)`中，它采用不带双引号的浮点字面值`123.45`并将其打印出来。
 
 * * *
 
 ### 示例 3：使用终止符参数进行打印而没有链接中断
 
-如果要打印而没有换行符，则需要在**打印**函数的终止符参数中传递一个空字符串，如下所示：
+如果要打印而没有换行符，则需要在`print`函数的终止符参数中传递一个空字符串，如下所示：
 
 ```swift
 print("Hello, World!", terminator: "")
@@ -127,7 +127,7 @@ World!
 
 ### 示例 6：使用三重引号打印多行
 
-在 Swift 中，有一种更好的方法可以在单个`print`语句中输出多行消息。 您必须使用多行字符串文字。 这是通过在多行字符串文字中使用三引号将字符添加为
+在 Swift 中，有一种更好的方法可以在单个`print`语句中输出多行消息。 您必须使用多行字符串字面值。 这是通过在多行字符串字面值中使用三引号将字符添加为
 
 ```swift
 print("""
@@ -147,7 +147,7 @@ World!
 
 ### 示例 7：使用字符串插值打印变量
 
-您还可以通过使用字符串插值将变量或常量的值添加到字符串文字中，即，将变量包装在以反斜杠`(\)`为前缀的一对括号中。
+您还可以通过使用字符串插值将变量或常量的值添加到字符串字面值中，即，将变量包装在以反斜杠`(\)`为前缀的一对括号中。
 
 ```swift
 var helloMsg = "Hello, World!"
@@ -160,7 +160,7 @@ print("I have a message \(helloMsg)")
 I have a message Hello, World!
 ```
 
-语句`print("I have a message \(helloMsg)")`将变量`helloMsg`的值包装为字符串文字中的`\(helloMsg)`，从而插入该值。 因此，该语句输出`I have a message Hello, World!`。
+语句`print("I have a message \(helloMsg)")`将变量`helloMsg`的值包装为字符串字面值中的`\(helloMsg)`，从而插入该值。 因此，该语句输出`I have a message Hello, World!`。
 
 * * *
 
@@ -168,7 +168,7 @@ I have a message Hello, World!
 
 如果要在 Swift 中从用户那里获取输入，则必须在不使用 UIKit 框架的情况下才能在 Xcode 游乐场上进行输入。
 
-但是，使用 Swift 框架，您可以在 Xcode 中创建一个命令行应用程序，以从用户那里获取输入。 您可以参阅 *Swift 命令行应用程序*文章，以使用 Xcode 创建命令行应用程序。
+但是，使用 Swift 框架，您可以在 Xcode 中创建一个命令行应用，以从用户那里获取输入。 您可以参阅 *Swift 命令行应用*文章，以使用 Xcode 创建命令行应用。
 
 这是您可以用来获取用户输入的代码。
 
@@ -188,7 +188,7 @@ Swift
 Your favorite programming language is Swift. 
 ```
 
-在上述程序中，打印功能输出**。请输入您喜欢的编程语言。 调试区域中的**。 语句`let name = readLine()`在调试区域中等待用户输入。
+在上述程序中，`print`函数输出`Please Enter your favorite programming language.`。 语句`let name = readLine()`在调试区域中等待用户输入。
 
 如果键入“`Swift`”并按`Enter`，则`readLine`函数将该字符串分配给常量`name`，并将输出显示为`Your favorite programming language is Swift. `。
 

docs/swift/9.md

@@ -89,7 +89,7 @@ let someValue:Int = 12
 
 这些类型的语句使程序可以更改编译器行为的各个方面。 Swift 有以下两个编译器控制语句：
 
-*   **Conditional compilation block**
+*   **条件编译块**
 
     A conditional compilation block allows code to be only compiled depending on the value of one or more compilation conditions. Every conditional compilation block begins with the `#if` and ends with `#endif`. A simple conditional compilation block has the following form:
 
@@ -123,8 +123,8 @@ let someValue:Int = 12
 该语句用于控制程序中的执行流程。 Swift 中有几种类型的控制流语句。
 
 1.  **循环语句**：此语句允许重复执行代码块。 例如：`for-in`，`while`，重复`while`等。
-2.  **分支语句**：此语句仅在满足某些条件时才允许执行特定代码块。 例如：如果不是，请设置防护装置，`switch`等。
-3.  **控制传递语句**：此语句允许更改代码执行顺序的方法。 例如：中断，继续，失败，抛出，返回等。
+2.  **分支语句**：此语句仅在满足某些条件时才允许执行特定代码块。 例如：`if-else`，`guard`，`switch`等。
+3.  **控制传递语句**：此语句允许更改代码执行顺序的方法。 例如：`break`，`continue`，`fail`，`throw`，`return`等。
 
 * * *