2020-07-06 23:16:11

docs/swift/12.md

@@ -119,7 +119,7 @@ iOS
 
 上面的示例将整数值 10 分配给常数 `age` 。 因此，语句`print(age)`在控制台中输出 10。
 
-同样，语句`let platform = "iOS"`将字符串文字`"iOS"`分配给常量`平台`。 因此，语句`print(platform)`在控制台中输出 **iOS** 。
+同样，语句`let platform = "iOS"`将字符串文字`"iOS"`分配给常量`platform`。 因此，语句`print(platform)`在控制台中输出 **iOS** 。
 
 ### 示例 5：复合赋值运算符
 

docs/swift/14.md

@@ -18,8 +18,8 @@ condition ? value1 : value2
 
 这是这样的
 
-*   如果`条件`为 true，则返回 `value1` 。
-*   如果`条件`为假，则返回 `value2` 。
+*   如果`condition`为 true，则返回 `value1` 。
+*   如果`condition`为假，则返回 `value2` 。
 
 上面的等效代码使用 if-else 是：
 

docs/swift/15.md

@@ -46,7 +46,7 @@ print(invertedNumber)
 
 在上面的程序中，语句`let initalNumber:UInt8 = 1`的类型为 Unsigned int，大小为 8 位。 因此，十进制的 1 可以表示为二进制的`00000001`。
 
-按位非运算符更改变量或常量的所有位，位 0 更改为 1，而 1 更改为 0。因此`倒数`包含位`11111110`。 将其转换为十进制后，将其表示为 254。因此，语句`print(invertedNumber)`在屏幕中输出 254。
+按位非运算符更改变量或常量的所有位，位 0 更改为 1，而 1 更改为 0。因此`invertedNumber`包含位`11111110`。 将其转换为十进制后，将其表示为 254。因此，语句`print(invertedNumber)`在屏幕中输出 254。
 
 您还可以直接在位中执行按位运算符，如下所示：
 
@@ -68,7 +68,7 @@ When you run the above program, the output will be:
 
 `initialBits` 包含对应于十进制 255 的二进制值`11111111`。 为了用二进制表示数字，我们在文字中以`0b`作为前缀。 如果没有`0b`作为前缀，它将把它当作普通整数对待，并且会出现溢出错误（UInt8 只能存储 0 到 255 之间的数字）。
 
-由于我们使用了按位非运算符，因此将所有 1 都更改为 0。因此，常量`反转位`包含`00000000`，它等于`UInt8`中的 0。
+由于我们使用了按位非运算符，因此将所有 1 都更改为 0。因此，常量`initialBits`包含`00000000`，它等于`UInt8`中的 0。
 
 * * *
 
@@ -86,7 +86,7 @@ When you run the above program, the output will be:
 -2
 ```
 
-在上面的程序中，十进制的 1 可以表示为`00000001`的二进制。 按位非运算符更改变量或常量的所有位，位 0 更改为 1，1 更改为 0。因此，`倒数`包含位`11111110`。 这应该在屏幕中输出 254。 而是返回-2。 奇怪吧？ 让我们在下面探讨这是如何发生的。
+在上面的程序中，十进制的 1 可以表示为`00000001`的二进制。 按位非运算符更改变量或常量的所有位，位 0 更改为 1，1 更改为 0。因此，`invertedNumber`包含位`11111110`。 这应该在屏幕中输出 254。 而是返回-2。 奇怪吧？ 让我们在下面探讨这是如何发生的。
 
 `let initalNumber:Int = 1`是一个可以容纳正整数和负整数的有符号整数。 这就是为什么当我们不对有符号整数应用运算符时，返回的二进制也可能表示负数的原因。
 
@@ -100,7 +100,7 @@ When you run the above program, the output will be:
 2.  反转数字。 0 变成 1，而 1 变成 0：`11111101`
 3.  新增 1：`11111110`
 
-这就是编译器将二进制数`1111110`解释为十进制`-2`的方式。 但是，编译器有些许变化，我们没有注意到。 它还将`倒数`的类型推断为`Int8`类型。
+这就是编译器将二进制数`1111110`解释为十进制`-2`的方式。 但是，编译器有些许变化，我们没有注意到。 它还将`invertedNumber`的类型推断为`Int8`类型。
 
 * * *
 

docs/swift/17.md

@@ -47,15 +47,15 @@ Number is positive.
 This statement is always executed.
 ```
 
