From d32e5e62964f51311ee1b418f2d89587c37f9594 Mon Sep 17 00:00:00 2001
From: wizardforcel <562826179@qq.com>
Date: Thu, 9 Jul 2020 23:44:45 +0800
Subject: [PATCH] 2020-07-09 23:44:45

---
 docs/swift/10.md |  4 ++--
 docs/swift/11.md |  2 +-
 docs/swift/12.md |  4 ++--
 docs/swift/13.md |  8 +++----
 docs/swift/14.md |  2 +-
 docs/swift/16.md |  2 +-
 docs/swift/17.md |  6 +++---
 docs/swift/18.md |  4 ++--
 docs/swift/19.md |  6 +++---
 docs/swift/2.md  |  2 +-
 docs/swift/20.md |  4 ++--
 docs/swift/21.md |  8 +++----
 docs/swift/22.md |  8 +++----
 docs/swift/23.md |  6 +++---
 docs/swift/24.md | 22 +++++++++----------
 docs/swift/25.md |  2 +-
 docs/swift/26.md | 24 ++++++++++-----------
 docs/swift/27.md | 50 +++++++++++++++++++++---------------------
 docs/swift/28.md | 24 ++++++++++-----------
 docs/swift/29.md |  2 +-
 docs/swift/3.md  |  2 +-
 docs/swift/30.md |  2 +-
 docs/swift/31.md | 14 ++++++------
 docs/swift/33.md |  2 +-
 docs/swift/34.md | 12 +++++------
 docs/swift/35.md |  2 +-
 docs/swift/36.md |  2 +-
 docs/swift/37.md | 56 ++++++++++++++++++++++++------------------------
 docs/swift/4.md  | 16 +++++++-------
 docs/swift/5.md  | 28 ++++++++++++------------
 docs/swift/6.md  |  6 +++---
 docs/swift/7.md  | 14 ++++++------
 docs/swift/8.md  |  6 +++---
 docs/swift/9.md  |  2 +-
 34 files changed, 177 insertions(+), 177 deletions(-)

