ChildhoodAndy
@ -200,7 +200,7 @@
|
||||
|
||||
func returnFifteen() -> Int {
|
||||
var y = 10
|
||||
func add() {
|
||||
func add() {
|
||||
y += 5
|
||||
}
|
||||
add()
|
||||
@ -247,7 +247,7 @@
|
||||
|
||||
有很多种创建闭包的方法。如果一个闭包的类型已知，比如作为一个回调函数，你可以忽略参数的类型和返回值。单个语句闭包会把它语句的值当做结果返回。
|
||||
|
||||
你可以获取参数的数量——这个方法在非常短的闭包中很有用。一个被作为最后一个参数传入函数的时候可以直接出现在括号后面。
|
||||
你可以通过参数位置而不是参数名字来引用参数——这个方法在非常短的闭包中非常有用。当一个闭包作为最后一个参数传给一个函数的时候，它可以直接跟在括号后面。
|
||||
|
||||
sort([1, 5, 3, 12, 2]) { $0 > $1 }
|
||||
|
||||
@ -345,7 +345,7 @@
|
||||
triangle.perimeter = 9.9
|
||||
triangle.sideLength
|
||||
|
||||
在`perimeter`的 setter 中，新值的名字是`newValue`。你可以在`set`之后显示的设置一个名字。
|
||||
在`perimeter`的 setter 中，新值的名字是`newValue`。你可以在`set`之后显式的设置一个名字。
|
||||
|
||||
注意`EquilateralTriangle`类的构造器执行了三步：
|
||||
|
||||
|
||||
@ -80,14 +80,14 @@ Swift 是一个类型安全的语言，可选就是一个很好的例子。Swift
|
||||
let languageName = "Swift"
|
||||
languageName = "Swift++"
|
||||
// this is a compile-time error - languageName cannot be changed
|
||||
|
||||
|
||||
### 输出常量和变量
|
||||
|
||||
你可以用`println`函数来输出当前常量或变量的值:
|
||||
|
||||
println(friendlyWelcome)
|
||||
// prints "Bonjour!"
|
||||
|
||||
|
||||
`println`是一个用来输出的全局函数，输出的内容会在最后带换行。如果你用Xcode，`println`将会输出内容到“console”面板上。(另一种函数叫`print`，唯一区别是在输出内容最后不会加入换行。)
|
||||
|
||||
`println`函数输出传入的`String`值：
|
||||
@ -101,7 +101,7 @@ Swift用字符串插值（string interpolation）的方式把常量名或者变
|
||||
|
||||
println("The current value of friendlyWelcome is \(friendlyWelcome)")
|
||||
// prints "The current value of friendlyWelcome is Bonjour!
|
||||
|
||||
|
||||
> 注意：字符串插值所有可用的选项在 字符串插值 这章中讲述。
|
||||
|
||||
### 注释
|
||||
@ -115,9 +115,9 @@ Swift 中的注释与C 语言的注释非常相似。单行注释以双正斜杠
|
||||
|
||||
/* this is also a comment,
|
||||
but written over multiple lines */
|
||||
|
||||
|
||||
与C 语言多行注释不同的是，Swift 的多行注释可以嵌套在其它的多行注释之中。你可以先生成一个多行注释块，然后在这个注释块之中再嵌套成第二个多行注释。终止注释时先插入第二个注释块的终止标记，然后再插入第一个注释块的终止标记：
|
||||
|
||||
|
||||
/* this is the start of the first multiline comment
|
||||
/* this is the second, nested multiline comment */
|
||||
this is the end of the first multiline comment */
|
||||
@ -129,3 +129,162 @@ Swift 中的注释与C 语言的注释非常相似。单行注释以双正斜杠
|
||||
|
||||
let cat = "🐱"; println(cat)
|
||||
// prints "🐱"
|
||||
|
||||
|
||||
## 整数
|
||||
|
||||
整数就是没有小数部分的数字，比如`42`和`-23`。整数可以是有符号（正、负、零）或者无符号（正、零）。
|
||||
|
||||
Swift 提供了8、16、32和64位的有符号和无符号整数类型。这些整数类型和 C 语言的命名方式很像，比如8位无符号整数类型是`UInt8`，32位有符号整数类型是`Int32`。就像 Swift 的其他类型一样，整数类型采用大写命名法。
|
||||
|
||||
### 整数范围
|
||||
|
||||
你可以访问不同整数类型的`min`和`max`属性来获取对应类型的最大值和最小值：
|
||||
|
||||
let minValue = UInt8.min // minValue 为 0，是 UInt8 类型的最小值
|
||||
let maxValue = UInt8.max // maxValue 为 255，是 UInt8 类型的最大值
|
||||
|
||||
### Int
|
||||
|
||||
一般来说，你不需要专门指定整数的长度。Swift 提供了一个特殊的整数类型`Int`，长度与当前平台的原生字长相同：
|
||||
|
||||
* 在32位平台上，`Int`和`Int32`长度相同。
|
||||
* 在64位平台上，`Int`和`Int64`长度相同。
|
||||
|
||||
除非你需要特定长度的整数，一般来说使用`Int`就够了。这可以提高代码一致性和可复用性。即使是在32位平台上，`Int`可以存储的整数范围也可以达到`-2147483648`~`2147483647`，大多数时候这已经足够大了。
|
||||
|
||||
### UInt
|
||||
|
||||
Swift 也提供了一个特殊的无符号类型`UInt`，长度与当前平台的原生字长相同：
|
||||
|
||||
* 在32位平台上，`UInt`和`UInt32`长度相同。
|
||||
* 在64位平台上，`UInt`和`UInt64`长度相同。
|
||||
|
||||
> 注意：尽量不要使用`UInt`，除非你真的需要存储一个和当前平台原生字长相同的无符号整数。除了这种情况，最好使用`Int`，即使你要存储的值已知是非负的。统一使用`Int`可以提高代码的可复用性，避免不同类型数字之间的转换，并且匹配数字的类型推测，详情参见[类型安全和类型推测](## 类型安全和类型推测)。
|
||||
|
||||
## 浮点数
|
||||
|
||||
浮点数是有小数部分的数字，比如`3.14159`，`0.1`和`-273.15`。
|
||||
|
||||
浮点类型比整数类型表示的范围更大，可以存储比`Int`类型更大或者更小的数字。Swift 提供了两种有符号浮点数类型：
|
||||
|
||||
* `Double`表示64位浮点数。当你需要存储很大或者很高精度的浮点数时请使用此类型。
|
||||
* `Float`表示32位浮点数。精度要求不高的话可以使用此类型。
|
||||
|
||||
> 注意：`Double`精确度很高，至少有15位数字，而`Float`最少只有6位数字。选择哪个类型取决于你的代码需要处理的数字大小。
|
||||
|
||||
## 类型安全和类型推测
|
||||
|
||||
Swift 是一个类型安全的语言。类型安全的语言可以让你清楚地知道代码要处理的值的类型。如果你的代码需要一个`String`，你绝对不可能不小心传进去一个`Int`。
|
||||
|
||||
Swift 是类型安全的，会在编译你的代码时进行类型检查，如果遇到不匹配的类型会报错。这可以让你在开发的时候尽早发现并修复错误。
|
||||
|
||||
当你要处理不同类型的值时，类型检查可以帮你避免错误。然而，这并不是说你每次声明常量和变量的时候都需要显式指定类型。如果你没有显式指定类型，Swift 会使用类型推测来选择合适的类型。有了类型推测，编译器可以在编译代码的时候自动推测出表达式的类型。原理很简单，判断你赋的值即可。
|
||||
|
||||
因为有类型推测，和 C 或者 Objc 比起来 Swift 很少需要声明类型。常量和变量虽然需要明确类型，但是大部分工作并不需要你自己来完成。
|
||||
|
||||
当你声明常量或者变量并赋初值的时候类型推测非常有用。当你在声明常量或者变量的时候赋给它们一个原始值即可触发类型推测。（原始值就是会直接出现在你代码中的值，比如`42`和`3.14159`。）
|
||||
|
||||
举个例子，如果你给一个新常量赋值`42`并且没有标明类型，Swift 可以推测出常量类型是`Int`，因为你给它赋的初值看起来很像一个整数：
|
||||
|
||||
let meaningOfLife = 42
|
||||
// meaningOfLife 会被推测为 Int 类型
|
||||
|
||||
同理，如果你没有给浮点原始值标明类型，Swift 会推测你想要的是`Double`：
|
||||
|
||||
let pi = 3.14159
|
||||
// pi 会被推测为 Double 类型
|
||||
|
||||
当推测浮点数的类型时，Swift 总是会选择`Double`而不是`Float`。
|
||||
|
||||
如果表达式中同时出现了整数和浮点数，会被推测为`Double`类型：
|
||||
|
||||
let anotherPi = 3 + 0.14159
|
||||
// anotherPi 会被推测为 Double 类型
|
||||
|
||||
原始值`3`没有显式声明类型，而表达式中出现了一个浮点原始值，所以表达式会被推测为`Double`类型。
|
||||
|
||||
## 数值类原始值
|
||||
|
||||
整数原始值可以被写作：
|
||||
|
||||
* 一个十进制数，没有前缀
|
||||
* 一个二进制数，前缀是`0b`
|
||||
* 一个八进制数，前缀是`0o`
|
||||
* 一个十六进制数，前缀是`0x`
|
||||
|
||||
下面的所有整数原始值的十进制值都是`17`:
|
||||
|
||||
let decimalInteger = 17
|
||||
let binaryInteger = 0b10001 // 二进制的17
|
||||
let octalInteger = 0o21 // 八进制的17
|
||||
let hexadecimalInteger = 0x11 // 十六机制的17
|
||||
|
||||
浮点原始值可以是十进制（没有前缀）或者是十六进制（前缀是`0x`）。小数点两边必须有至少一个十进制数字（或者是十六进制的数字）。浮点原始值还有一个可选的指数，在十进制浮点数中通过大写或者小写的`e`来指定，在十六进制浮点数中通过大写或者小写的`p`来指定。
|
||||
|
||||
如果一个十进制数的指数为`exp`，那这个数相当于基数和10^exp的乘积：
|
||||
* 1.25e2 表示 1.25 × 10^2，等于 125.0。
|
||||
* 1.25e-2 表示 1.25 × 10^-2，等于 0.0125。
|
||||
|
||||
如果一个十六进制数的指数为`exp`，那这个数相当于基数和2^exp的乘积：
|
||||
* 0xFp2 表示 15 × 2^2，等于 60.0。
|
||||
* 0xFp-2 表示 15 × 2^-2，等于 3.75。
|
||||
|
||||
下面的这些浮点原始值都等于十进制的`12.1875`：
|
||||
|
||||
let decimalDouble = 12.1875
|
||||
let exponentDouble = 1.21875e1
|
||||
let hexadecimalDouble = 0xC.3p0
|
||||
|
||||
数值类原始值可以包括额外的格式来增强可读性。整数和浮点数都可以添加额外的零并且包含下划线，并不会影响原始值：
|
||||
|
||||
let paddedDouble = 000123.456
|
||||
let oneMillion = 1_000_000
|
||||
let justOverOneMillion = 1_000_000.000_000_1
|
||||
|
||||
## 数值类型转换
|
||||
|
||||
通常来讲，即使代码中的整数常量和变量已知非负，也请使用`Int`类型。总是使用默认的整数类型可以保证你的整数常量和变量可以直接被复用并且可以匹配整数类原始值的类型推测。
|
||||
只有在必要的时候才使用其他整数类型，比如要处理外部的长度明确的数据或者为了优化性能、内存占用等等。使用显式指定长度的类型可以及时发现值溢出并且可以暗示正在处理特殊数据。
|
||||
|
||||
### 整数转换
|
||||
|
||||
不同整数类型的变量和常量可以存储不同大小的数字。`Int8`类型的常量或者变量可以存储的数字范围是`-128`~`127`，`UInt8`类型的常量或者变量能存储的数字范围是`0`~`255`。如果数字超出了常量或者变量可存储的范围，编译的时候会报错：
|
||||
|
||||
let cannotBeNegative: UInt8 = -1
|
||||
// UInt8 类型不能存储负数，所以会报错
|
||||
let tooBig: Int8 = Int8.max + 1
|
||||
// Int8 类型不能存储超过最大值的数，所以会报错
|
||||
|
||||
因为每一个整数类型都可以存储不同范围的值，你必须根据情况来选择不同的转换方法。不同的转换方法可以暴露出隐藏的转换错误并让你的代码更加清晰。
|
||||
|
||||
要将一种数字类型转换成另一种，你要用当前值来初始化一个新数字，这个数字的类型就是你的目标类型。在下面的例子中，常量`twoThousand`类型是`UInt16`，然而常量`one`类型是`Uint8`。它们不能直接相加，因为它们类型不同。所以要调用`UInt16(one)`来创建一个新的`UInt16`数字并用`one`的值来初始化，然后使用这个新数字来计算：
|
||||
|
||||
let twoThousand: UInt16 = 2_000
|
||||
let one: UInt8 = 1
|
||||
let twoThousandAndOne = twoThousand + UInt16(one)
|
||||
|
||||
现在两个数字的类型都是`UInt16`，可以进行相加。目标常量`twoThousandAndOne`的类型被推测为`UInt16`，因为它是两个`UInt16`值的合。
|
||||
|
||||
`SomeType(ofInitialValue)`是调用 Swift 构造器并传入一个初始值的默认方法。在语言内部，`UInt16`有一个构造器，可以接受一个`UInt8`类型的值，所以这个构造器可以用现有的`UInt8`来创建一个新的`UInt16`。注意，你并不能传入任意类型的值，只能传入`UInt16`内部有对应构造器的值。不过你可以扩展现有的类型来让它可以接收其他类型的值（包括自定义类型），详情参见`扩展(链接待添加)`.
|
||||
|
||||
### 整数和浮点数转换
|
||||
|
||||
整数和浮点数的转换必须显式指定类型：
|
||||
|
||||
let three = 3
|
||||
let pointOneFourOneFiveNine = 0.14159
|
||||
let pi = Double(three) + pointOneFourOneFiveNine
|
||||
// pi 等于 3.14159，所以被推测为 Double 类型
|
||||
|
||||
这个例子中，常量`three`的值被用来创建一个`Double`类型的值，所以加号两边的数类型相同。如果不进行转换，两者无法相加。
|
||||
|
||||
浮点数转换为整数也一样，整数类型可以用`Double`或者`Float`类型来初始化：
|
||||
|
||||
let integerPi = Int(pi)
|
||||
// integerPi 等于 3，所以被推测为 Int 类型
|
||||
|
||||
当用这种方式来初始化一个新的整数值时，浮点值会被截断。也就是说`4.75`会变成`4`，`-3.9`会变成`3`。
|
||||
|
||||
> 注意：结合数字类常量和变量不同于结合数字类原始值。原始值`3`可以直接和原始值`0.14159`相加，因为数字原始值本身没有明确的类型。它们的类型只在编译器需要求值的时候被推测。
|
||||
|
||||
|
||||
@ -1,22 +1,30 @@
|
||||
# 字符串和字符 (Strings and Characters)
|
||||
|
||||
**String** 是一个有序的字符集合，例如 "hello, world", "albatross"。Swift 字符串通过 **String** 类型来表示，也可以表示为 **Character** 类型值的集合。
|
||||
**String** 是一个有序的字符集合，例如 "hello, world", "albatross"。
|
||||
Swift 字符串通过 **String** 类型来表示，也可以表示为 **Character** 类型值的集合。
|
||||
|
||||
Swift 的 **String** 和 **Character** 类型提供了一个快速的，兼容 Unicode 的方式来处理代码中的文本信息。创建和操作字符串的语法与 C的操作方式相似，轻量并且易读。字符串连接操作只需要简单地通过 `+` 号将两个字符串相连即可。与 Swift 中其他值一样，能否更改字符串的值，取决于其被定义为常量还是变量。
|
||||
Swift 的 **String** 和 **Character** 类型提供了一个快速的，兼容 Unicode 的方式来处理代码中的文本信息。
|
||||
创建和操作字符串的语法与 C的操作方式相似，轻量并且易读。
|
||||
字符串连接操作只需要简单地通过 `+` 号将两个字符串相连即可。
|
||||
与 Swift 中其他值一样，能否更改字符串的值，取决于其被定义为常量还是变量。
|
||||
|
||||
尽管语法简易，但 **String** 类型是一种快速、现代化的字符串实现。每一个字符串都是由独立编码的 Unicode 字符组成，并提供了用于访问这些字符在不同的Unicode表示的支持。
|
||||
尽管语法简易，但 **String** 类型是一种快速、现代化的字符串实现。
|
||||
每一个字符串都是由独立编码的 Unicode 字符组成，并提供了用于访问这些字符在不同的Unicode表示的支持。
|
||||
|
||||
**String** 也可以用于在常量、变量、字面量和表达式中进行字符串插值，这使得创建用于展示、存储和打印的字符串变得轻松自如。
|
||||
|
||||
> 注意：
|
||||
>
|
||||
> Swift 的 **String** 类型与 Foundation NSString 类进行了无缝桥接。如果您利用 Cocoa 或 Cocoa Touch 中的 Foundation 框架进行工作，整个 NSString API 都可以调用您创建的任意 String 类型的值，您额外还可以在任意 API 中使用本章介绍的 **String** 特性。您也可以在任意要求传入NSString 实例作为参数的 API 中使用 **String** 类型的值进行替换。
|
||||
> Swift 的 **String** 类型与 Foundation NSString 类进行了无缝桥接。
|
||||
> 如果您利用 Cocoa 或 Cocoa Touch 中的 Foundation 框架进行工作，整个 NSString API 都可以调用您创建的任意 String 类型的值，您额外还可以在任意 API 中使用本章介绍的 **String** 特性。
|
||||
> 您也可以在任意要求传入NSString 实例作为参数的 API 中使用 **String** 类型的值进行替换。
|
||||
>
|
||||
>更多关于在 Foundation 和 Cocoa 中使用 **String** 的信息请查看 [Using Swift with Cocoa and Objective-C](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216)。
|
||||
|
||||
### 字符串字面量
|
||||
|
||||
您可以在您的代码中包含一段预定义的字符串值作为字符串字面量。字符串字面量是由双引号包裹着的具有固定顺序的文本字符集。
|
||||
您可以在您的代码中包含一段预定义的字符串值作为字符串字面量。
|
||||
字符串字面量是由双引号包裹着的具有固定顺序的文本字符集。
|
||||
|
||||
字符串字面量可以用于为常量和变量提供初始值。
|
||||
|
||||
@ -49,7 +57,8 @@ let sparklingHeart = "\U0001F496" // 💖, Unicode scalar U+1F496
|
||||
|
||||
### 初始化空字符串
|
||||
|
||||
为了构造一个很长的字符串，可以创建一个空字符串作为初始值。可以将空的字符串字面量赋值给变量，也可以初始化一个新的 **String** 实例：
|
||||
为了构造一个很长的字符串，可以创建一个空字符串作为初始值。
|
||||
可以将空的字符串字面量赋值给变量，也可以初始化一个新的 **String** 实例：
|
||||
|
||||
```
|
||||
var emptyString = "" // empty string literal
|
||||
@ -85,19 +94,25 @@ constantString += " and another Highlander"
|
||||
|
||||
### 字符串是值类型
|
||||
|
||||
Swift 的 **String** 类型是值类型。如果您创建了一个新的字符串，那么当其进行常量、变量赋值操作或在函数/方法中传递时，会进行值拷贝。任何情况下，都会对已有字符串值创建新副本，并对该新副本进行传递或赋值。值类型在 [Structures and Enumerations Are Value Types](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ClassesAndStructures.html#//apple_ref/doc/uid/TP40014097-CH13-XID_104) 中进行了说明。
|
||||
Swift 的 **String** 类型是值类型。
|
||||
如果您创建了一个新的字符串，那么当其进行常量、变量赋值操作或在函数/方法中传递时，会进行值拷贝。
|
||||
任何情况下，都会对已有字符串值创建新副本，并对该新副本进行传递或赋值。
|
||||
值类型在 [Structures and Enumerations Are Value Types](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ClassesAndStructures.html#//apple_ref/doc/uid/TP40014097-CH13-XID_104) 中进行了说明。
|
||||
|
||||
> 注意：
|
||||
>
|
||||
> 其 Cocoa 中的 NSString 不同，当您在 Cocoa 中创建了一个 NSString 实例，并将其传递给一个函数/方法，或者赋值给一个变量，您永远都是传递或赋值同一个 NSString 实例的一个引用。除非您特别要求其进行值拷贝，否则字符串不会进行赋值新副本操作。
|
||||
> 与 Cocoa 中的 NSString 不同，当您在 Cocoa 中创建了一个 NSString 实例，并将其传递给一个函数/方法，或者赋值给一个变量，您永远都是传递或赋值同一个 NSString 实例的一个引用，除非您特别要求其进行值拷贝，否则字符串不会进行赋值新副本操作。
|
||||
|
||||
Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字符串的值，其明确了无论该值来自于哪里，都是您独自拥有的。您可以放心您传递的字符串本身不会被更改。
|
||||
Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字符串的值，其明确了无论该值来自于哪里，都是您独自拥有的。
|
||||
您可以放心您传递的字符串本身不会被更改。
|
||||
|
||||
在实际编译时，Swift编译器会优化字符串的使用，使实际的复制只发生在绝对必要的情况下，这意味着您始终可以将字符串作为值类型的同时获得极高的性能。
|
||||
|
||||
#### 使用字符(Characters)
|
||||
|
||||
Swift 的 **String** 类型表示特定序列的字符值的集合。每一个字符值代表一个 Unicode 字符。您可利用 for-in 循环来遍历字符串中的每一个字符：
|
||||
Swift 的 **String** 类型表示特定序列的字符值的集合。
|
||||
每一个字符值代表一个 Unicode 字符。
|
||||
您可利用 for-in 循环来遍历字符串中的每一个字符：
|
||||
|
||||
```
|
||||
for character in "Dog!🐶" {
|
||||
@ -128,11 +143,16 @@ println("unusualMenagerie has \(countElements(unusualMenagerie)) characters")
|
||||
// prints "unusualMenagerie has 40 characters"
|
||||
```
|
||||
|
||||
>注意：
|
||||
> 注意：
|
||||
>
|
||||
>不同的 Unicode 字符以及相同 Unicode 字符的不同表示方式可能需要不同数量的内存空间来存储，所以Swift 中的字符在一个字符串中并不一定占用相同的内存空间。因此，字符串的长度不得不通过迭代字符串中每一个字符的长度来进行计算。如果您正在处理一个长字符串，需要注意 `countElements` 函数必须遍历字符串中的字符以精准计算字符串的长度。
|
||||
> 不同的 Unicode 字符以及相同 Unicode 字符的不同表示方式可能需要不同数量的内存空间来存储。
|
||||
> 所以Swift 中的字符在一个字符串中并不一定占用相同的内存空间。
|
||||
> 因此字符串的长度不得不通过迭代字符串中每一个字符的长度来进行计算。
|
||||
> 如果您正在处理一个长字符串，需要注意 `countElements` 函数必须遍历字符串中的字符以精准计算字符串的长度。
|
||||
>
|
||||
>另外需要注意的是通过 `countElements` 返回的字符数量并不总是与包含相同字符的 NSString 的 `length` 属性相同。NSString 的 `length` 属性是基于利用 UTF-16 表示的十六位代码单元数字，而不是基于 Unicode 字符。为了解决这个问题，NSString 的 `length` 属性在被 Swift的 **String** 访问时会成为 `utf16count`。
|
||||
> 另外需要注意的是通过 `countElements` 返回的字符数量并不总是与包含相同字符的 NSString 的 `length` 属性相同。
|
||||
> NSString 的 `length` 属性是基于利用 UTF-16 表示的十六位代码单元数字，而不是基于 Unicode 字符。
|
||||
> 为了解决这个问题，NSString 的 `length` 属性在被 Swift的 **String** 访问时会成为 `utf16count`。
|
||||
|
||||
### 连接字符串和字符
|
||||
|
||||
@ -168,7 +188,8 @@ welcome += character1
|
||||
|
||||
### 字符串插值
|
||||
|
||||
字符串插值是一种全新的构建字符串的方式，可以在其中包含常量、变量、字面量和表达式。您插入的字符串字面量的每一项都被包裹在以反斜线为前缀的圆括号中：
|
||||
字符串插值是一种全新的构建字符串的方式，可以在其中包含常量、变量、字面量和表达式。
|
||||
您插入的字符串字面量的每一项都被包裹在以反斜线为前缀的圆括号中：
|
||||
|
||||
```
|
||||
let multiplier = 3
|
||||
@ -176,9 +197,12 @@ let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"
|
||||
// message is "3 times 2.5 is 7.5"
|
||||
```
|
||||
|
||||
在上面的例子中，`multiplier` 作为 `\(multiplier)` 被插入到一个字符串字面量中。当创建字符串执行插值计算时此占位符会被替换为 `multiplier` 实际的值。
|
||||
在上面的例子中，`multiplier` 作为 `\(multiplier)` 被插入到一个字符串字面量中。
|
||||
当创建字符串执行插值计算时此占位符会被替换为 `multiplier` 实际的值。
|
||||
|
||||
`multiplier` 的值也作为字符串中后面表达式的一部分。该表达式计算 `Double(multiplier) * 2.5` 的值并将结果 (7.5) 插入到字符串中。在这个例子中，表达式写为 `\(Double(multiplier) * 2.5)` 并包含在字符串字面量中。
|
||||
`multiplier` 的值也作为字符串中后面表达式的一部分。
|
||||
该表达式计算 `Double(multiplier) * 2.5` 的值并将结果 (7.5) 插入到字符串中。
|
||||
在这个例子中，表达式写为 `\(Double(multiplier) * 2.5)` 并包含在字符串字面量中。
|
||||
|
||||
>注意：
|
||||
>
|
||||
@ -203,7 +227,9 @@ if quotation == sameQuotation {
|
||||
|
||||
##### 前缀/后缀相等
|
||||
|
||||
通过调用字符串的 `hasPrefix`/`hasSuffix` 方法来检查字符串是否拥有特定前缀/后缀。两个方法均需要以字符串作为参数传入并传出 **Boolean** 值。两个方法均执行基本字符串和前缀/后缀字符串之间逐个字符的比较操作。
|
||||
通过调用字符串的 `hasPrefix`/`hasSuffix` 方法来检查字符串是否拥有特定前缀/后缀。
|
||||
两个方法均需要以字符串作为参数传入并传出 **Boolean** 值。
|
||||
两个方法均执行基本字符串和前缀/后缀字符串之间逐个字符的比较操作。
|
||||
|
||||
下面的例子以一个字符串数组表示莎士比亚话剧 `罗密欧与朱丽叶` 中前两场的场景位置：
|
||||
|
||||
@ -250,13 +276,15 @@ let whispered = normal.lowercaseString
|
||||
|
||||
### Unicode
|
||||
|
||||
Unicode 是文本编码和表示的国际标准。它使您可以用标准格式表示来自任意语言几乎所有的字符，并能够对文本文件或网页这样的外部资源中的字符进行读写操作。
|
||||
Unicode 是文本编码和表示的国际标准。
|
||||
它使您可以用标准格式表示来自任意语言几乎所有的字符，并能够对文本文件或网页这样的外部资源中的字符进行读写操作。
|
||||
|
||||
Swift 的字符串和字符类型是完全兼容 Unicode 的，它支持如下所述的一系列不同的 Unicode 编码。
|
||||
|
||||
###### Unicode 术语(Terminology)
|
||||
|
||||
Unicode 中每一个字符都可以被解释为一个或多个 unicode 标量。字符的 unicode 标量是一个唯一的21位数字(和名称)，例如 `U+0061` 表示小写的拉丁字母A ("a")，`U+1F425` 表示正面站立的鸡宝宝 ("🐥")
|
||||
Unicode 中每一个字符都可以被解释为一个或多个 unicode 标量。
|
||||
字符的 unicode 标量是一个唯一的21位数字(和名称)，例如 `U+0061` 表示小写的拉丁字母A ("a")，`U+1F425` 表示小幺鸡表情 ("🐥")
|
||||
|
||||
当 Unicode 字符串被写进文本文件或其他存储结构当中，这些 unicode 标量将会按照 Unicode 定义的集中格式之一进行编码。其包括 `UTF-8` (以8位代码单元进行编码) 和 `UTF-16` (以16位代码单元进行编码)。
|
||||
|
||||
@ -264,7 +292,8 @@ Unicode 中每一个字符都可以被解释为一个或多个 unicode 标量。
|
||||
|
||||
Swift 提供了几种不同的方式来访问字符串的 Unicode 表示。
|
||||
|
||||
您可以利用 `for-in` 来对字符串进行遍历，从而以 Unicode 字符的方式访问每一个字符值。该过程在 [Working with Characters](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/StringsAndCharacters.html#//apple_ref/doc/uid/TP40014097-CH7-XID_376) 中进行了描述。
|
||||
您可以利用 `for-in` 来对字符串进行遍历，从而以 Unicode 字符的方式访问每一个字符值。
|
||||
该过程在 [Working with Characters](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/StringsAndCharacters.html#//apple_ref/doc/uid/TP40014097-CH7-XID_376) 中进行了描述。
|
||||
|
||||
另外，能够以其他三种 Unicode 兼容的方式访问字符串的值：
|
||||
|
||||
@ -280,7 +309,8 @@ let dogString = "Dog!🐶"
|
||||
|
||||
##### UTF-8
|
||||
|
||||
您可以通过遍历字符串的 `utf8` 属性来访问它的 `UTF-8` 表示。其为 **UTF8View** 类型的属性，**UTF8View** 是无符号8位 (`UInt8`) 值的集合，每一个 `UIn8` 都是一个字符的 UTF-8 表示：
|
||||
您可以通过遍历字符串的 `utf8` 属性来访问它的 `UTF-8` 表示。
|
||||
其为 **UTF8View** 类型的属性，**UTF8View** 是无符号8位 (`UInt8`) 值的集合，每一个 `UIn8` 都是一个字符的 UTF-8 表示：
|
||||
|
||||
```
|
||||
for codeUnit in dogString.utf8 {
|
||||
@ -290,11 +320,13 @@ print("\n")
|
||||
// 68 111 103 33 240 159 144 182
|
||||
```
|
||||
|
||||
上面的例子中，前四个10进制代码单元值 (68, 111, 103, 33) 代表了字符 `D` `o` `g` 和 `!` ，他们的 UTF-8 表示与 ASCII 表示相同。后四个代码单元值 (240, 159, 144, 182) 是 `狗脸表情` 的4位 UTF-8 表示。
|
||||
上面的例子中，前四个10进制代码单元值 (68, 111, 103, 33) 代表了字符 `D` `o` `g` 和 `!` ，他们的 UTF-8 表示与 ASCII 表示相同。
|
||||
后四个代码单元值 (240, 159, 144, 182) 是 `狗脸表情` 的4位 UTF-8 表示。
|
||||
|
||||
##### UTF-16
|
||||
|
||||
您可以通过遍历字符串的 `utf16` 属性来访问它的 `UTF-16` 表示。其为 **UTF16View** 类型的属性，**UTF16View** 是无符号16位 (`UInt16`) 值的集合，每一个 `UInt16` 都是一个字符的 UTF-16 表示：
|
||||
您可以通过遍历字符串的 `utf16` 属性来访问它的 `UTF-16` 表示。
|
||||
其为 **UTF16View** 类型的属性，**UTF16View** 是无符号16位 (`UInt16`) 值的集合，每一个 `UInt16` 都是一个字符的 UTF-16 表示：
|
||||
|
||||
```
|
||||
for codeUnit in dogString.utf16 {
|
||||
@ -306,11 +338,14 @@ print("\n")
|
||||
|
||||
同样，前四个代码单元值 (68, 111, 103, 33) 代表了字符 `D` `o` `g` 和 `!` ，他们的 UTF-16 代码单元和 UTF-8 完全相同。
|
||||
|
||||
第五和第六个代码单元值 (55357 and 56374) 是 `狗脸表情` 字符的UTF-16 表示。第一个值为 `U+D83D` (十进制值为 55357)，第二个值为 `U+DC36` (十进制值为 56374)。
|
||||
第五和第六个代码单元值 (55357 and 56374) 是 `狗脸表情` 字符的UTF-16 表示。
|
||||
第一个值为 `U+D83D` (十进制值为 55357)，第二个值为 `U+DC36` (十进制值为 56374)。
|
||||
|
||||
##### Unicode 标量 (Scalars)
|
||||
|
||||
您可以通过遍历字符串的 `unicodeScalars` 属性来访问它的 Unicode 标量表示。其为 **UnicodeScalarView** 类型的属性， **UnicodeScalarView** 是 `UnicodeScalar` 的集合。`UnicodeScalar` 是21位的 Unicode 代码点。
|
||||
您可以通过遍历字符串的 `unicodeScalars` 属性来访问它的 Unicode 标量表示。
|
||||
其为 **UnicodeScalarView** 类型的属性， **UnicodeScalarView** 是 `UnicodeScalar` 的集合。
|
||||
`UnicodeScalar` 是21位的 Unicode 代码点。
|
||||
|
||||
每一个 `UnicodeScalar` 拥有一个值属性，可以返回对应的21位数值，用 `UInt32` 来表示。
|
||||
|
||||
@ -322,7 +357,9 @@ print("\n")
|
||||
// 68 111 103 33 128054
|
||||
```
|
||||
|
||||
同样，前四个代码单元值 (68, 111, 103, 33) 代表了字符 `D` `o` `g` 和 `!` 。第五位数值，128054，是一个十六进制1F436的十进制表示。其等同于 `狗脸表情` 的Unicode 标量 U+1F436。
|
||||
同样，前四个代码单元值 (68, 111, 103, 33) 代表了字符 `D` `o` `g` 和 `!` 。
|
||||
第五位数值，128054，是一个十六进制1F436的十进制表示。
|
||||
其等同于 `狗脸表情` 的Unicode 标量 U+1F436。
|
||||
|
||||
作为查询字符值属性的一种替代方法，每个 `UnicodeScalar` 值也可以用来构建一个新的字符串值，比如在字符串插值中使用：
|
||||
|
||||
|
||||
@ -0,0 +1,358 @@
|
||||
# 闭包
|
||||
|
||||
闭包是功能性自包含模块，可以在代码中被传递和使用。
|
||||
Swift 中的闭包与 C 和 Objective-C 中的 `blocks` 以及其他一些编程语言中的 `lambdas` 比较相似。
|
||||
|
||||
闭包可以 **捕获** 和存储其所在上下文中任意常量和变量的引用。
|
||||
这就是所谓的闭合并包裹着这些常量和变量，俗称闭包。Swift 会为您管理在 **捕获** 过程中涉及到的内存操作。
|
||||
|
||||
> 注意：
|
||||
>
|
||||
> 如果您不熟悉 **捕获** (capturing) 这个概念也不用担心，后面会详细对其进行介绍。
|
||||
|
||||
在 `函数` 章节中介绍的全局和嵌套函数实际上也是特殊的闭包，闭包采取如下三种形式之一：
|
||||
|
||||
* 全局函数是一个有名字但不会捕获任何值的闭包
|
||||
* 嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
|
||||
* 闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的没有名字的闭包
|
||||
|
||||
Swift 的闭包表达式拥有简洁的风格，并鼓励在常见场景中进行语法优化，主要优化如下：
|
||||
|
||||
* 利用上下文推断参数和返回值类型
|
||||
* 单表达式闭包可以省略 `return` 关键字
|
||||
* 参数名称缩写
|
||||
* Trailing 闭包语法
|
||||
|
||||
### 闭包表达式
|
||||
|
||||
嵌套函数是一个在较复杂函数中方便进行命名和定义自包含代码模块的方式。
|
||||
当然，有时候撰写小巧的没有完整定义和命名的类函数结构也是很有用处的，尤其是在您处理一些函数并需要将另外一些函数作为该函数的参数时。
|
||||
|
||||
闭包表达式是一种利用简洁语法构建内联闭包的方式。
|
||||
闭包表达式提供了一些语法优化，使得撰写闭包变得简单明了。
|
||||
下面闭包表达式的例子通过使用几次迭代展示了 `sort` 函数定义和语法优化的方式。
|
||||
每一次迭代都用更简洁的方式描述了相同的功能。
|
||||
|
||||
##### `sort` 函数
|
||||
|
||||
Swift 标准库提供了 `sort` 函数，会根据您提供的排序闭包将已知类型数组中的值进行排序。
|
||||
一旦排序完成，函数会返回一个与原数组大小相同的新数组，该数组中包含已经正确排序的同类型元素。
|
||||
|
||||
下面的闭包表达式示例使用 `sort` 函数对一个 **String** 类型的数组进行字母逆序排序，以下是初始数组值：
|
||||
|
||||
```
|
||||
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
|
||||
```
|
||||
|
||||
该例子对一个 **String** 类型的数组进行排序，因此排序闭包需为 `(String, String) -> Bool` 类型的函数。
|
||||
|
||||
提供排序闭包的一种方式是撰写一个符合其类型要求的普通函数，并将其作为 `sort` 函数的第二个参数传入：
|
||||
|
||||
```
|
||||
func backwards(s1: String, s2: String) -> Bool {
|
||||
return s1 > s2
|
||||
}
|
||||
var reversed = sort(names, backwards)
|
||||
// reversed is equal to ["Ewa", "Daniella", "Chris", "Barry", "Alex"]
|
||||
```
|
||||
|
||||
如果第一个字符串 (s1) 大于第二个字符串 (s2)，`backwards` 函数则返回 `true`，表示在新的数组中 s1 应该出现在 s2 前。
|
||||
字符中的 "大于" 表示 "按照字母顺序后出现"。
|
||||
这意味着字母 "B" 大于字母 "A", 字符串 "Tom" 大于字符串 "Tim"。
|
||||
其将进行字母逆序排序，"Barry" 将会排在 "Alex" 之后。
|
||||
|
||||
然而，这是一个相当冗长的方式，本质上只是写了一个单表达式函数 (a > b)。
|
||||
在下面的例子中，利用闭合表达式语法可以更好的构造一个内联排序闭包。
|
||||
|
||||
##### 闭包表达式语法
|
||||
|
||||
闭包表达式语法有如下一般形式：
|
||||
|
||||
```
|
||||
{ (parameters) -> returnType in
|
||||
statements
|
||||
}
|
||||
```
|
||||
|
||||
闭包表达式语法可以使用常量、变量和 `inout` 类型作为参数，不提供默认值。
|
||||
也可以在参数列表的最后使用可变参数。元组也可以作为参数和返回值。
|
||||
|
||||
下面的例子展示了之前 `backwards` 函数对应的闭包表达式版本的代码：
|
||||
|
||||
```
|
||||
reversed = sort(names, { (s1: String, s2: String) -> Bool in
|
||||
return s1 > s2
|
||||
})
|
||||
```
|
||||
|
||||
需要注意的是内联闭包参数和返回值类型声明与 `backwards` 函数类型声明相同。
|
||||
在这两种方式中，都写成了 (s1: String, s2: String) -> Bool。
|
||||
然而在内联闭包表达式中，函数和返回值类型都写在大括号内，而不是大括号外。
|
||||
|
||||
闭包的函数体部分由关键字 `in` 引入。
|
||||
该关键字表示闭包的参数和返回值类型定义已经完成，闭包函数体即将开始。
|
||||
|
||||
因为这个闭包的函数体部分如此短以至于可以将其改写成一行代码：
|
||||
|
||||
```
|
||||
reversed = sort(names, { (s1: String, s2: String) -> Bool in return s1 > s2 } )
|
||||
```
|
||||
|
||||
这说明 `sort` 函数的整体调用保持不变，一对圆括号仍然包裹住了函数中整个参数集合。而其中一个参数现在变成了内联闭包 (相比于 `backwards` 版本的代码)。
|
||||
|
||||
##### 根据上下文推断类型
|
||||
|
||||
因为排序闭包是作为函数的参数进行传入的，Swift可以推断其参数和返回值的类型。
|
||||
`sort` 期望第二个参数是类型为 `(String, String) -> Bool` 的函数，因此实际上 `String`, `String` 和 `Bool` 类型并不需要作为闭包表达式定义中的一部分。
|
||||
因为所有的类型都可以被正确推断，返回箭头 (->) 和 围绕在参数周围的括号也可以被省略：
|
||||
|
||||
```
|
||||
reversed = sort(names, { s1, s2 in return s1 > s2 } )
|
||||
```
|
||||
|
||||
实际上任何情况下，通过内联闭包表达式构造的闭包作为参数传递给函数时，都可以推断出闭包的参数和返回值类型，这意味着您几乎不需要利用完整格式构造任何内联闭包。
|
||||
|
||||
##### 单行表达式闭包可以省略 `return`
|
||||
|
||||
单行表达式闭包可以通过隐藏 `return` 关键字来隐式返回单行表达式的结果，如上版本的例子可以改写为：
|
||||
|
||||
```
|
||||
reversed = sort(names, { s1, s2 in s1 > s2 } )
|
||||
```
|
||||
|
||||
在这个例子中，`sort` 函数的第二个参数函数类型明确了闭包必须返回一个 **Bool** 类型值。
|
||||
因为闭包函数体只包含了一个单一表达式 (s1 > s2)，该表达式返回 **Bool** 类型值，因此这里没有歧义，`return`关键字可以省略。
|
||||
|
||||
##### 参数名称缩写
|
||||
|
||||
Swift 自动为内联函数提供了参数名称缩写功能，您可以直接通过 `$0`,`$1`,`$2` 来顺序调用闭包的参数。
|
||||
|
||||
如果您在闭包表达式中使用参数名称缩写，您可以在闭包参数列表中省略对其的定义，并且对应参数名称缩写的类型会通过函数类型进行推断。
|
||||
`in` 关键字也同样可以被省略，因为此时闭包表达式完全由闭包函数体构成：
|
||||
|
||||
```
|
||||
reversed = sort(names, { $0 > $1 } )
|
||||
```
|
||||
|
||||
在这个例子中，`$0` 和 `$1` 表示闭包中第一个和第二个 **String** 类型的参数。
|
||||
|
||||
##### 运算符函数
|
||||
|
||||
实际上还有一种更简短的方式来撰写上面例子中的闭包表达式。
|
||||
Swift 的 **String** 类型定义了关于大于号 (>) 的字符串实现，其作为一个函数接受两个 **String** 类型的参数并返回 **Bool** 类型的值。
|
||||
而这正好与 `sort` 函数的第二个参数需要的函数类型相符合。
|
||||
因此，您可以简单地传递一个大于号，Swift可以自动推断出您想使用大于号的字符串函数实现：
|
||||
|
||||
```
|
||||
reversed = sort(names, >)
|
||||
```
|
||||
|
||||
更多关于运算符表达式的内容请查看 [Operator Functions](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_43) 。
|
||||
|
||||
### Trailing 闭包
|
||||
|
||||
如果您需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用 trailing 闭包来增强函数的可读性。
|
||||
Trailing 闭包是一个书写在函数括号之外(之后)的闭包表达式，函数支持将其作为最后一个参数调用。
|
||||
|
||||
```
|
||||
func someFunctionThatTakesAClosure(closure: () -> ()) {
|
||||
// 函数体部分
|
||||
}
|
||||
|
||||
// 以下是不使用 trailing 闭包进行函数调用
|
||||
|
||||
someFunctionThatTakesAClosure({
|
||||
// 闭包主体部分
|
||||
})
|
||||
|
||||
// 以下是使用 trailing 闭包进行函数调用
|
||||
|
||||
someFunctionThatTakesAClosure() {
|
||||
// 闭包主体部分
|
||||
}
|
||||
```
|
||||
> 注意：
|
||||
>
|
||||
> 如果函数只需要闭包表达式一个参数，当您使用 trailing 闭包时，您甚至可以把 () 省略掉。
|
||||
NOTE
|
||||
|
||||
在上例中作为 `sort` 函数参数的字符串排序闭包可以改写为：
|
||||
|
||||
```
|
||||
reversed = sort(names) { $0 > $1 }
|
||||
```
|
||||
|
||||
当闭包非常长以至于不能在一行中进行书写时，Trailing 闭包变得非常有用。
|
||||
举例来说，Swift 的 **Array** 类型有一个 `map` 方法，其获取一个闭包表达式作为其唯一参数。
|
||||
数组中的每一个元素调用一次该闭包函数，并返回该元素所映射的值(也可以是不同类型的值)。
|
||||
具体的映射方式和返回值类型由闭包来指定。
|
||||
|
||||
当提供给数组闭包函数后，`map` 方法将返回一个新的数组，数组中包含了与原数组一一对应的映射后的值。
|
||||
|
||||
下例介绍了如何在 `map` 方法中使用 trailing 闭包将 **Int** 类型数组 `[16,58,510]` 转换为包含对应 **String** 类型的数组 `["OneSix", "FiveEight", "FiveOneZero"]`:
|
||||
|
||||
```
|
||||
let digitNames = [
|
||||
0: "Zero", 1: "One", 2: "Two", 3: "Three", 4: "Four",
|
||||
5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine"
|
||||
]
|
||||
let numbers = [16, 58, 510]
|
||||
```
|
||||
|
||||
如上代码创建了一个数字位和他们名字映射的英文版本字典。
|
||||
同时定义了一个准备转换为字符串的整型数组。
|
||||
|
||||
您现在可以通过传递一个 trailing 闭包给 `numbers` 的 `map` 方法来创建对应的字符串版本数组。
|
||||
需要注意的时调用 `numbers.map` 不需要在 `map` 后面包含任何括号，因为其只需要传递闭包表达式这一个参数，并且该闭包表达式参数通过 trailing 方式进行撰写：
|
||||
|
||||
```
|
||||
let strings = numbers.map {
|
||||
(var number) -> String in
|
||||
var output = ""
|
||||
while number > 0 {
|
||||
output = digitNames[number % 10]! + output
|
||||
number /= 10
|
||||
}
|
||||
return output
|
||||
}
|
||||
// strings 常量被推断为字符串类型数组，即 String[]
|
||||
// 其值为 ["OneSix", "FiveEight", "FiveOneZero"]
|
||||
```
|
||||
|
||||
`map` 在数组中为每一个元素调用了闭包表达式。
|
||||
您不需要指定闭包的输入参数 `number` 的类型，因为可以通过要映射的数组类型进行推断。
|
||||
|
||||
闭包 `number` 参数被声明为一个变量参数 (变量的具体描述请参看[Constant and Variable Parameters](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Functions.html#//apple_ref/doc/uid/TP40014097-CH10-XID_224))，因此可以在闭包函数体内对其进行修改。
|
||||
闭包表达式制定了返回类型为 **String**，以表明存储映射值的新数组类型为 **String**。
|
||||
|
||||
闭包表达式在每次被调用的时候创建了一个字符串并返回。
|
||||
其使用求余运算符 (number % 10) 计算最后一位数字并利用 `digitNames` 字典获取所映射的字符串。
|
||||
|
||||
> 注意：
|
||||
>
|
||||
> 字典 `digitNames` 下标后跟着一个叹号 (!)，因为字典下标返回一个可选值 (optional value)，表明即使该 key 不存在也不会查找失败。
|
||||
> 在上例中，它保证了 `number % 10` 可以总是作为一个 `digitNames` 字典的有效下标 key。
|
||||
> 因此叹号可以用于强制展开 (force-unwrap) 存储在可选下标项中的 **String** 类型值。
|
||||
|
||||
从 `digitNames` 字典中获取的字符串被添加到输出的前部，逆序建立了一个字符串版本的数字。
|
||||
(在表达式 `number % 10`中，如果number为16，则返回6，58返回8，510返回0)。
|
||||
|
||||
`number` 变量之后除以10。
|
||||
因为其是整数，在计算过程中未除尽部分被忽略。
|
||||
因此 16变成了1，58变成了5，510变成了51。
|
||||
|
||||
整个过程重复进行，直到 `number /= 10` 为0，这时闭包会将字符串输出，而map函数则会将字符串添加到所映射的数组中。
|
||||
|
||||
上例中 trailing 闭包语法在函数后整洁封装了具体的闭包功能，而不再需要将整个闭包包裹在 `map` 函数的括号内。
|
||||
|
||||
### 捕获 (Caputure)
|
||||
|
||||
闭包可以在其定义的上下文中捕获常量或变量。
|
||||
即使定义这些常量和变量的原域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。
|
||||
|
||||
Swift最简单的闭包形式是嵌套函数，也就是定义在其他函数的函数体内的函数。
|
||||
嵌套函数可以捕获其外部函数所有的参数以及定义的常量和变量。
|
||||
|
||||
下例为一个叫做 `makeIncrementor` 的函数，其包含了一个叫做 `incrementor` 嵌套函数。
|
||||
嵌套函数 `incrementor` 从上下文中捕获了两个值，`runningTotal` 和 `amount`。
|
||||
之后 `makeIncrementor` 将 `incrementor` 作为闭包返回。
|
||||
每次调用 `incrementor` 时，其会以 `amount` 作为增量增加 `runningTotal` 的值。
|
||||
|
||||
```
|
||||
func makeIncrementor(forIncrement amount: Int) -> () -> Int {
|
||||
var runningTotal = 0
|
||||
func incrementor() -> Int {
|
||||
runningTotal += amount
|
||||
return runningTotal
|
||||
}
|
||||
return incrementor
|
||||
}
|
||||
```
|
||||
|
||||
`makeIncrementor` 返回类型为 `() -> Int`。
|
||||
这意味着其返回的是一个函数，而不是一个简单类型值。
|
||||
该函数在每次调用时不接受参数只返回一个 **Int** 类型的值。
|
||||
关于函数返回其他函数的内容，请查看[Function Types as Return Types](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Functions.html#//apple_ref/doc/uid/TP40014097-CH10-XID_232)。
|
||||
|
||||
`makeIncrementor` 函数定义了一个整型变量 `runningTotal` (初始为0) 用来存储当前跑步总数。
|
||||
该值通过 `incrementor` 返回。
|
||||
|
||||
`makeIncrementor` 有一个 **Int** 类型的参数，其外部命名为 `forIncrement`， 内部命名为 `amount`，表示每次 `incrementor` 被调用时 `runningTotal` 将要增加的量。
|
||||
|
||||
`incrementor` 函数用来执行实际的增加操作。
|
||||
该函数简单地使 `runningTotal` 增加 `amount`，并将其返回。
|
||||
|
||||
如果我们单独看这个函数，会发现看上去不同寻常：
|
||||
|
||||
```
|
||||
func incrementor() -> Int {
|
||||
runningTotal += amount
|
||||
return runningTotal
|
||||
}
|
||||
```
|
||||
|
||||
`incrementor` 函数并没有获取任何参数，但是在函数体内访问了 `runningTotal` 和 `amount` 变量。这是因为其通过捕获在包含它的函数体内已经存在的 `runningTotal` 和 `amount` 变量而实现。
|
||||
|
||||
由于没有修改 `amount` 变量，`incrementor` 实际上捕获并存储了该变量的一个副本，而该副本随着 `incrementor` 一同被存储。
|
||||
|
||||
然而，因为每次调用该函数的时候都会修改 `runningTotal` 的值，`incrementor` 捕获了当前 `runningTotal` 变量的引用，而不是仅仅复制该变量的初始值。捕获一个引用保证了当 `makeIncrementor` 结束时候并不会消失，也保证了当下一次执行 `incrementor` 函数时，`runningTotal` 可以继续增加。
|
||||
|
||||
> 注意：
|
||||
>
|
||||
> Swift 会决定捕获引用还是拷贝值。
|
||||
> 您不需要标注 `amount` 或者 `runningTotal` 来声明在嵌入的 `incrementor` 函数中的使用方式。
|
||||
> Swift 同时也处理 `runingTotal` 变量的内存管理操作，如果不再被 `incrementor` 函数使用，则会被清除。
|
||||
|
||||
下面为一个使用 `makeIncrementor` 的例子：
|
||||
|
||||
```
|
||||
let incrementByTen = makeIncrementor(forIncrement: 10)
|
||||
```
|
||||
|
||||
该例子定义了一个叫做 `incrementByTen` 的常量，该常量指向一个每次调用会加10的 `incrementor` 函数。
|
||||
调用这个函数多次可以得到以下结果：
|
||||
|
||||
```
|
||||
incrementByTen()
|
||||
// 返回的值为10
|
||||
incrementByTen()
|
||||
// 返回的值为20
|
||||
incrementByTen()
|
||||
// 返回的值为30
|
||||
```
|
||||
|
||||
如果您创建了另一个 `incrementor`，其会有一个属于自己的独立的 `runningTotal` 变量的引用。
|
||||
下面的例子中，`incrementBySevne` 捕获了一个新的 `runningTotal` 变量，该变量和 `incrementByTen` 中捕获的变量没有任何联系：
|
||||
|
||||
```
|
||||
let incrementBySeven = makeIncrementor(forIncrement: 7)
|
||||
incrementBySeven()
|
||||
// 返回的值为7
|
||||
incrementByTen()
|
||||
// 返回的值为40
|
||||
```
|
||||
|
||||
> 注意：
|
||||
>
|
||||
> 如果您闭包分配给一个类实例的属性，并且该闭包通过指向该实例或其成员来捕获了该实例，您将创建一个在闭包和实例间的强引用环。
|
||||
> Swift 使用捕获列表来打破这种强引用环。更多信息，请参考 [Strong Reference Cycles for Closures](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AutomaticReferenceCounting.html#//apple_ref/doc/uid/TP40014097-CH20-XID_61)。
|
||||
|
||||
### 闭包是引用类型
|
||||
|
||||
上面的例子中，`incrementBySeven` 和 `incrementByTen` 是常量，但是这些常量指向的闭包仍然可以增加其捕获的变量值。
|
||||
这是因为函数和闭包都是引用类型。
|
||||
|
||||
无论您将函数/闭包赋值给一个常量还是变量，您实际上都是将常量/变量的值设置为对应函数/闭包的引用。
|
||||
上面的例子中，`incrementByTen` 指向闭包的引用是一个常量，而并非闭包内容本身。
|
||||
|
||||
这也意味着如果您将闭包赋值给了两个不同的常量/变量，两个值都会指向同一个闭包：
|
||||
|
||||
```
|
||||
let alsoIncrementByTen = incrementByTen
|
||||
alsoIncrementByTen()
|
||||
// 返回的值为50
|
||||
```
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -0,0 +1,21 @@
|
||||
# 自动引用计数
|
||||
|
||||
Swift使用自动引用计数(ARC)这一机制来跟踪和管理你的应用程序的内存。通常情况下，Swift的内存管理机制会一直起着作用，你无须自己来考虑内存的管理。ARC会在类的实例不再被使用时，自动释放其占用的内存。
|
||||
|
||||
然而，在少数情况下，ARC为了能帮助你管理内存，需要更多的关于你的代码之间关系的信息。本章描述了这些情况，并且为你示范怎样启用ARC来管理你的应用程序的内存。
|
||||
|
||||
> 注意: 引用计数仅仅应用于类的实例。结构体和枚举类型是值类型，不是引用类型，也不是通过引用的方式存储和传递。
|
||||
|
||||
## 自动引用计数的工作机制
|
||||
|
||||
当你每次创建一个类的新的实例的时候，ARC会分配一大块内存用来储存实例的信息。内存中会包含实例的类型信息，以及这个实例所有相关属性的值。此外，当实例不再被使用时，ARC释放实例所占用的内存，并让释放的内存能挪作他用。这确保了不再被使用的实例，不会一直占用内存空间。
|
||||
|
||||
然而，当ARC收回和释放了正在被使用中的实例，该实例的属性和方法将不能再被访问和调用。实际上，如果你试图访问这个实例，你的应用程序很可能会崩溃。
|
||||
|
||||
为了确保使用中的实例不会被回收，ARC会跟踪和计算每一个类实例正在被多少属性，常量和变量所引用。哪怕实例的引用数为一，ARC都不会回收这个实例。
|
||||
|
||||
为了使之成为可能，无论你将类实例赋值给属性，常量或者是变量，属性，常量或者变量，都会对此实例创建强引用。之所以称之为强引用，是因为它会将实例牢牢的保持住，只要强引用还在，实例是不允许被释放的。
|
||||
|
||||
## 自动引用计数实践
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user