-在上面的程序中，我们用值 10 初始化了常量`编号`，并且测试表达式`number > 0`的计算结果为 true。 因此，执行 if 语句体内的`print("Number is positive.")`语句，输出 **Number 为正。 控制台中的**。
+在上面的程序中，我们用值 10 初始化了常量`number`，并且测试表达式`number > 0`的计算结果为 true。 因此，执行 if 语句体内的`print("Number is positive.")`语句，输出 **Number 为正。 控制台中的**。
 
-现在，将`数字`的值更改为负整数。 假设`-5`。 在这种情况下的输出将是：
+现在，将`number`的值更改为负整数。 假设`-5`。 在这种情况下的输出将是：
 
 ```swift
 This statement is always executed.
 ```
 
-当`数字`初始化为值-5 时，测试表达式`number > 0`的计算结果为 false。 因此，Swift 编译器会跳过 if 语句主体的执行。
+当`number`初始化为值-5 时，测试表达式`number > 0`的计算结果为 false。 因此，Swift 编译器会跳过 if 语句主体的执行。
 
 * * *
 
@@ -100,18 +100,18 @@ Number is positive.
 This statement is always executed
 ```
 
-在上述程序中，常数`编号`初始化为值 10，并且测试表达式`number > 0`的值为`true`。 因此，if 语句体内的语句`print("Number is positive.")`被执行。
+在上述程序中，常数`number`初始化为值 10，并且测试表达式`number > 0`的值为`true`。 因此，if 语句体内的语句`print("Number is positive.")`被执行。
 
 输出**号为正。 控制台中的**和 else 主体内部的语句将被跳过。
 
-现在，将`数字`的值更改为负数。 假设-5。 在这种情况下的输出将是：
+现在，将`number`的值更改为负数。 假设-5。 在这种情况下的输出将是：
 
 ```swift
 Number is not positive.
 This statement is always executed.
 ```
 
-当`数字`为-5 时，将测试表达式`number > 0`评估为`false`。 在这种情况下，将执行 else 主体内部的语句，并跳过 if 主体内部的语句。
+当`number`为-5 时，将测试表达式`number > 0`评估为`false`。 在这种情况下，将执行 else 主体内部的语句，并跳过 if 主体内部的语句。
 
 您还可以在 Swift 中用[三元运算符替换 if..else 语句，这是 if ... else 语句的简写形式。](/swift-programming/ternary-conditional-operator "Swift ternary conditional operator")
 
@@ -169,7 +169,7 @@ When you run the program, the output will be:
 Number is 0.
 ```
 
-在上面的程序中，常量`编号`初始化为值 0。由于从上到下执行语句，因此它将检查计算为`false`的表达式`number > 0`。
+在上面的程序中，常量`number`初始化为值 0。由于从上到下执行语句，因此它将检查计算为`false`的表达式`number > 0`。
 
 然后，它检查下一个表达式`number < 0`，该表达式的结果也为 false。
 

docs/swift/19.md

@@ -210,9 +210,9 @@ Python
 
 在上面的程序中，要迭代的序列是一个字符串数组。
 
-`语言`的值设置为数组的第一个元素，并执行循环内的 print 语句，该语句在控制台中输出“ Swift”。
+`language`的值设置为数组的第一个元素，并执行循环内的 print 语句，该语句在控制台中输出“ Swift”。
 
-执行该语句后，将使用数组的下一个元素更新`语言`，并再次调用 print 语句。 这个过程一直持续到访问数组的最后一个元素为止。
+执行该语句后，将使用数组的下一个元素更新`language`，并再次调用 print 语句。 这个过程一直持续到访问数组的最后一个元素为止。
 
 * * *
 
@@ -295,9 +295,9 @@ t
 
 在上面的程序中，要迭代的序列是字符串（字符集合）。
 
-`值`设置为字符串的第一个字符，并使用 where 条件进行检查。 如果条件返回`true`，则执行循环内的块（打印语句），并在控制台中输出“ I”。
+`value`设置为字符串的第一个字符，并使用 where 条件进行检查。 如果条件返回`true`，则执行循环内的块（打印语句），并在控制台中输出“ I”。
 