diff --git a/docs/swift/10.md b/docs/swift/10.md
index c7b820f..d712d6a 100644
--- a/docs/swift/10.md
+++ b/docs/swift/10.md
@@ -1,4 +1,4 @@
-# 迅捷注释
+# Swift 注释
 
 > 原文： [https://www.programiz.com/swift-programming/comments](https://www.programiz.com/swift-programming/comments)
 
@@ -10,7 +10,7 @@
 
 * * *
 
-## 快速注释及其类型
+## 注释及其类型
 
 快速有两种类型的注释：
 
diff --git a/docs/swift/11.md b/docs/swift/11.md
index 38a999f..14cdb3e 100644
--- a/docs/swift/11.md
+++ b/docs/swift/11.md
@@ -1 +1 @@
-# 迅捷运算符
\ No newline at end of file
+# Swift 运算符
\ No newline at end of file
diff --git a/docs/swift/12.md b/docs/swift/12.md
index d665b62..69d8c04 100644
--- a/docs/swift/12.md
+++ b/docs/swift/12.md
@@ -1,4 +1,4 @@
-# 迅捷运算符
+# Swift 运算符
 
 > 原文： [https://www.programiz.com/swift-programming/operators](https://www.programiz.com/swift-programming/operators)
 
@@ -42,7 +42,7 @@ false
 
 * * *
 
-## 2.二进制运算符
+## 2.二元运算符
 
 该运算符对两个操作数进行运算。
 
diff --git a/docs/swift/13.md b/docs/swift/13.md
index bb98a29..c436ab2 100644
--- a/docs/swift/13.md
+++ b/docs/swift/13.md
@@ -59,7 +59,7 @@ Execution Steps
 
 * * *
 
-### 示例 2：具有复杂赋值运算符的 Swift 运算符优先级
+### 示例 2：带有复杂赋值运算符的 Swift 运算符优先级
 
 ```swift
 var y = 15
@@ -89,7 +89,7 @@ Execution Steps
 
 * * *
 
-## Swift 运算符关联
+## Swift 运算符关联性
 
 尽管存在由运算符优先级定义的预定义规则来求值表达式，但是您可能想知道如果存在多个相同优先级的运算符会发生什么。 运算符关联性定义了如何将具有相同优先级的运算符组合在一起。
 
@@ -97,7 +97,7 @@ Execution Steps
 
 * * *
 
-### 运算符关联表
+### 运算符关联性表
 
 下表显示了 Swift 运算符的关联性及其优先级。
 
@@ -121,7 +121,7 @@ Swift Standard Library Associativity (Precedence Highest to Lowest)
 
 * * *
 
-### 示例 3：Swift 运算符关联
+### 示例 3：Swift 运算符关联性
 
 ```swift
 let x =  40  / 2 * 10
diff --git a/docs/swift/14.md b/docs/swift/14.md
index f626cfb..2c9a4f3 100644
--- a/docs/swift/14.md
+++ b/docs/swift/14.md
@@ -77,7 +77,7 @@ The condition is false
 
 但是，这可能不是一个好主意。
 
-### 示例 2：如果使用其他三元条件运算符则嵌套
+### 示例 2：使用三元条件运算符替代`if-else`嵌套
 
 ```swift
 if true && false {
diff --git a/docs/swift/16.md b/docs/swift/16.md
index 473eaa5..c426353 100644
--- a/docs/swift/16.md
+++ b/docs/swift/16.md
@@ -1 +1 @@
-# 快速流量控制
\ No newline at end of file
+# Seift 流程控制
\ No newline at end of file
diff --git a/docs/swift/17.md b/docs/swift/17.md
index f7ced43..7824fa6 100644
--- a/docs/swift/17.md
+++ b/docs/swift/17.md
@@ -8,7 +8,7 @@
 
 * * *
 
-## Swift `if`（`if-then`）语句
+## Swift `if`语句
 
 Swift 中`if`语句的语法为：
 
@@ -59,7 +59,7 @@ This statement is always executed.
 
 * * *
 
-## Swift `if..else`（`if-else`）语句
+## Swift `if..else`语句
 
 如果测试表达式的值为`true`，则`if`语句执行代码的特定部分。 `if`语句可以具有可选的`else`语句。 如果测试表达式为假，则将执行`else`语句主体内的代码。
 
@@ -117,7 +117,7 @@ This statement is always executed.
 
 * * *
 
-## Swift `if..else..if`（`if-else-if`）语句
+## Swift `if..else..if`语句
 
 在 Swift 中，还可以在许多代码中执行一个代码块。 为此，可以将`if..else..if`阶梯用作：
 
diff --git a/docs/swift/18.md b/docs/swift/18.md
index 2960b76..db2b1a3 100644
--- a/docs/swift/18.md
+++ b/docs/swift/18.md
@@ -1,4 +1,4 @@
-# `switch`声明
+# `switch`语句
 
 > 原文： [https://www.programiz.com/swift-programming/switch-statement](https://www.programiz.com/swift-programming/switch-statement)
 
@@ -41,7 +41,7 @@ default:
 
 * * *
 
-### 示例 1：使用 Switch 语句的简单程序
+### 示例 1：使用`Switch`语句的简单程序
 
 ```swift
 let dayOfWeek = 4
diff --git a/docs/swift/19.md b/docs/swift/19.md
index fe79542..351de7b 100644
--- a/docs/swift/19.md
+++ b/docs/swift/19.md
@@ -10,7 +10,7 @@
 
 * * *
 
-## 为什么需要循环循环？
+## 为什么需要`for in`循环？
 
 想象有人告诉您编写一个输出`"Hello, World!"`的程序！ 在屏幕上。 您的解决方案将是：
 
@@ -43,7 +43,7 @@ for i in 1...100 {
 
 * * *
 
-## 循环内语法
+## `for in`循环语法
 
 您可以在 Swift 中创建一个`for in`循环，如下所示：
 
@@ -137,7 +137,7 @@ For-in loop execution steps without range values
 
 ## `for-in`循环，使用步幅固定的间隔
 
-如果要使循环在每次迭代中以某个固定值（而不是范围）递增，则必须使用[跨步](https://developer.apple.com/documentation/swift/1641347-stride)方法。
+如果要使循环在每次迭代中以某个固定值（而不是范围）递增，则必须使用[`stride`](https://developer.apple.com/documentation/swift/1641347-stride)方法。
 
 ### 示例 3：使用步幅的`for-in`循环
 
diff --git a/docs/swift/2.md b/docs/swift/2.md
index d2343fd..caf3b65 100644
--- a/docs/swift/2.md
+++ b/docs/swift/2.md
@@ -1 +1 @@
-# 迅捷介绍
\ No newline at end of file
+# Swift 介绍
\ No newline at end of file
diff --git a/docs/swift/20.md b/docs/swift/20.md
index 39dd7bb..12afaff 100644
--- a/docs/swift/20.md
+++ b/docs/swift/20.md
@@ -1,8 +1,8 @@
-# 快速的`while`并重复`while`循环
+# Swift `while`和`repeat...while`循环
 
 > 原文： [https://www.programiz.com/swift-programming/repeat-while-loop](https://www.programiz.com/swift-programming/repeat-while-loop)
 
-#### 在本文中，您将学习在 Swift 编程中创建`while`并`repeat..while`循环。
+#### 在本文中，您将学习在 Swift 编程中创建`while`和`repeat..while`循环。
 
 在上一篇文章中，我们了解了[`for-in`循环](/swift-programming/for-in-loop "Swift for-in loop")，用于在一定次数下运行一组任务。 在本文中，您将学习在未知迭代次数时使用`while`和`repeat..while`作为`for-in`循环的替代方法。
 
diff --git a/docs/swift/21.md b/docs/swift/21.md
index 851b59c..d6e242b 100644
--- a/docs/swift/21.md
+++ b/docs/swift/21.md
@@ -97,11 +97,11 @@ while i <= 5 {
 
 * * *
 
-## Swift 嵌套重复循环
+## Swift 嵌套`repeat-while`循环
 
-嵌套的[`repeat-while`循环](/swift-programming/repeat-while-loop#repeat-while "Swift repeat-while loop")包含一个`while`重复循环，作为另一个`repeat-while`循环中的语句。 您可以根据需要具有任意数量的嵌套`while`循环。
+嵌套的[`repeat-while`循环](/swift-programming/repeat-while-loop#repeat-while "Swift repeat-while loop")包含一个`repeat-while`循环，作为另一个`repeat-while`循环中的语句。 您可以根据需要具有任意数量的嵌套`while`循环。
 
-### 示例 3：Swift 嵌套重复循环
+### 示例 3：Swift 嵌套`repeat-while`循环
 
 ```swift
 var i = 1
@@ -125,7 +125,7 @@ The output of the program is same as the above program.
 
 不必具有相同类型的嵌套循环。 您还可以通过将一种类型的循环放入其他类型的循环中来创建嵌套循环的变体。
 
-### 示例 3：`while`和`for`的 Swift 嵌套循环
+### 示例 3：Swift `while`和`for`的嵌套循环
 
 下面的程序包含不同类型的嵌套循环（`while`和`for-in`循环）。
 
diff --git a/docs/swift/22.md b/docs/swift/22.md
index 34bfe93..8ed59d3 100644
--- a/docs/swift/22.md
+++ b/docs/swift/22.md
@@ -24,7 +24,7 @@ break
 
 * * *
 
-## 示例 1：`for`循环中的 Swift `break`语句
+## 示例 1：Swift `for`循环中的`break`语句
 
 ```swift
 for i in 1...5 {
@@ -55,7 +55,7 @@ The end
 
 * * *
 
-## 示例 2：`while`循环中的 Swift `break`语句
+## 示例 2：Swift `while`循环中的`break`语句
 
 ```swift
 var currentLevel:Int = 1, finalLevel:Int = 2
@@ -88,7 +88,7 @@ outside of while loop
 
 * * *
 
-## 示例 3：带嵌套循环的 Swift `break`语句
+## 示例 3：Swift 嵌套循环的`break`语句
 
 ```swift
 for j in 1...2 {
@@ -121,7 +121,7 @@ j = 2
 
 * * *
 
-## 带中断的带标签语句
+## 带标签的`break`语句
 
 前缀为（`label: Statement`）形式的语句称为带标签的语句。 标签是一个标识符，您可以稍后在`break`或`continue`语句中引用它。 要了解有关带标签语句的更多信息，请访问 *Swift 带标签语句*。
 
diff --git a/docs/swift/23.md b/docs/swift/23.md
index 1f58c9c..ee7d3b2 100644
--- a/docs/swift/23.md
+++ b/docs/swift/23.md
@@ -24,7 +24,7 @@ continue
 
 * * *
 
-## 示例 1：`for`循环中的 Swift `continue`语句
+## 示例 1：Swift `for`循环中的`continue`语句
 
 ```swift
 for i in 1...5 {
@@ -52,7 +52,7 @@ i = 5
 
 * * *
 
-## 示例 2：`while`循环中的 Swift `Continue`语句
+## 示例 2：Swift `while`循环中的`Continue`语句
 
 ```swift
 var intialLevel:Int = -5, finalLevel:Int = 2
@@ -86,7 +86,7 @@ outside of while loop
 
 * * *
 
-## 示例 3：带嵌套循环的 Swift `continue`语句
+## 示例 3：Swift 嵌套循环的`continue`语句
 
 ```swift
 for j in 1...2 {
diff --git a/docs/swift/24.md b/docs/swift/24.md
index 7237930..da4dd0e 100644
--- a/docs/swift/24.md
+++ b/docs/swift/24.md
@@ -10,11 +10,11 @@
 
 `Guard`语句的主要用途是在某些条件下将程序控制权移出范围。 这些语句与`if`语句类似，后者根据特定条件（布尔值）执行语句，但与`if`不同，`guard`语句仅在不满足特定条件时运行。
 
-而且，保护内部的语句必须退出范围。 因此，我们必须在保护语句的末尾使用用户程序控制语句`return`，`break`，`continue`或`throw`。
+而且，`guard`内部的语句必须退出范围。 因此，我们必须在`guard`语句的末尾使用用户程序控制语句`return`，`break`，`continue`或`throw`。
 
 * * *
 
-## 保护声明的语法
+## `guard`语句的语法
 
 ```swift
 guard expression else {
@@ -30,11 +30,11 @@ guard expression else {
 
 * * *
 
-## 保护声明如何工作？
+## `guard`语句如何工作？
 
 ![How Swift guard statement works?](img/cfd206b9615924061b14dcdb80487cd1.png "Swift guard statement")
 
-注意：保护语句的末尾必须包含控制语句`return`，`break`，`continue`或`throw`。
+注意：`guard`语句的末尾必须包含控制语句`return`，`break`，`continue`或`throw`。
 
 * * *
 
@@ -70,9 +70,9 @@ guard false else {
 print("Condition met") 
 ```
 
-在以上程序中，保护条件求值为`false`。 因此，`else`内部的`print("Condition not met")`语句应执行。 但是您会收到一个错误消息，说`guard`主体可能不会退出，请考虑使用`return`或`throw`退出示波器。
+在以上程序中，`guard`条件求值为`false`。 因此，`else`内部的`print("Condition not met")`语句应执行。 但是您会收到一个错误消息，说`guard`主体可能不会退出，请考虑使用`return`或`throw`退出示波器。
 
-简单的错误消息表示，您需要使用`return`，`break`，`continue`或`throw`语句从保护语句转移程序控制。 现在，我们将使用`return`。 并且由于`return`语句只能在函数内部使用，因此我们将上述代码包装在 *Swift 函数*中。
+简单的错误消息表示，您需要使用`return`，`break`，`continue`或`throw`语句从`guard`语句转移程序控制。 现在，我们将使用`return`。 并且由于`return`语句只能在函数内部使用，因此我们将上述代码包装在 *Swift 函数*中。
 
 * * *
 
@@ -101,15 +101,15 @@ Condition not met
 Hello after function call 
 ```
 
-在上述程序中，保护条件的计算结果为`false`，因此执行保护内部的语句。 第一个语句`print("Condition not met")`在控制台输出`Condition not met`。
+在上述程序中，`guard`条件的计算结果为`false`，因此执行`guard`内部的语句。 第一个语句`print("Condition not met")`在控制台输出`Condition not met`。
 
 并且语句`return`终止函数的执行，并且执行函数调用后的语句`print("Hello, after function call")`在控制台中输出`Hello after function call`。
 
 * * *
 
-## 示例 4：带有可选组件的`guard`
+## 示例 4：带有可选项的`guard`
 
-我们已经在[Swift `Optional`](/swift-programming/optionals "Swift Optionals")中看到了`if-let`的使用，以展开可选项。 但是，我们也可以使用保护声明代替`if-let`来展开具有一个优点的可选项。 展开带保护的可选项而不是`if-let`的主要优点是，我们可以扩大展开的变量的范围。
+我们已经在[Swift `Optional`](/swift-programming/optionals "Swift Optionals")中看到了`if-let`的使用，以展开可选项。 但是，我们也可以使用`guard`语句 代替`if-let`来展开具有一个优点的可选项。 展开带`guard`的可选项而不是`if-let`的主要优点是，我们可以扩大展开的变量的范围。
 
 让我们在下面的示例中看到这一点：
 
@@ -133,9 +133,9 @@ changeOptionalStringToUpperCase()
 Name is nil. Cannot process
 ```
 
-在上述程序中，您可以看到在保护声明定义的范围之外使用了未包装的值`temp`。 由于`name`被定义为可选并且包含`nil`值，因此`guard`语句无法解包该值。
+在上述程序中，您可以看到在`guard`语句 定义的范围之外使用了未包装的值`temp`。 由于`name`被定义为可选并且包含`nil`值，因此`guard`语句无法解包该值。
 
-因此，将执行后卫内部的语句，该语句打印`Name is nil. Cannot process`，并使用`return`语句终止函数。 上述保护语句`if-else`语句的等效代码是：
+因此，将执行后卫内部的语句，该语句打印`Name is nil. Cannot process`，并使用`return`语句终止函数。 上述`guard`语句`if-else`语句的等效代码是：
 
 ```swift
 func changeOptionalStringToUpperCase() {
diff --git a/docs/swift/25.md b/docs/swift/25.md
index 06fee88..a0784f0 100644
--- a/docs/swift/25.md
+++ b/docs/swift/25.md
@@ -1 +1 @@
-# 迅捷收藏
\ No newline at end of file
+# Swift 集合
\ No newline at end of file
diff --git a/docs/swift/26.md b/docs/swift/26.md
index b3792c7..d422feb 100644
--- a/docs/swift/26.md
+++ b/docs/swift/26.md
@@ -1,4 +1,4 @@
-# 迅捷数组
+# Swift 数组
 
 > 原文： [https://www.programiz.com/swift-programming/arrays](https://www.programiz.com/swift-programming/arrays)
 
@@ -201,7 +201,7 @@ fatal error: Index out of range
 
 ## 一些有用的内置数组函数&属性
 
-### 1\. isEmpty
+### 1\. `isEmpty`
 
 此属性确定数组是否为空。 如果数组不包含任何值，则返回`true`，否则返回`false`。
 
@@ -220,11 +220,11 @@ false
 
 * * *
 
-### 2.首先
+### 2.`first`
 
 此属性用于访问数组的第一个元素。
 
-#### 示例 9：首先如何工作？
+#### 示例 9：`first`如何工作？
 
 ```swift
 let intArr = [21, 34, 54, 12]
@@ -241,7 +241,7 @@ Optional(21)
 
 * * *
 
-### 3.附加
+### 3.`append`
 
 `append`函数用于在数组末尾插入/附加元素。
 
@@ -276,11 +276,11 @@ print(firstArr)
 
 * * *
 
-### 4.插入
+### 4.`insert`
 
 此函数用于在数组的特定索引处插入/附加元素。
 
-#### 示例 11：插入如何工作？
+#### 示例 11：`insert`如何工作？
 
 ```swift
 var intArr = [21,34,54,12]
@@ -298,11 +298,11 @@ print(intArr)
 
 * * *
 
-### 5.删除
+### 5.`remove`
 
 此函数从数组中删除并返回在指定位置指定的值。
 
-#### 示例 12：删除如何工作？
+#### 示例 12：`remove`如何工作？
 
 ```swift
 var strArr = ["ab","bc","cd","de"]
@@ -322,7 +322,7 @@ removed value is bc
 
 * * *
 
-### 6.颠倒了
+### 6.`reversed`
 
 此函数以相反的顺序返回数组的元素。
 
@@ -342,11 +342,11 @@ print(reversedArr)
 
 * * *
 
-### 7.计数
+### 7.`count`
 
 此属性返回数组中元素的总数。
 
-#### 示例 14：计数
+#### 示例 14：`count`
 
 ```swift
 let floatArr = [10.2,21.3,32.0,41.3]
diff --git a/docs/swift/27.md b/docs/swift/27.md
index 6f7f03c..e140f47 100644
--- a/docs/swift/27.md
+++ b/docs/swift/27.md
@@ -1,4 +1,4 @@
-# 迅捷套装
+# Swift 集
 
 > 原文： [https://www.programiz.com/swift-programming/sets](https://www.programiz.com/swift-programming/sets)
 
@@ -10,7 +10,7 @@
 
 * * *
 
-## 什么是集合？
+## 什么是集？
 
 集只是一个容器，可以在无序列表中保存多个数据类型的值，并确保容器中的元素唯一（即每个数据仅出现一次）。
 
@@ -24,7 +24,7 @@ Swift 的所有基本类型（例如`String`，`Int`，`Double`和`Bool`）在
 
 * * *
 
-## 如何在 Swift 中声明集合？
+## 如何在 Swift 中声明集？
 
 您可以通过将类型指定为`Set`，然后再将其存储在`< >`中的数据类型来创建一个空集。
 
@@ -52,7 +52,7 @@ print(emptyIntSet)</int></int>
 
 由于 Swift 是一种类型推断语言，因此您也可以在不指定数据类型的情况下直接创建集，但是必须使用一些值进行初始化，以便编译器可以将其类型推断为：
 
-### 示例 2：声明具有某些值的集合
+### 示例 2：声明具有某些值的集
 
 ```swift
 let someIntSet:Set = [1, 2, 3, 4, 5, 6, 7, 8, 9]
@@ -71,7 +71,7 @@ print(someIntSet)
 
 如您所知，当您尝试将集合内的值打印为`print(someIntSet)`时，您将以与定义集合中的项不同的顺序获得结果，因为它存储的值没有定义的顺序。 因此，每次访问订单时都会更改。
 
-### 示例 3：声明具有重复值的集合
+### 示例 3：声明具有重复值的集
 
 ```swift
 let someStrSet:Set = ["ab","bc","cd","de","ab"]
@@ -90,13 +90,13 @@ print(someStrSet)
 
 * * *
 
-## 如何在 Swift 中访问集合元素？
+## 如何在 Swift 中访问集的元素？
 
 您无法使用*下标语法*作为数组访问集合的元素。 这是因为集合是无序的，并且没有索引来访问元素。
 
 因此，您需要使用其方法和属性或使用`for-in`循环来访问集合。
 
-#### 示例 4：访问集合中的元素
+#### 示例 4：访问集中的元素
 
 ```swift
 var someStrSet:Set = ["ab", "bc", "cd", "de"]
@@ -120,7 +120,7 @@ bc
 
 * * *
 
-#### 示例 5：使用`remove()`访问集合中的元素
+#### 示例 5：使用`remove()`访问集中的元素
 
 ```swift
 var someStrSet:Set = ["ab", "bc", "cd", "de"]
@@ -140,7 +140,7 @@ Optional("cd")
 
 * * *
 
-#### 示例 6：`remove()`的可选处理
+#### 示例 6：`remove()`的可选项处理
 
 ```swift
 var someStrSet:Set = ["ab", "bc", "cd", "de"]
@@ -161,7 +161,7 @@ cd
 
 * * *
 
-## 如何在集合中添加新元素？
+## 如何在集中添加新元素？
 
 您可以使用 Swift 中的`insert()`方法将新元素添加到集合中。
 
@@ -183,7 +183,7 @@ print(someStrSet)
 
 * * *
 
-## 设置操作
+## 集的操作
 
 使用集合的另一个主要优点是您可以执行集合操作，例如将两个集合组合在一起，确定两个集合具有哪些共同的值等。此操作类似于数学中的集合操作。
 
@@ -267,13 +267,13 @@ print(a.symmetricDifference(b))
 
 * * *
 
-## 设置成员资格和平等运营
+## 集的成员资格和相等操作
 
-### 设置相等
+### 集的相等
 
 您可以使用`==`运算符检查两组是否包含相同的元素。 如果两个集合包含相同的元素，则返回`true`，否则返回`false`。
 
-#### 示例 5：设置相等操作
+#### 示例 5：集的相等操作
 
 ```swift
 let a: Set = [1, 3, 5, 7, 9]
@@ -302,7 +302,7 @@ a and c are same
 
 * * *
 
-### 设置成员资格
+### 集的成员资格
 
 您还可以使用以下方法检查两个集合之间的关系：
 
@@ -311,7 +311,7 @@ a and c are same
 *   `isStrictSubset(of:`或`isStrictSuperset(of:)`：此方法确定集合是子集还是超集，但不等于指定的集。
 *   `isDisjoint(with:)`此方法确定两个集合是否没有共同的值。
 
-#### 示例 6：设置成员资格操作
+#### 示例 6：集的成员资格操作
 
 ```swift
 let a: Set = [1, 3, 5, 7, 9]
@@ -362,11 +362,11 @@ false
 
 * * *
 
-### 2.首先
+### 2.`first`
 
 此属性用于访问集合的第一个元素。
 
-#### 示例 8：首先如何工作？
+#### 示例 8：`first`如何工作？
 
 ```swift
 let intSet = [21, 34, 54, 12]
@@ -385,11 +385,11 @@ Optional(54)
 
 * * *
 
-### 3.插入
+### 3.`insert`
 
-insert 函数用于在集合中插入/追加元素。
+`insert`函数用于在集合中插入/追加元素。
 
-#### 示例 9：插入如何工作？
+#### 示例 9：`insert`如何工作？
 
 ```swift
 var intSet:Set = [21, 34, 54, 12]
@@ -405,7 +405,7 @@ print(intSet)
 
 * * *
 
-### 4.颠倒了
+### 4.`reversed`
 
 此函数以相反的顺序返回集合的元素。
 
@@ -427,11 +427,11 @@ print(reversedSet)
 
 * * *
 
-### 5.计数
+### 5.`count`
 
 此属性返回集合中元素的总数。
 
-#### 示例 11：计数如何工作？
+#### 示例 11：`count`如何工作？
 
 ```swift
 let floatSet:Set = [10.2, 21.3, 32.0, 41.3]
@@ -446,7 +446,7 @@ print(floatSet.count)
 
 * * *
 
-### 6\. removeFirst
+### 6\. `removeFirst`
 
 此函数从集合中删除并返回第一个值。
 
diff --git a/docs/swift/28.md b/docs/swift/28.md
index c4323af..1e65117 100644
--- a/docs/swift/28.md
+++ b/docs/swift/28.md
@@ -1,4 +1,4 @@
-# 斯威夫特字典
+# Swift 字典
 
 > 原文： [https://www.programiz.com/swift-programming/dictionary](https://www.programiz.com/swift-programming/dictionary)
 
@@ -90,7 +90,7 @@ print(newDictionary)
 
 在上述程序中，`zip(customKeys,customValues)`创建一个新的*元组*序列，每个元素表示来自`customKeys`和`customValues`的值。 要了解有关`zip`的工作原理的更多信息，请访问 Swift `zip`。
 
-现在，我们可以将此序列传递给`Dictionary(uniqueKeysWithValues:)`初始化程序，并创建一个新的`Dictionary`。 因此，`print(newDictionary)`输出具有两个数组元素的新词典。
+现在，我们可以将此序列传递给`Dictionary(uniqueKeysWithValues:)`初始化程序，并创建一个新的`Dictionary`。 因此，`print(newDictionary)`输出具有两个数组元素的新字典。
 
 * * *
 
@@ -158,7 +158,7 @@ print(someDictionary)
 ["Japan": "Tokyo", "China": "Beijing", "India": "NewDelhi", "Nepal": "Kathmandu"]
 ```
 
-在上面的示例中，我们使用下标语法在给定的词典中创建了一个新的键值对`"Japan": "Tokyo"`。
+在上面的示例中，我们使用下标语法在给定的字典中创建了一个新的键值对`"Japan": "Tokyo"`。
 
 您还可以使用下标语法将与特定键关联的值更改为：
 
@@ -180,9 +180,9 @@ print(someDictionary)
 
 * * *
 
-## 一些有用的内置词典功能&属性
+## 一些有用的内置字典功能&属性
 
-### 1\. isEmpty
+### 1\. `isEmpty`
 
 此属性确定字典是否为空。 如果字典不包含任何值，则返回`true`，否则返回`false`。
 
@@ -201,11 +201,11 @@ false
 
 * * *
 
-### 2.首先
+### 2.`first`
 
 此属性用于访问字典的第一个元素。
 
-#### 示例 9：首先如何工作？
+#### 示例 9：`first`如何工作？
 
 ```swift
 let someDictionary = ["Nepal":"Kathmandu", "China":"Beijing", "India":"NewDelhi"]
@@ -220,11 +220,11 @@ Optional((key: "China", value: "Beijing"))
 
 * * *
 
-### 3.计数
+### 3.`count`
 
 此属性返回字典中的元素总数（键值对）。
 
-#### 示例 10：计数如何工作？
+#### 示例 10：`count`如何工作？
 
 ```swift
 let someDictionary = ["Nepal":"Kathmandu", "China":"Beijing", "India":"NewDelhi"]
@@ -239,11 +239,11 @@ print(someDictionary.count)
 
 * * *
 
-### 4.键
+### 4.`keys`
 
 此属性返回字典中的所有键。
 
-#### 示例 11：键如何工作？
+#### 示例 11：`keys`如何工作？
 
 ```swift
 var someDictionary = ["Nepal":"Kathmandu", "China":"Beijing", "India":"NewDelhi"]
@@ -261,7 +261,7 @@ print(dictKeys)
 
 * * *
 
-### 5\. removeValue
+### 5\. `removeValue`
 
 此函数从字典中删除并返回用键指定的值。 这两个键值对将从字典中删除。
 
diff --git a/docs/swift/29.md b/docs/swift/29.md
index 8b15750..c83426a 100644
--- a/docs/swift/29.md
+++ b/docs/swift/29.md
@@ -1 +1 @@
-# 迅捷函数
\ No newline at end of file
+# Swift 函数
\ No newline at end of file
diff --git a/docs/swift/3.md b/docs/swift/3.md
index c8515e1..242d005 100644
--- a/docs/swift/3.md
+++ b/docs/swift/3.md
@@ -28,7 +28,7 @@ print("Hello, World!")
 Hello, World!
 ```
 
-## 斯威夫特：HelloWorld 程序有效吗？
+## Swift：HelloWorld 程序有效吗？
 
 1.  `// Hello, World! Program`
 
diff --git a/docs/swift/30.md b/docs/swift/30.md
index a9a6e62..ed2c209 100644
--- a/docs/swift/30.md
+++ b/docs/swift/30.md
@@ -1,4 +1,4 @@
-# 迅捷函数
+# Swift 函数
 
 > 原文： [https://www.programiz.com/swift-programming/functions](https://www.programiz.com/swift-programming/functions)
 
diff --git a/docs/swift/31.md b/docs/swift/31.md
index dae5d55..ee2f5a7 100644
--- a/docs/swift/31.md
+++ b/docs/swift/31.md
@@ -117,7 +117,7 @@ Good Morning!
 
 * * *
 
-## 具有参数和返回值的功能
+## 具有参数和返回值的函数
 
 这些类型的函数使用参数，还返回值。
 
@@ -265,7 +265,7 @@ let result = sum(of: 2, and: 3)
 print("The sum is \(result)") 
 ```
 
-现在，方法调用是可表达的。 但是，现在我们必须在`return of + and`中使用参数名称`of`和`and`来找到两个数字的和。 现在，这使得函数体不可读。 在功能体内使用`a`和`b`代替`of`和`and`。
+现在，方法调用是可表达的。 但是，现在我们必须在`return of + and`中使用参数名称`of`和`and`来找到两个数字的和。 现在，这使得函数体不可读。 在函数体内使用`a`和`b`代替`of`和`and`。
 
 为此，我们必须将参数标签明确定义为：
 
@@ -282,7 +282,7 @@ print("The sum is \(result)")
 
 在上面的程序中，该函数接受类型为`Int`的两个参数。 函数调用使用`of`和`and`的参数标签，将函数称为`sum(of: 2, and: 3)`而不是`sum(a: 2, b: 3)`有意义。
 
-另外，功能体使用参数名称`a`和`b`代替`of`和`and`。
+另外，函数体使用参数名称`a`和`b`代替`of`和`and`。
 
 您也可以通过在参数名称之前写入`_`来省略参数标签。
 
@@ -297,7 +297,7 @@ print("The sum is \(result)")
 
 * * *
 
-## 具有默认参数值的功能
+## 具有默认参数值的函数
 
 您可以为函数中的任何参数提供默认值，方法是在该参数的类型之后为该参数分配一个值。 提供默认参数可让您在调用函数时忽略该参数。
 
@@ -387,9 +387,9 @@ The sum of numbers is 36
 
 * * *
 
-## 具有输入输出参数的功能
+## 具有输入输出参数的函数
 
-定义功能参数时，无法在体内修改功能参数。 因此，它们默认为常量。 让我们在示例中看一下：
+定义函数参数时，无法在体内修改函数参数。 因此，它们默认为常量。 让我们在示例中看一下：
 
 ```swift
 func process(name:String) {
@@ -414,7 +414,7 @@ func funcname(parameterName:inout Type) -> Return Type {
 }
 ```
 
-### 示例 12：带有`in out`参数的函数
+### 示例 12：带有`inout`参数的函数
 
 ```swift
 func process(name:inout String) { 
diff --git a/docs/swift/33.md b/docs/swift/33.md
index b7cd437..cde5c03 100644
--- a/docs/swift/33.md
+++ b/docs/swift/33.md
@@ -1,4 +1,4 @@
-# 快速递归
+# Swift 递归
 
 > 原文： [https://www.programiz.com/swift-programming/recursion](https://www.programiz.com/swift-programming/recursion)
 
diff --git a/docs/swift/34.md b/docs/swift/34.md
index 26422d7..38311bf 100644
--- a/docs/swift/34.md
+++ b/docs/swift/34.md
@@ -1,4 +1,4 @@
-# 迅捷范围
+# Swift 范围
 
 > 原文： [https://www.programiz.com/swift-programming/ranges](https://www.programiz.com/swift-programming/ranges)
 
@@ -8,7 +8,7 @@
 
 我们可以使用下面描述的两个范围运算符快速创建范围：
 
-## 1.近距离运算符（`lowerBound ... upperBound`）
+## 1.闭合运算符（`lowerBound ... upperBound`）
 
 它包括间隔（`lowerbound`到`upperBound`）中的所有值。 使用`…`（3 点）运算符声明。
 
@@ -24,7 +24,7 @@
 
 ## 范围类型
 
-### 1.封闭范围（`lowerBound ... upperBound`）
+### 1.闭合范围（`lowerBound ... upperBound`）
 
 使用封闭范围运算符创建的范围称为封闭范围。 它包括从下限到上限的所有值。
 
@@ -81,11 +81,11 @@ for value in 1..<3 {
 
 * * *
 
-### 3.一侧范围
+### 3.单侧范围
 
 单边范围是指在一个方向上尽可能连续的范围。 可以使用半开范围算子和闭合范围算子来创建它，但是该算子只能在一侧具有一个值。
 
-#### 示例 3：单边范围小于 2
+#### 示例 3：小于 2 的单侧范围
 
 ```swift
 let range = ..<2
@@ -110,7 +110,7 @@ false
 
 但是，由于使用半开范围运算符，因此上限值（2）不包含在范围内。 因此，`range.contains(2)`返回`false`。
 
-#### 示例 4：从 2 开始的单边范围
+#### 示例 4：从 2 开始的单侧范围
 
 ```swift
 let range = 2...
diff --git a/docs/swift/35.md b/docs/swift/35.md
index 77e72d0..a348280 100644
--- a/docs/swift/35.md
+++ b/docs/swift/35.md
@@ -141,7 +141,7 @@ The string value is Swift
 *   对`output(x: 2)`的调用会触发函数`func output(x:Int)`中的语句，并且
 *   调用`output(x: "Swift")`会触发函数`func output(x:String)`中的语句。
 
-## 示例 3：基于不同数量参数的函数重载
+## 示例 3：基于不同参数数量的函数重载
 
 ```swift
 func output() {
diff --git a/docs/swift/36.md b/docs/swift/36.md
index 0deb15f..9ed13c7 100644
--- a/docs/swift/36.md
+++ b/docs/swift/36.md
@@ -1 +1 @@
-# 迅捷进阶
\ No newline at end of file
+# Swift 进阶
\ No newline at end of file
diff --git a/docs/swift/37.md b/docs/swift/37.md
index 7872f11..e6332d5 100644
--- a/docs/swift/37.md
+++ b/docs/swift/37.md
@@ -1,4 +1,4 @@
-# 迅速关闭
+# Swift 闭包
 
 > 原文： [https://www.programiz.com/swift-programming/closures](https://www.programiz.com/swift-programming/closures)
 
@@ -11,7 +11,7 @@
 闭包主要用于两个原因：
 
 1.  **完成块**
-    闭包可帮助您在某些任务完成执行时得到通知。 请参阅[关闭作为完成处理器](#completion)，以了解有关它的更多信息。
+    闭包可帮助您在某些任务完成执行时得到通知。 请参阅[闭包作为完成处理器](#completion)，以了解有关它的更多信息。
 2.  **高阶函数**
     闭包可以作为高阶函数的输入参数传递。 高阶函数只是一种接受函数作为输入并返回类型函数的值作为输出的函数类型。
     为此，最好使用闭包代替函数，因为闭包省略了`func`关键字和函数名，从而使代码更具可读性和简短性。
@@ -214,15 +214,15 @@ someSimpleFunction(msg:"Hello Swift Community!")  {
 
 * * *
 
-## 自动关闭
+## 自动闭包
 
 用`@autoclosure`关键字标记的闭包称为自动闭包。`@autoclosure`关键字通过添加`{}`在表达式周围创建自动闭包。 因此，在将闭包传递给函数时，可以省略花括号`{}`。
 
-使用自动关闭的主要优点是，调用关闭时，无需将表达式用大括号`{}`括起来。
+使用自动闭包的主要优点是，调用闭包时，无需将表达式用大括号`{}`括起来。
 
 让我们在示例中看一下。
 
-### 示例 6：不使用`@autoclosure`进行关闭
+### 示例 6：不使用`@autoclosure`的闭包
 
 ```swift
 func someSimpleFunction(someClosure:()->(), msg:String) {
@@ -253,11 +253,11 @@ someClosure: ({
 
 ```
 
-我们可以使用自动关闭功能将上述程序重写为：
+我们可以使用自动闭包功能将上述程序重写为：
 
 * * *
 
-### 示例 7：自动关闭
+### 示例 7：自动闭包
 
 ```swift
 func someSimpleFunction(someClosure: @autoclosure ()->(), msg:String) {
@@ -283,7 +283,7 @@ Hello World! from closure
 
 像普通的闭包一样，您可以将参数传递给自动闭包并从中返回值。 但是，即使您传递参数，它们也会被忽略并且不能在闭包内部使用。 这是因为您无法定义参数以将其用作`{ arg in }`。
 
-因此，建议创建不带参数但可以返回值的自动关闭。 值是包装在其中的表达式。 让我们在下面的示例中看到这一点。
+因此，建议创建不带参数但可以返回值的自动闭包。 值是包装在其中的表达式。 让我们在下面的示例中看到这一点。
 
 ### 示例 8：具有返回值的自动闭包
 
@@ -301,7 +301,7 @@ someSimpleFunction("Good Morning")
 Good Morning
 ```
 
-在上面的程序中，我们定义了一个不带参数但返回`String`（`()->(String)`）的函数。 我们将自动关闭功能**“早上好”** 传递给了该功能。 这也是闭包的返回值。
+在上面的程序中，我们定义了一个不带参数但返回`String`（`()->(String)`）的函数。 我们将自动闭包功能**“早上好”** 传递给了该功能。 这也是闭包的返回值。
 
 因此，当我们在函数内部调用`someClosure()`时，它返回了`Good Morning`值。
 
@@ -321,23 +321,23 @@ someSimpleFunction("Good Morning")
 Good Morning
 ```
 
-在上面的程序中，我们定义了一个需要自动关闭的函数。 闭包采用`String`类型的值，并且还返回`String`类型的值。
+在上面的程序中，我们定义了一个需要自动闭包的函数。 闭包采用`String`类型的值，并且还返回`String`类型的值。
 
 像前面的示例一样，我们将自动闭包`Good Morning`传递给函数，这是闭包的返回值。
 
-因此，即使自动关闭称为`someClosure("Hello World")`，它也不能接受任何参数，它仍会返回并打印`Good Morning`。
+因此，即使自动闭包称为`someClosure("Hello World")`，它也不能接受任何参数，它仍会返回并打印`Good Morning`。
 
 * * *
 
-## 转义与无转义闭包
+## 逃逸与无逃逸闭包
 
-### 无逃逸关闭
+### 无逃逸闭包
 
 当闭包作为参数传递给函数时，闭包被认为是无法逃脱的，并在函数返回之前被调用。 闭包不在函数外部使用。
 
-在 Swift 中，默认情况下所有闭包参数都不会转义。 转义和不转义闭包的概念是用于编译器优化的。
+在 Swift 中，默认情况下所有闭包参数都不会逃逸。 逃逸和不逃逸闭包的概念是用于编译器优化的。
 
-#### 示例 10：没有转义的闭包
+#### 示例 10：无逃逸的闭包
 
 ```swift
 func testFunctionWithNoEscapingClosure(myClosure:() -> Void) {
@@ -359,15 +359,15 @@ function called
 closure called 
 ```
 
-在上面的示例中，闭包被称为没有转义，因为闭包`myClosure()`在函数返回之前被调用，并且闭包不在函数主体之外使用。
+在上面的示例中，闭包被称为没有逃逸，因为闭包`myClosure()`在函数返回之前被调用，并且闭包不在函数主体之外使用。
 
 * * *
 
-### 逃逸关闭
+### 逃逸闭包
 
-当闭包作为函数的参数传递给闭包时，闭包被认为是对函数的转义，但是在函数返回或在函数主体之外使用闭包后调用闭包。
+当闭包作为函数的参数传递给闭包时，闭包被认为是对函数的逃逸，但是在函数返回或在函数主体之外使用闭包后调用闭包。
 
-#### 示例 11：转义闭包
+#### 示例 11：逃逸闭包
 
 ```swift
 var closureArr:[()->()] = []
@@ -396,11 +396,11 @@ closure called
 
 现在，如果将在函数范围内定义的闭包`myClosure`附加到在函数外部定义的`ClosureArr`，则闭包`myClosure`需要逸出主体 功能的
 
-因此，闭包需要转义并标记为`@escaping`关键字。
+因此，闭包需要逃逸并标记为`@escaping`关键字。
 
-#### 示例 12：没有转义的闭包
+#### 示例 12：无逃逸的闭包
 
-在上面的“不转义闭包”部分中，我们描述了如果在函数返回之前调用了闭包，则闭包需要不转义。 因此，如果在函数返回后调用闭包，则应该转义，对吗？
+在上面的“不逃逸闭包”部分中，我们描述了如果在函数返回之前调用了闭包，则闭包需要不逃逸。 因此，如果在函数返回后调用闭包，则应该逃逸，对吗？
 
 让我们用一个例子测试一下：
 
@@ -428,11 +428,11 @@ func testFunctionWithNoEscapingClosure(myClosure:@escaping () -> Void) {
 } 
 ```
 
-在上述程序中，`DispatchQueue.main.async`异步运行代码块。 所以，现在。 即使在函数返回后也可能发生闭包调用`myClosure()`。 因此，闭包需要转义，并用`@escaping`关键字标记。
+在上述程序中，`DispatchQueue.main.async`异步运行代码块。 所以，现在。 即使在函数返回后也可能发生闭包调用`myClosure()`。 因此，闭包需要逃逸，并用`@escaping`关键字标记。
 
 * * *
 
-## 关闭为完成处理器
+## 闭包为完成处理器
 
 完成处理器是回调/通知，可让您在函数完成其任务时执行某些操作。
 
@@ -500,7 +500,7 @@ print("Other statements")
 3.  您可以在函数内部执行一些工作。 目前，仅`print("some work here")`语句在控制台中的输出为**。**
 4.  对闭包的简单调用为`completion()`，它将发送回调并将程序的控制权转移到闭包内的语句。
     因此，执行`print("call back received")`，在控制台中输出`"call back received"`。
-5.  之后，程序控制再次返回到关闭调用，并执行语句`print("after calling callback")`，该语句在控制台中输出`"after calling callback"`。
+5.  之后，程序控制再次返回到闭包调用，并执行语句`print("after calling callback")`，该语句在控制台中输出`"after calling callback"`。
 6.  函数内部的语句执行后，程序将控制权转移到函数调用`doSomeWork()`，然后执行下一个语句`print("Other statements")`，该语句在控制台中输出`"Other statements"`。
 
 让我们来看一个更实际的示例，将闭包用作完成处理器。
@@ -530,11 +530,11 @@ codeinPlayground { (msg) in
 Code, Take a Nap and Relax
 ```
 
-在上面的程序中，我们声明了一个变量`closeButtonPressed`，该变量将模拟用户是否在游乐场上轻按了关闭按钮。 想想如果您按下关闭按钮，变量`closeButtonPressed`将是`true`。
+在上面的程序中，我们声明了一个变量`closeButtonPressed`，该变量将模拟用户是否在游乐场上轻按了闭包按钮。 想想如果您按下闭包按钮，变量`closeButtonPressed`将是`true`。
 
 函数`codeinPlayground`接受闭包作为参数。 闭包`completion`接受`String`，但不返回值。 由于`closeButtonPressed`被分配了`false`，因此`if`语句内的语句未执行且没有调用闭包。
 
-现在，如果将`closeButtonPressed`分配给`true`（即，当用户按下关闭按钮时）作为`var closeButtonPressed = true`，则会调用`if`执行和关闭语句。
+现在，如果将`closeButtonPressed`分配给`true`（即，当用户按下闭包按钮时）作为`var closeButtonPressed = true`，则会调用`if`执行和闭包语句。
 
 当为变量`closeButtonPressed`分配`true`时，输出为：
 
@@ -543,6 +543,6 @@ Code, Take a Nap and Relax
 Close the playground 
 ```
 
-在这里，我们将闭包用作完成处理器，因为当用户点击关闭按钮时，我们不想在函数`codeinPlayground`中执行语句，而是通过调用闭包`completion("Close the playground")`来完成其执行。
+在这里，我们将闭包用作完成处理器，因为当用户点击闭包按钮时，我们不想在函数`codeinPlayground`中执行语句，而是通过调用闭包`completion("Close the playground")`来完成其执行。
 
 这样，我们就有机会处理与闭包语句内的函数相关的所有最终事件。 在本例中，我们在控制台中将消息输出为`print(msg)`。
diff --git a/docs/swift/4.md b/docs/swift/4.md
index 94ac84f..c7b45c3 100644
--- a/docs/swift/4.md
+++ b/docs/swift/4.md
@@ -34,7 +34,7 @@ print(siteName)
 
 您可以使用[赋值运算符](/swift-programming/operators#assignment "Swift Assignment Operators")（=）在变量中赋值。
 
-#### 示例 1：声明并将值分配给变量
+#### 示例 1：声明并将值赋给变量
 
 ```swift
 var siteName:String
@@ -63,7 +63,7 @@ Apple.com
 
 由于 Swift 是[类型的推断语言](https://en.wikipedia.org/wiki/Type_inference "Swift type inference")，因此它可以自动推断（知道）“ Apple.com”是`String`并将`siteName`声明为[ `String`。 因此，您甚至可以将声明中的`(:String)`类型删除为：
 
-#### 示例 2：在 Swift 中类型推断的变量
+#### 示例 2：Swift 中变量的类型推断
 
 ```swift
 var siteName = "Apple.com"
@@ -98,7 +98,7 @@ Programiz.com
 
 * * *
 
-## 什么是常数？
+## 什么是常量？
 
 常量是变量的一种特殊类型，其值不能更改。 将常量视为保存了以后无法更改的信息的容器是有帮助的。
 
@@ -123,11 +123,11 @@ print(siteName)
 
 * * *
 
-### 如何在 Swift 中为常量分配值？
+### 如何在 Swift 中为常量赋值？
 
 您可以使用赋值运算符（`=`）在与变量相同的**常量**中分配值。
 
-#### 示例 4：声明并将值分配给常量
+#### 示例 4：声明并将值赋给常量
 
 ```swift
 let siteName:String
@@ -155,7 +155,7 @@ Apple.com
 
 与变量一样，可以从声明中删除类型（`:String`），如下所示：
 
-#### 示例 5：在 Swift 中类型推断的常量
+#### 示例 5：Swift 中常量的类型推断
 
 ```swift
 let siteName = "Apple.com"
@@ -186,7 +186,7 @@ print(siteName)
 
 ## 什么是字面值？
 
-字面值是直接出现在源代码中的值。 它可以是数字，字符或字符串等。例如：`"Hello, World"`，12、23.0，`"C"`是字面值的简单示例。 字面值常用于初始化变量或常量（将值分配给它们）。
+字面值是直接出现在源代码中的值。 它可以是数字，字符或字符串等。例如：`"Hello, World"`，12、23.0，`"C"`是字面值的简单示例。 字面值常用于初始化变量或常量（将值赋给它们）。
 
 **例如**：
 
@@ -315,7 +315,7 @@ print(someAnotherFloat)
 let result:Bool = false
 ```
 
-在上面的程序中，`false`是布尔常量，它分配给常量`result`。
+在上面的程序中，`false`是布尔常量，它赋给常量`result`。
 
 * * *
 
diff --git a/docs/swift/5.md b/docs/swift/5.md
index 59e293c..882cfe4 100644
--- a/docs/swift/5.md
+++ b/docs/swift/5.md
@@ -65,13 +65,13 @@ var highScore:Int = "Jack"
 
 下面列出了 swift 中最常用的数据类型：
 
-### 布尔
+### `Bool`
 
 *   声明为`Bool`类型的变量/常量只能存储`true`或`false`两个值。
 *   **默认值**：`false`
 *   当您使用`if-else`语句时，经常使用它。 [Swift `if-else`](/swift-programming/if-else-statement "Swift if else statement")文章将对此进行详细介绍。
 
-#### 示例 1：布尔数据类型
+#### 示例 1：`Bool`数据类型
 
 ```swift
 let result:Bool = true
@@ -86,7 +86,7 @@ true
 
 * * *
 
-### 整数
+### `Int`
 
 *   声明为整数类型的变量/常数可以存储正整数和负整数，包括零且无小数部分。
 *   **默认值**：0
@@ -96,7 +96,7 @@ true
 *   有很多`Integer`类型的变体，例如`UInt`，`Int8`，`Int16`等。最常用的是`Int`。
 *   如果需要指定变量/常量可以容纳的整数的大小/类型，则可以使用`UInt`，`Int8`和`Int16`等更具体地存储它，我们将在下面进行探讨。
 
-#### 示例 2：整数数据类型
+#### 示例 2：`Int`数据类型
 
 ```swift
 var highScore:Int = 100
@@ -121,7 +121,7 @@ print(highScore)
 
 让我们探索 Swift 中`Int`类型的一些变体。
 
-#### Int8
+#### `Int8`
 
 *   可以存储正数和负数的整数类型的变体。
 *   **默认值**：0
@@ -157,7 +157,7 @@ print(Int8.max)
 
 * * *
 
-#### UInt
+#### `UInt`
 
 *   整数类型的变体，称为`UInt`（无符号整数），只能存储无符号数字（正数或零）。
 *   **默认值**：0
@@ -176,14 +176,14 @@ highScore = -100//compile time error when trying to
 
 * * *
 
-### 浮动
+### `Float`
 
 *   声明为浮点型的变量或常量可以存储带小数点或小数点的数字。
 *   **默认值**：0.0
 *   **大小**：32 位浮点数。
 *   **范围**：`1.2 * 10^-38`至`3.4 * 10^38`（`~6`位数字）
 
-#### 示例 5：浮点数据类型
+#### 示例 5：`Float`数据类型
 
 ```swift
 let highScore:Float = 100.232
@@ -198,14 +198,14 @@ print(highScore)
 
 * * *
 
-### 双重
+### `Double`
 
 *   声明为`Double`类型的变量/常量也将带小数点或小数点的数字存储为`Float`，但比`Float`支持的小数点大。
 *   **默认值**：0.0
 *   **大小**：64 位浮点数。 （因此，Double 类型的变量可以存储带小数或小数点大于 Float 支持的数字）
 *   **范围**：`2.3 * 10^-308`至`1.7 * 10^308`（`~15`位数字）
 
-#### 示例 6：双精度数据类型
+#### 示例 6：`Double`数据类型
 
 ```swift
 let highScore:Double = 100.232321212121
@@ -220,12 +220,12 @@ print(highScore)
 
 * * *
 
-### 字符
+### `Character`
 
 *   声明为`Character`类型的变量/常量可以存储单字符字符串文字。
 *   您可以使用转义序列`\u{n}`（unicode 码点，n 为十六进制）在 Swift 中将表情符号或英语以外的其他语言作为字符包含在内。
 
-#### 示例 7：字符数据类型
+#### 示例 7：`Character`数据类型
 
 ```swift
 let playerName:Character = "J"
@@ -243,7 +243,7 @@ J
 
 * * *
 
-### 字符串
+### `String`
 
 *   声明为`String`类型的变量或常量可以存储字符集合。
 *   **默认值**：`""`（空字符串）
@@ -259,7 +259,7 @@ J
     *   `\'`（单引号），以及
     *   `\u{n}`（unicode 码点，n 为十六进制）。
 
-#### 示例 8：字符串数据类型
+#### 示例 8：`String`数据类型
 
 ```swift
 let playerName = "Jack"
diff --git a/docs/swift/6.md b/docs/swift/6.md
index 6a01246..5a69e8f 100644
--- a/docs/swift/6.md
+++ b/docs/swift/6.md
@@ -113,7 +113,7 @@ var unwrappedValue:Int = someValue //crashes due to this line
 
 * * *
 
-## 类型处理
+## 可选项处理
 
 为了使用可选项，需要将其解包。 使用可选项的更好方法是通过条件展开而不是使用`!`运算符强制展开。
 
@@ -189,7 +189,7 @@ It has some value 0
 
 * * *
 
-### 3.保护声明
+### 3.`guard`语句
 
 您可以使用`guard`处理 Swift 中的可选项。 如果您不知道什么警卫，请不要担心。 现在，仅将警卫视为没有`if`块的`if-else`条件。 如果条件失败，则执行`else`语句。 如果不是，则执行下一条语句。 有关更多详细信息，请参见 [Swift `Guard`](/swift-programming/guard-statement "Swift guard statement")。
 
@@ -217,7 +217,7 @@ It has some value 5
 
 * * *
 
-### 4.无商定算子
+### 4.`nil`折叠运算符
 
 在 Swift 中，您还可以使用`nil`折叠运算符检查可选变量是否包含值。 定义为`(a ?? b)`。 它解开可选的`a`并返回它（如果它包含一个值），或者如果`a`为零，则返回默认值`b`。
 
diff --git a/docs/swift/7.md b/docs/swift/7.md
index fcbc1a1..e82a3ba 100644
--- a/docs/swift/7.md
+++ b/docs/swift/7.md
@@ -1,4 +1,4 @@
-# 迅捷的字符和字符串
+# Swift 的字符和字符串
 
 > 原文： [https://www.programiz.com/swift-programming/characters-strings](https://www.programiz.com/swift-programming/characters-strings)
 
@@ -114,7 +114,7 @@ I love Swift.
 
 * * *
 
-### 对字符串的操作
+### 字符串操作
 
 `String`中有一些内置的函数和属性来处理最常用的操作。 例如：要连接字符串，请将其更改为大写或大写。 让我们在下面探索一些常用的操作：
 
@@ -141,7 +141,7 @@ true
 
 * * *
 
-#### 字符串串联
+#### 字符串连接
 
 可以使用[加法运算符](/swift-programming/operators#arithmetic "Swift arithmetic operators") `(+)`或使用[复合赋值运算符](/swift-programming/operators#assignment "Swift assignment operators") `(+=)`将两个不同的字符串值相加。 您也可以使用`append`方法在字符串中附加一个字符/字符串。
 
@@ -202,7 +202,7 @@ let playerScore = 99
 
 现在，您需要向玩家显示一条消息，`Congratulations !. Your highest score is 99.`。 在这里，您需要一种在单个字符串中使用常量值的方法。
 
-可以使用以下字符串串联来实现：
+可以使用以下字符串连接来实现：
 
 ```swift
 let congratsMessage = "Congratulations " + playerName + "!. Your highest score is " + playerScore + "."
@@ -232,7 +232,7 @@ Congratulations Jack!. Your highest score is 99.
 
 * * *
 
-## 一些有用的内置`String`函数&变量：
+## 一些有用的`String`内置函数&变量：
 
 ### 1\. `isEmpty`
 
@@ -312,7 +312,7 @@ print(someString.count)
 
 * * *
 
-### 5\. hasPrefix
+### 5\. `hasPrefix`
 
 此函数确定字符串是否以某些字符开头并返回布尔值。 如果字符串前缀与提供的值匹配，则返回`true`，否则返回`false`。
 
@@ -333,7 +333,7 @@ false
 
 * * *
 
-### 6\. hasSuffix
+### 6\. `hasSuffix`
 
 此函数确定字符串是否以某些字符结尾，并返回布尔值。 如果字符串后缀与提供的值匹配，则返回`true`，否则返回`false`。
 
diff --git a/docs/swift/8.md b/docs/swift/8.md
index 972fe10..12d0f90 100644
--- a/docs/swift/8.md
+++ b/docs/swift/8.md
@@ -61,7 +61,7 @@ Hello, World!
 
 * * *
 
-### 示例 3：使用终止符参数进行打印而没有链接中断
+### 示例 3：使用终止符参数进行打印而没有行中断
 
 如果要打印而没有换行符，则需要在`print`函数的终止符参数中传递一个空字符串，如下所示：
 
@@ -86,7 +86,7 @@ I also love Taylor Swift.
 
 * * *
 
-### 示例 4：使用单次打印功能打印多个项目
+### 示例 4：使用单次打印函数打印多个项目
 
 您还可以在单​​个打印语句中打印多个项目，并在这些项目之间添加`separator`，如下所示：
 
@@ -125,7 +125,7 @@ World!
 
 * * *
 
-### 示例 6：使用三重引号打印多行
+### 示例 6：使用三引号打印多行
 
 在 Swift 中，有一种更好的方法可以在单个`print`语句中输出多行消息。 您必须使用多行字符串字面值。 这是通过在多行字符串字面值中使用三引号将字符添加为
 
diff --git a/docs/swift/9.md b/docs/swift/9.md
index bea1f12..e95cb51 100644
--- a/docs/swift/9.md
+++ b/docs/swift/9.md
@@ -16,7 +16,7 @@
 
 结果值通常是 [Swift 数据类型](/swift-programming/data-types "Swift Data Types")中的一种，例如整数，字符串和浮点数或更复杂的数据类型作为函数。
 
-### 示例 1：程序中的 Swift 表达式
+### 示例 1：Swift 程序中的表达式
 
 ```swift
 let someValue:Int = 12
-- 
GitLab