Merge branch 'JaySurplus-gh-pages' into gh-pages

2014-06-11 14:45:36 +08:00
parent cea562cbc4 f97bac29e5
commit e10674fc68
2 changed files with 373 additions and 308 deletions
--- a/ObjectiveC/02Interoperability/01Interacting
+++ b/ObjectiveC/02Interoperability/01Interacting
@ -1,318 +1,29 @@
--- [@haolloyin](https://github.com/haolloyin) 翻译自苹果官方文档 [Using Swift with Cocoa and Objective-C](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/MixandMatch.html#//apple_ref/doc/uid/TP40014216-CH10-XID_75) 的 [Interacting with Objective-C APIs](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/InteractingWithObjective-CAPIs.html) 章节
+# 时间点
 6.3 项目发布 第一天仅有50Star
 6.4 开始有人关注 300+Star
 6.5~6.6 翻译工作开始步入正轨
 6.7~6.8 翻译速度一般 
 6.9~6.11 建立QQ群 翻译速度加快 完成翻译 初步校对
 6.12 发布
-## Interacting with Objective-C APIs - 与 Objc API 交互
+# 发起原因
-Swift 和 Objc 之间双向的`互用性`（`Interoperability`），让你可以用一种语言访问另一种语言写的代码。当你开始整合 Swift 代码到应用的开发工作流时，可以很好地理解这种互用性在重新定义，改善并强化你写 Cocoa 应用的方式。
+最初其实没想到会做成这样，只是想着既然Swift这么火，我也想学一学，不如顺便翻译一下，也算是为大家做点贡献。
-互用性一个很重要的方面是在写 Swift 代码的同时可以用 Objc API。导入 Objc framework 之后，你可以用 Swift 原生的语法来实例化类，并和它们进行交互。
+# 如何组织开源翻译
-### Initialization - 初始化
+## 让新手也能参与
 你可以用 Swift 语法调用 Objc 类的初始化方法，在 Swift 代码中进行 Objc 类的实例化。因为 Objc 的初始化方法都迁移到 Swift 了。`init` 前缀被去掉并成为关键字表示一个方法是初始化方法。以 `initWith` 开头的初始化方法中的 `With` 也被去掉了。从 `init` 或 `initWith` 中切分出来首字母变成小写，并且作为第一个参数名，该 selector 的其他部分也同样变成参数名。selector 括号内的各部分也是调用端
 例如 Objc 中这么写：
-```
+## 传达信息
 // OBJECTIVE-C
 UITableView *myTableView = [[UITableView alloc] initWithFrame:CGRectZero style:UITableViewStyleGrouped];
 ```
 Swift 中则这么写：
 ```
 // SWIFT
 let myTableView: UITableView = UITableView(frame: CGRectZero, style: .Grouped)
 ```
 不需要调用 `alloc`，Swift 会为你正确处理。**注意调用 Swift 初始化方法时不应该再出现 `init` 字眼。**
 初始化时你可以显式指明变量的类型，也可以忽略不写，Swift 的类型推导会确定对象的类型。
 ```
 // SWIFT
 let myTextField = UITextField(frame: CGRect(0.0, 0.0, 200.0, 40.0))
 ```
 `UITableView` 和 `UITextField` 拥有和 Objc 类似的方法，可以像在 Objc 代码中那样使用它们来访问在类中定义的属性或方法。
 为了一致性和简单性，Objc 的工厂方法在 Swift 中以方便的初始化方法出现，这种映射方法使它们和初始化方法一样简洁明了。例如你在 Objc 中这么调用工厂方法：
 ```
 // OBJECTIVE-C
 UIColor *color = [UIColor colorWithRed:0.5 green:0.0 blue:0.5 alpha:1.0];
 ```
 在 Swift 中这么调用：
 ```
 // SWIFT
 let color = UIColor(red: 0.5, green: 0.0, blue: 0.5, alpha: 1.0)
 ```
 ### Accessing Properties - 属性访问
 在 Swift 中用点语法来访问、设置属性。
 ```
 // SWIFT
 myTextField.textColor = UIColor.darkGrayColor()
 myTextField.text = "Hello world"
 if myTextField.editing {
    myTextField.editing = false
 }
 ```
 当获取或设置属性时，直接用属性名，不需要括号。注意 `darkGrayColor` 是 `UIColor` 中的方法，不是属性，因此带有括号。
 在 Objc 中返回一个值并且不带参数的方法，可以看作隐式的属性访问器，并用和访问属性一样的语法来调用。这在 Swift 中很简单，只有在 Objc 中用 `@property` 语法声明的属性才会被看作属性。方法的导入、调用详见 [Working with Methods](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/InteractingWithObjective-CAPIs.html#//apple_ref/doc/uid/TP40014216-CH4-XID_29)。
 ### Working with Methods - 方法调用
 在 Swift 中调用 Obc 方法时，使用点语法。
 因为 Objc 的方法都迁移到 Swift，方法名的第一部分作为基本的方法名，并出现在小括号左边。第一个实参写在小括号里面，并且不需要参数名；方法名的其余部分与实参相应写在小括号里面。方法名的所有部分在调用端都是必须的。
 例如 Objc 中这样调用：
 ```
 // OBJECTIVE-C
 [myTableView insertSubview:mySubview atIndex:2];
 ```
 在 Swift 中这样调用：
 ```
 // SWIFT
 myTableView.insertSubview(mySubview, atIndex: 2)
 ```
 如果调用的方法不带参数，你还是需要写上括号。
 ```
 // SWIFT
 myTableView.layoutIfNeeded()
 ```
 ### id Compatibility - 兼容 id
 Swift 包含一个叫做 `AnyObject` 的协议类型来表示任意一种对象，就像 Objc `id` 一样。`AnyObject` 协议允许你在写类型安全的 Swift 代码的同时，保留无类型（`untyped`）对象的灵活性。正由于 `AnyObjcet` 协议提供的安全性，Swift 用 `AnyObject` 替代 `id`。
 像 `id` 一样，你可以把任何类类型的对象赋值（assign）给用 `AnyObject` 声明的常量或变量，也可以把变量重新赋值到不同类型的对象。
 ```
 // SWIFT
 var myObject: AnyObject = UITableViewCell()
 myObject = NSDate()
 ```
 也可以不经过类型转换来调用 Objc 的方法或访问属性（后赋值给常量），但必须是 Objc 中用 `@objc attribute` 标记过的兼容方法。
 ```
 // SWIFT
 let futureDate = myObject.dateByAddingTimeInterval(10)
 let timeSinceNow = myObject.timeIntervalSinceNow
 ```
 然而因为 `AnyObject` 对象只有到运行时才确定其真实类型，这很可能写出不安全的代码。另外对比 Objc ，如果你调用（或访问） `AnyObject` 对象不存在的方法（或属性），这会导致运行时错误。例如下面的代码会编译通过，但是在运行时引发 `unrecognized selector error`：
 ```
 // SWIFT
 myObject.characterAtIndex(5)
 // crash, myObject does't respond to that method
 ```
 但是，你可以在代码中用 Swift 中的`可选值`（`optional`）来消除这种常见的 Objc error。当你在一个 `AnyObject` 类型的对象上调用一个 Objc 方法时，事实上跟`可选值隐式拆包`（`implicitly unwrapped optional`）很类似。你可以用跟可选协议中的方法相同的`可选链`（`optional chaining`）语法来调用 `AnyObject` 对象的方法。这对属性也同样适用。
 例如下面的代码，第1~2行将不会执行，因为 `NSDate` 对象不存在 `length` 属性和 `characterAtIndex:` 方法。常量 `myLength` 将会被推断为可选整型（`optional Int`），并且赋值为 `nil`。你也可以用 `if-let` 语句来尝试性地拆包方法调用的结果，因为对象调用的方法可能不存在（not respond to），正如下面第3行所示：
 ```
 // SWIFT
 let myLength = myObject.length?
 let myChar = myObject.characterAtIndex?(5)
 if let fifthCharacter = myObject.characterAtIndex(5) {
    println("Found \(fifthCharacter) at index 5")
 }
 ```
 > 译注：关于可选链（`Optional Chain`），建议读下官方教程的 [Optional Chaining](https://github.com/CocoaChina-editors/Welcome-to-Swift/blob/master/The%20Swift%20Programming%20Language/02Language%20Guide/17Optional%20Chaining.md) 和这篇 “[Swift之 ? 和 !](http://joeyio.com/ios/2014/06/04/swift---/)”。
 和 Swfit 中所有向下转型（`downcast`）一样，从 `AnyObject` 转型为具体对象类型是不保证成功的，因此会返回可选值（`optional value`），你可以通过检测可选值来确定转型是否成功。
 ```
 // SWIFT
 let userDefaults = NSUserDefaults.standardUserDefaults()
 let lastRefreshDate: AnyObject? = userDefaults.objectForKey("LastRefreshDate")
 if let date = lastRefreshDate as? NSDate {
    println("\(date.timeIntervalSinceReferenceDate)")
 }
 ```
 Of course, if you are certain of the type of the object (and know that it is not nil), you can force the invocation with the as operator.
 当然如果你确定一个对象的类型（并且对象不为 `nil`），你可以把它作为操作数强行调用。
 ```
 // SWIFT
 let myDate = lastRefreshDate as NSDate
 let timeInterval = myDate.timeIntervalSinceReferenceDate
 ```
 ### Working with nil - 关于 nil
 Objc 用原始指针（可能为 `NULL`，即 Objc 中的 `nil`）来指向对象。Swift 中的所有值（包括结构体，对象引用）都是非空的（`non-nil`）。作为替代，可以用一个`可选类型`（`optional type`）来表示一个值，尽管在封包过程中可能会丢失这个值。当值丢失时，得到的是 `nil`。阅读 [Optional](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5) 来了解更多。
 **由于 Objc 没有确保对象非空（`non-nil`），Swift 在将 Objc API 导入时，将所有实参类型和返回类型都改成可选类型。当你使用 Objc 对象时，应该先检查它是否为 `nil`。**
 在某些情况下，你可能100%确定一个 Objc 方法或属性不会返回 `nil` 对象引用。为了在这些情景下更方便地使用对象，Swift 引入了叫做`隐式拆包可选值`（`implicitly unwrapped optionals`）的类型，它包含所有可选类型的安全特性。另外，你可以直接访问它的值，不用判断是否为 `nil`或者将它拆包。当你在未经过安全拆包之前访问这种可选类型的值时，隐式拆包可选值会检查值是否已经丢失，如果已经丢失，会发生运行时错误。因此，你应该总是自行检查或拆包一个`隐式拆包可选值`，除非你确定这个值没有丢失。
 ### Extensions - 扩展
 Swift 的扩展（`extension`）类似于 Objc 的类别（`category`），`extension` 给 Swift 现有的类，结构体，枚举，增加行为，也适用于 Objc 中定义的类、结构体和枚举。你可以给一个类型定义一个 `extension`，不管这个类型来自系统 framework 还是你自定义的类型。简单地导入对应的模块，用你在 Objc 中那样用相同的名字引用类，结构体和枚举。
 例如你可以用等边三角型来扩展 `UIBezierPath` 类，基于你提供的边长和起始点创建一个简单的 Bézier 路径。
 ```
 // SWIFT
 extension UIBezierPath {
    convenience init(triangleSideLength: Float, origin: CGPoint) {
        self.init()
        let squareRoot = Float(sqrt(3))
        let altitude = (squareRoot * triangleSideLength) / 2
        moveToPoint(origin)
        addLineToPoint(CGPoint(triangleSideLength, origin.x))
        addLineToPoint(CGPoint(triangleSideLength / 2, altitude))
        closePath()
    }
 }
 ```
 可以用 `extension` 添加属性（包括类属性，静态属性），但是这些**属性必须进行计算；`extension` 并不能给类型，结构体，枚举添加存储属性（`stored property`）。**
 下面的例子扩展了 `CGRect` 结构体，使之拥有一个计算 `area` 的属性：
 ```
 // SWIFT
 extension CGRect {
    var area: CGFloat {
    return width * height
    }
 }
 let rect = CGRect(x: 0.0, y: 0.0, width: 10.0, height: 50.0)
 let area = rect.area
 // area: CGFloat = 500.0
 ```
 也可以用 `extension` 给类添加协议（`protocol conformance`）而无需继承这个类。如果是 Swift 中定义的协议，你可以将它添加到结构体或者枚举，不管这个结构体或枚举是来自 Swift 还是 Objc。
 **不能用 `extension` 对 Objc 类型现有的方法或属性进行重载（`override`）。**
 ### Closures - 闭包
 Objective-C blocks are automatically imported as Swift closures. For example, here is an Objective-C block variable:
 Objc 的 `block` 被自动导入为 Swift 的闭包（`closure`）。例如下面的 Objc block 变量：
 ```
 // OBJECTIVE-C
 void (^completionBlock)(NSData *, NSError *) = ^(NSData *data, NSError *error) {
    /* ... */
 }
 ```
 在 Swift 中看起来是这样的：
 ```
 // SWIFT
 let completionBlock: (NSData, NSError) -> Void = { data, error in 
    /* ... */
 }
 ```
 Swift 的闭包和 Objc 的 block 是兼容的，所以你可以将 Swift 的闭包作为实参传给 Objc 中期望传入 block 的方法。Swift 的闭包和函数是相同的类型，所以你甚至可以传递 Swift 的函数名。
 闭包拥有和 block 相似的捕获语义（`capture semantic`），但是有一个关键的不同之处：变量是可变的而不是拷贝一个副本。换句话说，Swift 中闭包的变量默认等同于 Objc 中用 `__block` 修饰的变量。
 ### Object Comparison - 对象比较
 Swift 中比较两个对象有两种不同的方式。一种是相等（`equality ==`），比较两个对象的内容；另一种是全等（`identity ===`），比较两个常量或变量是否指向同一个的对象实例。
 Swift 和 Objc 对象在 Swift 中一般用 `==` 和 `===` 操作符进行比较。Swift 为继承自 `NSObject` 类的对象提供了 `==` 操作符的默认实现，即 Swift 会调用 `NSObject` 类定义的 `isEqual:` 方法。`NSObject` 类只会判断是否全等（`identity comparison`，即是否指向同一实例），所以你应该自己实现 `NSObject` 子类的 `isEqual:` 方法。由于你可以传递 Swift 对心爱难过（包括那些没有继承自 `NSObject` 类的类对象）给 Objc API，你应该实现 `isEqual:` 方法，以便 Objc API 可以判断两个对象的内容是否相同，而不是判断是否指向同一个实例。
 作为类对象判等的一部分，确保根据对象比较的规则来实现 `hash` 属性。进一步说，如果你想用你的类对象作为字典的 key，你还要实现 `Hashable` 协议的 `hashValue` 属性。
 ### Swift Type Compatibility - Swift 类型兼容性
 当你在 Swift 中定义一个类继承自 `NSObject` 类或其他任意 Objc 类时，这个类自动与 Objc 兼容。这些步骤由 Swift 编译器为你完成。如果你不打算将一个 Swift 类导入到 Objc，那么你不用担心类型兼容相关的问题。另外，如果你的 Swift 类没有继承自 Objc 的类，并且你将会在 Objc 代码中使用，那么可以用 `@objc` 来修饰它。
 `@objc attribute` 使你的 Swift API 在 Objc 与其运行时中可用。换句话说，你可以用 `@objc` 来修饰任何你想在 Objc 使用的 Swift 类，方法，属性。如果你的 Swift 类继承自 Objc 的类，编译器会自动给 Swift 类插入 `@objc`。编译器也会自动为类的所有方法和属性添加 `@objc`，只要这个类用 `@objc` 修饰了。当你用 `@IBOutlet` `@IBAction` `@NSManaged` 时，`@objc` 也会被自动加上。`@objc` 在你用 Objc 类的 `selector` 实现 `target-action` 设计模式这一类工作时很有用，例如 `NSTimer` 和 `UIButton`。
 当你在 Objc 中使用 Swift API，编译器通常直接翻译。例如 Swift API `func playSong(name: String)` 会被导入 Objc 变成 `- (void)playSong:(NSString *)name`。但是有一个例外：当你在 Objc 中使用 Swift 初始化方法时，编译器为你在方法名最前面添加 `initWith` 字样，并且适当地将原来初始化方法的首字母大写。例如，Swift 的初始化方法 ` init (songName: String, artist: String)` 会被导入 Objc 变成 `(instancetype)initWithSongName:(NSString *)songName artist:(NSString *)artist`。
 Swift 也提供一个 `@objc` 的变型类允许你指定 Objc 的符号名（`symbol`）。例如，如果你的 Swift 类名含有 Objc 不支持的字符，你可以指定一个替代名以便在 Objc 中使用。如果你想为 Swift 函数提供一个 Objc 名称，应该使用 Objc 的 `selector` 语法，要记得为 `selector` 的每一部分加上分号（`:`）。
 ```
 // SWIFT
@objc(Squirrel)
 class Белка {
    @objc(initWithName:)
    init (имя: String) { /*...*/ }
    @objc(hideNuts:inTree:)
    func прячьОрехи(Int, вДереве: Дерево) { /*...*/ }
 }
 ```
 当你给 Swift 类使用 `@objc(<#name#>)` 时，这个类可以在 Objc 中使用，并且不需要任何命名空间。因此 `@objc(<#name#>)` 在你迁移可存档的（`archivable`） Objc 类到 Swift 时很有用，因为被存档的（`archived`）对象在存档中保存了它们的类名，你在 Objc 类中应该用 `@objc(<#name#>)` 来指定同样的名字，使得旧的存档可以在你新的 Swift 类中反存档（`unarchived`）。
 ### Objective-C Selectors
 Objc 的 `selector` 是一种指向 Objc 方法名的类型。在 Swift 中，Objc 的 `selector` 相应地用 `Selector` 结构体表示。你可以用 string 字面量来构造一个 Swift 的 `Selector`，例如：`let mySelector: Selector = "tappedButton:"`。由于 string 字面量会自动转化为 `selector`，因此你可以传递一个 string 字面量给任何接受 `selector` 作为参数的方法。
 ```
 // SWIFT
 import UIKit
 class MyViewController: UIViewController {
    let myButton = UIButton(frame: CGRect(x: 0, y: 0, width: 100, height: 50))
    init(nibName nibNameOrNil: String!, bundle nibBundleOrNil: NSBundle!) {
        super.init(nibName: nibName, bundle: nibBundle)
        myButton.targetForAction("tappedButton:", withSender: self)
    }
    func tappedButton(sender: UIButton!) {
        println("tapped button")
    }
 }
 ```
 > **注意**
 > 
 > **`performSelector:` 方法和其他与方法调用（`selector-invoking`）相关的方法没有被迁移到 Swift，因为他们固有的不安全性。**
 如果你的 Swift 类继承自 Objc 的类，那么这个类的所有方法和属性都是对 Objc `selector` 可见的。反之，如果 Swift 类没有继承自 Objc 类，你需要加上 `@objc` 修饰符，使得它们成为 Objc 中可用的 `selector`，详见前面的 [Swift Type Compatibility](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/InteractingWithObjective-CAPIs.html#//apple_ref/doc/uid/TP40014216-CH4-XID_36) 一节。
 由于开源翻译的参与者地点、时间都不统一，不可能组织大家开会，所以如何让每个人都明确知道项目的相关信息。
 要传达的信息包括：
 - 项目进度，比如哪些章节已翻译，哪些已认领，哪些已完成
 - 不同阶段时间点，比如哪天要翻译完成，哪天要校对完成
 - 如何领取
 - 下一阶段目标
--- a/source/chapter2/09_Classes_and_Structures.md
+++ b/source/chapter2/09_Classes_and_Structures.md
@ -7,3 +7,357 @@
 -   类是引用类型
 -   类和结构体的选择
 -   集合（collection）类型的赋值与复制行为
 类和结构体是人们构建代码所用的一种通用且灵活的构造体。为了在类和结构体中实现各种功能，我们必须要严格按照对于常量，变量以及函数所规定的语法规则来定义属性和添加方法。
 与其他编程语言所不同的是，Swift 并不要求你为自定义类和结构去创建独立的接口和实现文件。你所要做的是在一个单一文件中定义一个类或者结构体，系统将会自动生成面向其它代码的外部接口。
 > 通常一个`类`的实例被称为`对象`。然而在Swift 中，类和结构体的关系要比在其他语言中更加的密切，本章中所讨论的大部分功能都可以用在类和结构体上。因此，我们会主要使用`实例`而不是`对象`。
 ### 类和结构体对比
 Swift 中类和结构体有很多共同点。共同处在于：
 * 	定义属性用于储存值
 * 	定义方法用于提供功能
 * 	定义下标用于通过下标语法访问值
 * 	定义初始化器用于生成初始化值
 * 	通过扩展以增加默认实现的功能
 * 	符合协议以对某类提供标准功能
 更多信息请参见 [属性](http://)，[方法](http://)，[下标](http://)，[初始化](http://)，[扩展](http://)，和[协议](http://)。
 与结构体相比，类还有如下的附加功能：
 * 继承允许一个类继承另一个类的特征
 * 类型转换允许在运行时检查和解释一个类实例的类型
 * 取消初始化器允许一个类实例释放任何其所被分配的资源
 * 引用计数允许对一个类的多次引用
 更多信息请参见[继承](http://)，[类型转换](http://)，[初始化](http://)，和[自动引用计数](http://)。
 >结构体总是通过被复制的方式在代码中传递，因此请不要使用引用计数。
 ### 定义
 类和结构体有着类似的定义方式。我们通过关键字`class`和`struct`来分别表示类和结构体，并在一对大括号中定义它们的具体内容：
 	class SomeClass {
 		// class definition goes here
 	}
 	struct SomeStructure {
 		// structure definition goes here
 	}
 > 在你每次定义一个新类或者结构体的时候，实际上你是有效地定义了一个新的Swift 类型。因此请使用 `UpperCamelCase` 这种方式来命名（如 `SomeClass` 和`SomeStructure`等），以便符合标准Swift 类型的大写命名风格（如`String`，`Int`和`Bool`）。相反的，请使用`lowerCamelCase`这种方式为属性和方法命名（如`framerate`和`incrementCount`），以便和类区分。
 以下是定义结构体和定义类的示例：
 	struct Resolution {
 		var width = 0
 		var heigth = 0
 	}
 	class VideoMode {
 		var resolution = Resolution()
 		var interlaced = false
 		var frameRate = 0.0
 		var name: String?
 	}
 在上面的示例中我们定义了一个名为`Resolution`的结构体，用来描述一个显示器的像素分辨率。这个结构体包含了两个名为`width`和`height`的储存属性。储存属性是捆绑和储存在类或结构体中的常量或变量。当这两个属性被初始化为整数`0`的时候，它们会被推断为`Int`类型。
 在上面的示例中我们还定义了一个名为`VideoMode`的类，用来描述一个视频显示器的特定模式。这个类包含了四个储存属性变量。第一个是`分辨率`，它被初始化为一个新的`Resolution`结构体的实例，具有`Resolution`的属性类型。新`VideoMode`实例同时还会初始化其它三个属性，它们分别是，初始值为`false`(意为“non-interlaced video”)的`inteflaced`，回放帧率初始值为`0.0`的`frameRate`和值为可选`String`的`name`。`name`属性会被自动赋予一个默认值`nil`，意为“没有`name`值”，因它是一个可选类型。
 ### 类和结构体实例
 `Resolution`结构体和`VideoMode`类的定义仅描述了什么是`Resolution`和`VideoMode`。它们并没有描述一个特定的分辨率（resolution）或者视频模式（video mode）。为了描述一个特定的分辨率或者视频模式，我们需要生成一个它们的实例。
 生成结构体和类实例的语法非常相似：
 	let someResolution = Resolution()
 	let someVideoMode = VideoMode()
 结构体和类都使用初始化器语法来生成新的实例。初始化器语法的最简单形式是在结构体或者类的类型名称后跟随一个空括弧，如`Resolution()`或`VideoMode()`。通过这种方式所创建的类或者结构体实例，其属均会被初始化为默认值。[Initialization](http://)章节会对类和结构体的初始化进行更详细的讨论。
 ### 属性访问
 通过使用*点语法*（*dot syntax*）,你可以访问实例中所含有的属性。其语法规则是，实例名后面紧跟属性名，两者通过点号(.)连接：
 	println("The width of someResolution is \(someResolution.width)")
 	// prints "The width of someResolution is 0"
 在上面的例子中，`someResolution.width`引用`someResolution`的`width`属性，返回`width`的初始值`0`。
 你也可以访问子属性，如何`VideoMode`中`Resolution`属性的`width`属性：
 	println("The width of someVideoMode is \(someVideoMode.resolution.width)")
 	// prints "The width of someVideoMode is 0"
 你也可以使用点语法为属性变量赋值：
 	someVideoMode.resolution.width = 12880
 	println("The width of someVideoMode is now \(someVideoMode.resolution.width)")
 	// prints "The width of someVideoMode is now 1280"
 > 与Objective-C 语言不同的是，Swift 允许直接设置结构体属性的子属性。上面的最后一个例子，就是直接设置了`someVideoMode`中`resolution`属性的`width`这个子属性，以上操作并不需要从新设置`resolution`属性。
 ### 结构体类型的成员逐一初始化器
 //Memberwise Initializers for structure Types
 所有结构体都有一个自动生成的成员逐一初始化器，用于初始化新结构体实例中成员的属性。新实例中各个属性的初始值可以通过属性的名称传递到成员逐一初始化器之中：
 	let vga = resolution（width:640, heigth: 480）
 与结构体不同，类实例没有默认的成员逐一初始化器。[Initialization](http://)章节会对初始化器进行更详细的讨论。
 ### 结构体和枚举是值类型
 值类型被赋予给一个变量，常数或者本身被传递给一个函数的时候，实际上操作的是其的拷贝。
 在之前的章节中，我们已经大量使用了值类型。实际上，在Swift 中，所有的基本类型：整数(Integer)、浮点数(floating-point)、布尔值(Booleans)、字符串(string)、数组(array)和字典(dictionaries)，都是值类型，并且都是以结构体的形式在后台所实现。
 在Swift中，所有的结构体和枚举都是值类型。这意味着它们的实例，以及实例中所包含的任何值类型属性，在代码中传递的时候都会被复制。
 请看下面这个示例，其使用了前一个示例中`Resolution`结构体：
 	let hd = Resolution(width: 1920, height: 1080)
 	var cinema = hd
 在以上示例中，声明了一个名为`hd`的常量，其值为一个初始化为全高清视频分辨率(1920像素宽，1080像素高)的`Resolution`实例。
 然后示例中又声明了一个名为`cinema`的变量，其值为之前声明的`hd`。因为`Resolution`是一个结构体，所以`cinema`的值其实是`hd`的一个拷贝副本，而不是`hd`本身。尽管`hd`和`cinema`有着相同的宽(width)和高(height)属性，但是在后台中，它们是两个完全不同的实例。
 下面，为了符合数码影院放映的需求(2048像素宽，1080像素高)，`cinema`的`width`属性需要作如下修改：
 	cinema.width = 2048
 这里，将会显示`cinema`的`width`属性确已改为了`2048`：
 	println("cinema is now  \(cinema.width) pixels wide")
 	// prints "cinema is now 2048 pixels wide"
 然而，初始的`hd`实例中`width`属性还是`1920`：
 	println("hd is still \(hd.width	) pixels wide")
 	// prints "hd is still 1920 pixels wide"
 在将`hd`赋予给`cinema`的时候，实际上是将`hd`中所储存的`值(values)`进行拷贝，然后将拷贝的数据储存到新的`cinema`实例中。结果就是两个完全独立的实例碰巧包含有相同的数值。由于两者相互独立，因此将`cinema`的`width`修改为`2048`并不会影响`hd`中的宽(width)。
 枚举也遵循相同的行为准则：
 	enum CompassPoint {
 		case North, South, East, West
 	}
 	var currentDirection = CompassPoint.West
 	let rememberedDirection = currentDirection
 	currentDirection = .East
 	if rememberDirection == .West {
 		println("The remembered direction is still .West")
 	}
 	// prints "The remembered direction is still .West"
 上例中`rememberedDirection`被赋予了`currentDirection`的值(value)，实际上它被赋予的是值(value)的一个拷贝。赋值过程结束后再修改`currentDirection`的值并不影响`rememberedDirection`所储存的原始值(value)的拷贝。
 ### 类是引用类型
 与值类型不同，引用类型在被赋予到一个变量，常量或者被传递到一个函数时，操作的并不是其拷贝。因此，引用的是已存在的实例本身而不是其拷贝。
 请看下面这个示例，其使用了之前定义的`VideoMode`类：
 	let tenEighty = VideoMode()
 	tenEighty.resolution = hd
 	tenEighty.interlaced = true
 	tenEighty.name = "1080i"
 	tenEighty.frameRate = 25.0
 以上示例中，声明了一个名为`tenEighty`的常量，其引用了一个`VideoMode`类的新实例。在之前的示例中，这个视频模式(video mode)被赋予了HD分辨率(1920*1080)的一个拷贝(`hd`)。同时设置为交错(interlaced),命名为`“1080i”`。最后，其帧率是`25.0`帧每秒。
 然后，`tenEighty` 被赋予名为`alsoTenEighty`的新常量，同时对`alsoTenEighty`的帧率进行修改：
 	let alsoTenEighty = tenEighty
 	alsoTenEighty.frameRate = 30.0
 因为类是引用类型，所以`tenEight`和`alsoTenEight`实际上引用的是相同的`VideoMode`实例。换句话说，它们只是同一个实例的两种叫法。
 下面，通过查看`tenEighty`的`frameRate`属性，我们会发现它正确的显示了基本`VideoMode`实例的新帧率，其值为`30.0`：
 	println("The frameRate property of tenEighty is now \(tenEighty.frameRate)")
 	// prints "The frameRate property of theEighty is now 30.0"
 需要注意的是`tenEighty`和`alsoTenEighty`被声明为*常量(constants)*而不是变量。然而你依然可以改变`tenEighty.frameRate`和`alsoTenEighty.frameRate`,因为这两个常量本身不会改变。它们并不`储存`这个`VideoMode`实例，在后台仅仅是对`VideoMode`实例的引用。所以，改变的是被引用的基础`VideoMode`的`frameRate`参数，而不改变常量的值。
 ### 恒等运算符
 因为类是引用类型，有可能有多个常量和变量在后台同时引用某一个类实例。(对于结构体和枚举来说，这并不成立。因为它们作值类型，在被赋予到常量，变量或者传递到函数时，总是会被拷贝。)
 如果能够判定两个常量或者变量是否引用同一个类实例将会很有帮助。为了达到这个目的，Swift 内建了两个恒等运算符：
 * 等价于 ( === )
 * 不等价于 ( !== )
 以下是运用这两个运算符检测两个常量或者变量是否引用同一个实例：
 	if tenEighty === alsoTenTighty {
 		println("tenTighty and alsoTenEighty refer to the same Resolution instance.")
 	}
 	//prints "tenEighty and alsoTenEighty refer to the same Resolution instance."
 请注意“等价于”(用三个等号表示，===) 与“等于”(用两个等号表示，==)的不同：
 * “等价于”表示两个类类型(class type)的常量或者变量引用同一个类实例。
 * “等于”表示两个实例的值“相等”或“相同”，判定时要遵照类设计者定义定义的评判标准，因此相比于“相等”，这是一种更加合适的叫法。
 当你在定义你的自定义类和结构体的时候，你有义务来决定判定两个实例“相等”的标准。在章节[Equivalence Operators](http://)中将会详细介绍实现自定义“等于”和“不等于”运算符的流程。
 ### 指针
 如果你有C，C++或者Objective-C语言的经验，那么你也许会知道这些语言使用指针来引用内存中的地址。一个Swift 常量或者变量引用一个引用类型的实例与C语言中的指针类似，不同的是并不直接指向内存中的某个地址，而且也不要求你使用星号(*)来表明你在创建一个引用。Swift 中这些引用与其它的常量或变量的定义方式相同。
 ### 类和结构体的选择
 在你的代码中，你可以使用类和结构体来定义你的自定义数据类型。
 然而，结构体实例总是通过值传递，类实例总是通过引用传递。这意味两者适用不同的任务。当你的在考虑一个工程项目的数据构造和功能的时候，你需要决定每个数据构造是定义成类还是结构体。
 按照通用的准则，当符合一条或多条以下条件时，请考虑构建结构体：
 * 结构体的主要目的是用来封装少量相关简单数据值。
 * 有理由预计一个结构体实例在赋值或传递时，封装的数据将会被拷贝而不是被引用。
 * 任何在结构体中储存的值类型属性，也将会被拷贝，而不是被引用。
 * 结构体不需要去继承另一个已存在类型的属性或者行为。
 合适的结构体候选者包括：
 * 几何形状的大小，封装一个`width`属性和`height`属性，两者均为`Double`类型。
 * 一定范围内的路径，封装一个`start`属性和`length`属性，两者均为`Int`类型。
 * 三维坐标系内一点，封装`x`，`y`和`z`属性，三者均为`Double`类型。
 在所有其它案例中，定义一个类，生成一个它的实例，并通过引用来管理和传递。实际中，这意味着绝大部分的自定义数据构造都应该是类，而非结构体。
 ### 集合(Collection)类型的赋值和拷贝行为
 Swift 中`数组(Array)`和`字典(Dictionary)`类型均以结构体的形式实现。然而当数组被赋予一个常量或变量，或被传递给一个函数或方法时，其拷贝行为与字典和其它结构体有些许不同。
 以下对`数组`和`结构体`的行为描述与对`NSArray`和`NSDictionary`的行为描述在本质上不同，后者是以类的形式实现，前者是以结构体的形式实现。`NSArray`和`NSDictionary`实例总是以对已有实例引用,而不是拷贝的方式被赋值和传递。
 >以下是对于数组，字典，字符串和其它值的`拷贝`的描述。 
 在你的代码中，拷贝好像是确实是在有拷贝行为的地方产生过。然而，在Swift 的后台中，只有确有必要，`实际(actual)`拷贝才会被执行。Swift 管理所有的值拷贝以确保性能最优化的性能，所以你也没有必要去避免赋值以保证最优性能。(实际赋值由系统管理优化)
 ### 字典类型的赋值和拷贝行为
 无论何时将一个`字典`实例赋给一个常量或变量，或者传递给一个函数或方法，这个字典会即会在赋值或调用发生时被拷贝。在章节[Structures and Enumerations Are Value Types](http://)中将会对此过程进行详细介绍。
 如果`字典`实例中所储存的键(keys)和/或值(values)是值类型(结构体或枚举)，当赋值或调用发生时，它们都会被拷贝。相反，如果键(keys)和/或值(values)是引用类型，被拷贝的将会是引用，而不是被它们引用的类实例或函数。`字典`的键和值的拷贝行为与结构体所储存的属性的拷贝行为相同。
 下面的示例定义了一个名为`ages`的字典，其中储存了四个人的名字和年龄。`ages`字典被赋予了一个名为`copiedAges`的新变量，同时`ages`在赋值的过程中被拷贝。赋值结束后，`ages`和`copiedAges`成为两个相互独立的字典。
 	var ages = ["Peter": 23, "Wei": 35, "Anish": 65, "Katya": 19]
 	var copiedAges = ages
 这个字典的键(keys)是`字符串(String)`类型，值(values)是`整(Int)`类型。这两种类型在Swift 中都是值类型(value types)，所以当字典被拷贝时，两者都会被拷贝。
 我们可以通过改变一个字典中的年龄值(age value)，检查另一个字典中所对应的值，来证明`ages`字典确实是被拷贝了。如果在`copiedAges`字典中将`Peter`的值设为`24`，那么`ages`字典仍然会返回修改前的值`23`：
 	copiedAges["Peter"] = 24
 	println(ages["Peter"])
 	// prints "23"
 ### 数组的赋值和拷贝行为
 在Swift 中，`数组(Arrays)`类型的赋值和拷贝行为要比`字典(Dictionary)`类型的复杂的多。当操作数组内容时，`数组(Array)`能提供接近C语言的的性能，并且拷贝行为只有在必要时才会发生。
 如果你将一个`数组(Array)`实例赋给一个变量或常量，或者将其作为参数传递给函数或方法调用，在事件发生时数组的内容`不`会被拷贝。相反，数组公用相同的元素序列。当你在一个数组内修改某一元素，修改结果也会在另一数组显示。
 对数组来说，拷贝行为仅仅当操作有可能修改数组`长度`时才会发生。这种行为包括了附加(appending),插入(inserting),删除(removing)或者使用范围下标(ranged subscript)去替换这一范围内的元素。只有当数组拷贝确要发生时，数组内容的行为规则与字典中键值的相同，参见章节[Assignment and Copy Behavior for Dictionaries](http://)。
 下面的示例将一个`整数(Int)`数组赋给了一个名为`a`的变量，继而又被赋给了变量`b`和`c`：
 	var a = [1, 2, 3]
 	var b = a
 	var c = a
 我们可以在`a`,`b`,`c`上使用下标语法以得到数组的第一个元素：
 	println(a[0])
 	// 1
 	println(b[0])
 	// 1
 	println(c[0])
 	// 1
 如果通过下标语法修改数组中某一元素的值，那么`a`,`b`,`c`中的相应值都会发生改变。请注意当你用下标语法修改某一值时，并没有拷贝行为伴随发生，因为下表语法修改值时没有改变数组长度的可能：
 	a[0] = 42
 	println(a[0])
 	// 42
 	println(b[0])
 	// 42
 	println(c[0])
 	// 42
 然而，当你给`a`附加新元素时，数组的长度`会`改变。
 当附加元素这一事件发生时，Swift 语言会创建这个数组的一个拷贝。从此以后，`a`将会是原数组的一个独立拷贝。
 拷贝发生后，如果再修改`a`中元素值的话，`a`将会返回与`b`，`c`不同的结果，因为后两者引用的是原来的数组：
 	a.append(4)
 	a[0] = 777
 	println(a[0])
 	// 777
 	println(b[0])
 	// 42
 	println(c[0])
 	// 42
 ### 确保数组的唯一性
 在操作一个数组，或将其传递给函数以及方法调用之前是很有必要先确定这个数组是有一个唯一拷贝的。通过在数组变量上调用`unshare`方法来确定数组引用的唯一性。(当数组赋给常量时，不能调用`unshare`方法)
 如果一个数组被多个变量引用，在其中的一个变量上调用`unshare`方法，则会拷贝此数组，此时这个变量将会有属于它自己的独立数组拷贝。当数组仅被一个变量引用时，则不会有拷贝发生。
 在上一个示例的最后，`b`和`c`都引用了同一个数组。此时在`b`上调用`unshare`方法则会将`b`变成一个唯一个拷贝：
 	b.unshare()
 在`unshare`方法调用后再修改`b`中第一个元素的值，这三个数组(`a`,`b`,`c`)会返回不同的三个值：
 	b[0] = -105
 	println(a[0])
 	// 77
 	println(b[0])
 	// -105
 	println(c[0])
 	// 42
 ### 判定两个数组是否共用相同元素
 我们通过使用恒等运算符(identity operators)( === and !==)来判定两个数组或子数组共用相同的储存空间或元素。
 下面这个示例使用了“恒等于(identical to)” 运算符(===) 来判定`b`和`c`是否共用相同的数组元素：
 	if b === c {
 		println("b and c still share the same array elements.")
 	} else {
 		println("b and c now refer to two independent sets of array elements.")
 	}
 	// prints "b and c now refer totwo independent sets of array elements."
 此外，我们还可以使用恒等运算符来判定两个子数组是否共用相同的元素。下面这个示例中，比较了`b`的两个相等的子数组，并且确定了这两个子数组都引用相同的元素：
 	if b[0...1] === b[0...1] {
 		println("These two subarrays share the same elements.")
 	} else {
 		println("These two subarrays do not share the same elements.")
 	}
 	// prints "These two subarrays share the same elements."
 ### 强制复制数组
 我们通过调用数组的`copy`方法进行强制显性复制。这个方法对数组进行了浅拷贝(shallow copy),并且返回一个包含此拷贝的新数组。
 下面这个示例中定义了一个`names`数组，其包含了七个人名。还定义了一个`copiedNames`变量，用以储存在`names`上调用`copy`方法所返回的结果：
 	var names = ["Mohsen", "Hilary", "Justyn", "Amy", "Rich", "Graham", "Vic"]
 	var copiedNames = names.copy
 我们可以通过修改一个数组中某元素，并且检查另一个数组中对应元素的方法来判定`names`数组确已被复制。如果你将`copiedNames`中第一个元素从"`Mohsen`"修改为"`Mo`",则`names`数组返回的仍是拷贝发生前的"`Mohsen`"：
 	copiedName[0] = "Mo"
 	println(name[0])
 	// prints "Mohsen"
 > 如果你仅需要确保你对数组的引用是唯一引用，请调用`unshare`方法，而不是`copy`方法。`unshare`方法仅会在确有必要时才会创建数组拷贝。`copy`方法会在任何时候都创建一个新的拷贝，即使引用已经是唯一引用。