-执行该语句后，`值`更新为字符串的下一个字符，并再次检查条件。 如果条件返回`false`，则不执行该块，并且`值`更新为下一个字符。
+执行该语句后，`value`更新为字符串的下一个字符，并再次检查条件。 如果条件返回`false`，则不执行该块，并且`value`更新为下一个字符。
 
 此过程一直持续到访问字符串的最后一个字符为止。
 

docs/swift/22.md

@@ -129,7 +129,7 @@ j = 2
 
 ![labeled statement witb break](img/57eac5d60e2b33b44d0467877bcdabdf.png "How labeled statement witb break works?")
 
-在此，`标签`是标识符。 执行`break`语句时，它将终止`标签`内部的循环，程序将立即跳转到该标签后的语句。
+在此，`label`是标识符。 执行`break`语句时，它将终止`label`内部的循环，程序将立即跳转到该标签后的语句。
 
 ### 例 4：带有 break 的标记语句
 

docs/swift/23.md

@@ -128,7 +128,7 @@ i = 5
 
 ![Swift labeled statement with continue](img/b54f02ec7f4a68b1da120c7861967f48.png "How Swift labeled statement with continue works?")
 
-在此，`标签`是标识符。 当执行`continue`语句时，程序将跳过循环中其余的代码，并跳转到`标签`开始的语句。
+在此，`label`是标识符。 当执行`continue`语句时，程序将跳过循环中其余的代码，并跳转到`label`开始的语句。
 
 ### 示例 4：带有继续的标签语句
 

docs/swift/24.md

@@ -24,9 +24,9 @@ guard expression else {
 
 ```
 
-*   在这里，`表达式`是布尔表达式（返回`true`或`false`）。
-*   如果将`表达式`评估为`false`，则将执行`guard`代码块内部的语句。
-*   如果将`表达式`评估为`true`，则将跳过`guard`代码块内部的语句。
+*   在这里，`expression`是布尔表达式（返回`true`或`false`）。
+*   如果将`expression`评估为`false`，则将执行`guard`代码块内部的语句。
+*   如果将`expression`评估为`true`，则将跳过`guard`代码块内部的语句。
 
 * * *
 
@@ -133,7 +133,7 @@ When you run the above program, the output will be:
 Name is nil. Cannot process
 ```
 
-在上述程序中，您可以看到在保护声明定义的范围之外使用了未包装的值 `temp` 。 由于`名称`被定义为可选并且包含 nil 值，因此 guard 语句无法解包该值。
+在上述程序中，您可以看到在保护声明定义的范围之外使用了未包装的值 `temp` 。 由于`name`被定义为可选并且包含 nil 值，因此 guard 语句无法解包该值。
 
 因此，将执行后卫内部的语句，该语句打印**名称为 nil。 无法在输出中处理**，并使用`return`语句终止函数。 上述保护语句 if-else 语句的等效代码是：
 

docs/swift/26.md

@@ -71,7 +71,7 @@ When you run the program, the output will be:
 
 ### 示例 3：声明包含指定数量的单个重复值的数组
 
-您还可以重复给定值多次以在 Swift 中形成数组。 这是通过将数组初始化器与`重复`和`计数`一起使用来完成的。
+您还可以重复给定值多次以在 Swift 中形成数组。 这是通过将数组初始化器与`repeating`和`count`一起使用来完成的。
 
 ```swift
 let arrWithRepeatingValues = Array(repeating: "Hello, World", count: 4)
@@ -84,7 +84,7 @@ When you run the program, the output will be:
 ["Hello, World", "Hello, World", "Hello, World", "Hello, World"]
 ```
 
-在上面的程序中，我们定义了一个常量 `arrWithRepeatingValues` ，该常量存储字符串**的数组 Hello，World** ，并将相同的值重复 4 次，如`计数`中指定的那样 ]。
+在上面的程序中，我们定义了一个常量 `arrWithRepeatingValues` ，该常量存储字符串**的数组 Hello，World** ，并将相同的值重复 4 次，如`count`中指定的那样 ]。
 
 **注意：**在 Swift 中，不能像在其他编程语言中一样创建固定长度大小的数组。 固定长度大小的数组意味着，数组中的元素不能超过初始化期间定义的元素。
 

docs/swift/28.md

@@ -12,7 +12,7 @@
 
 从[设置](/swift-programming/sets "Swift Sets")开始，每个值都与唯一键相关联并将数据存储在无序列表中，即，您获得的元素顺序与在字典中定义项目的顺序不同。
 
-当您需要在集合中查找带有某些标识符的值时，可以使用字典而不是数组。 假设您可能要搜索国家的首都。 在这种情况下，您将创建一个包含键`国家`和值`首府城市`的字典。 现在，您可以通过搜索关键国家来从集合中获取首都。
+当您需要在集合中查找带有某些标识符的值时，可以使用字典而不是数组。 假设您可能要搜索国家的首都。 在这种情况下，您将创建一个键为国家和值为首府城市的字典。 现在，您可以通过搜索关键国家来从集合中获取首都。
 
 简单来说，您将键与值配对。 在上面的示例中，我们将一个国家与其首都配对。
 
@@ -67,7 +67,7 @@ When you run the program, the output will be:
 
 在上面的程序中，我们声明了一个字典，但没有明确定义类型，而是使用一些默认元素进行了初始化。
 
-元素在 key：value 对中，其中`键`的类型为`String`，`值`的类型为`Int`。 由于字典是无序列表，因此`print(someDic)`以不同于定义的顺序输出值。
+元素在 key：value 对中，其中`key`的类型为`String`，`value`的类型为`Int`。 由于字典是无序列表，因此`print(someDic)`以不同于定义的顺序输出值。
 
 * * *
 
@@ -339,6 +339,6 @@ When you run the program, the output will be:
 Not Found
 ```
 
-在上述程序中，我们在访问字典时在`默认`参数中指定了**值**。 如果键的值不存在，则返回默认值，否则返回该值。
+在上述程序中，我们在访问字典时在`default`参数中指定了**值**。 如果键的值不存在，则返回默认值，否则返回该值。
 
 在我们的例子中，键**“ nepal”** 不存在，因此程序返回 **Not Found** 。
\ No newline at end of file

docs/swift/31.md

@@ -205,7 +205,7 @@ print(msg.name)
 print("You have \(msg.coins) coins left") 
 ```
 
-在此程序中，返回类型为元组，其中包含具有该类型的变量名称。 这样的主要优点是您可以使用变量名称 `msg.name` 和 `msg.coins` 而不是 `msg.0` 和`访问结果 msg.1` 。
+在此程序中，返回类型为元组，其中包含具有该类型的变量名称。 这样的主要优点是您可以使用变量名称 `msg.name` 和 `msg.coins` 而不是访问结果 `msg.0` 和`msg.1` 。
 
 * * *
 
@@ -265,7 +265,7 @@ let result = sum(of: 2, and: 3)
 print("The sum is \(result)") 
 ```
 
-现在，方法调用是可表达的。 但是，现在我们必须使用`return of + and` 中 & `和`的参数名称`来找到两个数字的和。 现在，这使得函数体不可读。 在功能体内使用 `a` 和 `b` 代替` & `和`的`。`
+现在，方法调用是可表达的。 但是，现在我们必须在`return of + and`中使用参数名称`of`和`and`来找到两个数字的和。 现在，这使得函数体不可读。 在功能体内使用 `a` 和 `b` 代替`of`和`and`。
 
 为此，我们必须将参数标签明确定义为：
 
@@ -280,9 +280,9 @@ let result = sum(of: 2, and: 3)
 print("The sum is \(result)") 
 ```
 
-在上面的程序中，该函数接受类型为`Int`的两个参数。 函数调用使用 & `和`的参数标签`，而将函数称为`sum(of: 2, and: 3)`而不是`sum(a: 2, b: 3)`有意义。`
+在上面的程序中，该函数接受类型为`Int`的两个参数。 函数调用使用`of`和`and`的参数标签，将函数称为`sum(of: 2, and: 3)`而不是`sum(a: 2, b: 3)`有意义。
 
-另外，功能体使用参数名称 `a` 和 `b` 代替 & `和`的 `操作。`
+另外，功能体使用参数名称 `a` 和 `b` 代替`of`和`and`。
 
 您也可以通过在参数名称之前写入`_`来省略参数标签。
 
@@ -433,6 +433,6 @@ When you run the above program, the output will be:
 guest
 ```
 
-在上面的程序中，我们声明了一个函数，该函数接受`inout`参数`名称`，以便可以在函数体内更改/更改参数。
+在上面的程序中，我们声明了一个函数，该函数接受`inout`参数`name`，以便可以在函数体内更改/更改参数。
 
 在将参数传递给 in-out 参数时，必须在变量名称之前直接使用`ampersand (&)`符号，以便可以通过函数对其进行修改。
\ No newline at end of file

docs/swift/37.md

@@ -85,7 +85,7 @@ When you run the above program, the output will be:
 Hello, World!
 ```
 
-在上述程序中，闭包的类型`(String) -> ()`声明闭包接受的类型为`String`，但不返回值。您可以通过在闭包的语句中放置参数名称`来使用传递的值。 名称`，后跟`in`关键字。
+在上述程序中，闭包的类型`(String) -> ()`声明闭包接受的类型为`String`，但不返回值。您可以通过在闭包的语句中放置参数`name`，后跟`in`关键字来使用传递的值。
 
 请记住，`in`关键字的使用是将参数名称与语句分开。 由于闭包接受`String`，因此在将闭包称为`simpleClosure("Hello, World")`时需要传递字符串。 这将在闭包内部执行语句并输出**世界，您好！ 控制台中的**。
 

docs/swift/4.md

@@ -315,7 +315,7 @@ When you run the program, the output will be:
 let result:Bool = false
 ```
 
-在上面的程序中，`false`是布尔常量，它分配给常量`结果`。
+在上面的程序中，`false`是布尔常量，它分配给常量`result`。
 
 * * *
 

docs/swift/8.md

@@ -10,11 +10,11 @@
 
 功能`print(_:separator:terminator:)`接受三个参数。
 
-*   `项目：`要在控制台中打印的项目。 它可以接受多个项目。
-*   `分隔符：`在每个项目之间打印的字符串。 默认值为单个空格`(" ")`。
-*   `终止符：`在打印所有项目之后要打印的字符串。 默认值为换行符`("\n")`。
+*   `item`要在控制台中打印的项目。 它可以接受多个项目。
+*   `separator`在每个项目之间打印的字符串。 默认值为单个空格`(" ")`。
+*   `terminator`在打印所有项目之后要打印的字符串。 默认值为换行符`("\n")`。
 
-由于最后两个参数（`分隔符`，`终止符`）已指定了默认值，因此在调用打印函数时不必强制使用它们。
+由于最后两个参数（`separator`，`terminator`）已指定了默认值，因此在调用打印函数时不必强制使用它们。
 
 * * *
 
@@ -88,7 +88,7 @@ I also love Taylor Swift.
 
 ### 示例 4：使用单次打印功能打印多个项目
 
-您还可以在单​​个打印语句中打印多个项目，并在这些项目之间添加`分隔符`，如下所示：
+您还可以在单​​个打印语句中打印多个项目，并在这些项目之间添加`separator`，如下所示：
 
 ```swift
 print("Hello, World!", 2020, "See you soon", separator: ". ")
@@ -104,7 +104,7 @@ Hello, World!. 2020\. See you soon
 
 要打印的项目是字符串**您好，世界！** ，int **2020** 和字符串**很快见**。
 
-我们还在`分隔符`参数中传递了`"."`值。 这将在每个项目之间插入分隔符（点。）。 这样您就可以看到输出以分隔。 字符，后跟一个空格。
+我们还在`separator`参数中传递了`"."`值。 这将在每个项目之间插入分隔符（点。）。 这样您就可以看到输出以分隔。 字符，后跟一个空格。
 
 * * *
 
@@ -190,8 +190,8 @@ Your favorite programming language is Swift.
 
 在上述程序中，打印功能输出**。请输入您喜欢的编程语言。 调试区域中的**。 语句`let name = readLine()` 在调试区域中等待用户输入。
 
-如果键入“ Swift”并按 Enter，则`readLine`函数将该字符串分配给常量`名称`，并将输出显示为**。您最喜欢的编程语言是 Swift。**
+如果键入“ Swift”并按 Enter，则`readLine`函数将该字符串分配给常量`name`，并将输出显示为**。您最喜欢的编程语言是 Swift。**
 
-由于`readLine`函数返回一个可选字符串，因此我们已强制将常量解压缩为`名称！ `print("Your favorite programming language is \(name!)")`语句中的`。
+由于`readLine`函数返回一个可选字符串，因此我们已强制将常量解压缩为`print("Your favorite programming language is \(name!)")`语句中的`name`。
 
 您将在文章中了解有关可选的更多信息： [Swift 可选的](/swift-programming/optionals "Swift Optionals")。
\ No newline at end of file