add list

source/chapter2/01_The_Basics.md

@@ -1,5 +1,22 @@
 # 基础部分
 
+本页包含内容：
+
+-   常量与变量
+-   注释
+-   分号
+-   整数
+-   浮点数
+-   类型安全和类型推导
+-   数值类原始值
+-   数值类型转换
+-   类型别名
+-   布尔值
+-   元组
+-   可选
+-   断言
+
+
 Swift 是 iOS 和 OS X 应用开发的一门新语言。然而，如果你有 C 或者 Objective-C 开发经验的话，你会发现 Swift 的很多内容都是你熟悉的。
 
 Swift 的类型是在 C 和 Objective-C 的基础上提出的，`Int`是整型；`Double`和`Float`是浮点型；`Bool`是布尔型；`String`是字符串。Swift 还有两个有用的集合类型，`Array`和`Dictionary`，详情参见`集合类型(待添加链接)`。
@@ -160,7 +177,7 @@ Swift 也提供了一个特殊的无符号类型`UInt`，长度与当前平台
 * 在32位平台上，`UInt`和`UInt32`长度相同。
 * 在64位平台上，`UInt`和`UInt64`长度相同。
 
-> 注意：尽量不要使用`UInt`，除非你真的需要存储一个和当前平台原生字长相同的无符号整数。除了这种情况，最好使用`Int`，即使你要存储的值已知是非负的。统一使用`Int`可以提高代码的可复用性，避免不同类型数字之间的转换，并且匹配数字的类型推测，详情参见[类型安全和类型推测](## 类型安全和类型推测)。
+> 注意：尽量不要使用`UInt`，除非你真的需要存储一个和当前平台原生字长相同的无符号整数。除了这种情况，最好使用`Int`，即使你要存储的值已知是非负的。统一使用`Int`可以提高代码的可复用性，避免不同类型数字之间的转换，并且匹配数字的类型推导，详情参见[类型安全和类型推导](## 类型安全和类型推导)。
 
 ## 浮点数
 
@@ -173,36 +190,36 @@ Swift 也提供了一个特殊的无符号类型`UInt`，长度与当前平台
 
 > 注意：`Double`精确度很高，至少有15位数字，而`Float`最少只有6位数字。选择哪个类型取决于你的代码需要处理的数字大小。
 
-## 类型安全和类型推测
+## 类型安全和类型推导
 
 Swift 是一个类型安全的语言。类型安全的语言可以让你清楚地知道代码要处理的值的类型。如果你的代码需要一个`String`，你绝对不可能不小心传进去一个`Int`。
 
 Swift 是类型安全的，会在编译你的代码时进行类型检查，如果遇到不匹配的类型会报错。这可以让你在开发的时候尽早发现并修复错误。
 
-当你要处理不同类型的值时，类型检查可以帮你避免错误。然而，这并不是说你每次声明常量和变量的时候都需要显式指定类型。如果你没有显式指定类型，Swift 会使用类型推测来选择合适的类型。有了类型推测，编译器可以在编译代码的时候自动推测出表达式的类型。原理很简单，判断你赋的值即可。
+当你要处理不同类型的值时，类型检查可以帮你避免错误。然而，这并不是说你每次声明常量和变量的时候都需要显式指定类型。如果你没有显式指定类型，Swift 会使用类型推导来选择合适的类型。有了类型推导，编译器可以在编译代码的时候自动推导出表达式的类型。原理很简单，判断你赋的值即可。
 
-因为有类型推测，和 C 或者 Objc 比起来 Swift 很少需要声明类型。常量和变量虽然需要明确类型，但是大部分工作并不需要你自己来完成。
+因为有类型推导，和 C 或者 Objc 比起来 Swift 很少需要声明类型。常量和变量虽然需要明确类型，但是大部分工作并不需要你自己来完成。
 
-当你声明常量或者变量并赋初值的时候类型推测非常有用。当你在声明常量或者变量的时候赋给它们一个原始值即可触发类型推测。（原始值就是会直接出现在你代码中的值，比如`42`和`3.14159`。）
+当你声明常量或者变量并赋初值的时候类型推导非常有用。当你在声明常量或者变量的时候赋给它们一个原始值即可触发类型推导。（原始值就是会直接出现在你代码中的值，比如`42`和`3.14159`。）
 
-举个例子，如果你给一个新常量赋值`42`并且没有标明类型，Swift 可以推测出常量类型是`Int`，因为你给它赋的初值看起来很像一个整数：
+举个例子，如果你给一个新常量赋值`42`并且没有标明类型，Swift 可以推导出常量类型是`Int`，因为你给它赋的初值看起来很像一个整数：
 
     let meaningOfLife = 42
-    // meaningOfLife 会被推测为 Int 类型
+    // meaningOfLife 会被推导为 Int 类型
 
-同理，如果你没有给浮点原始值标明类型，Swift 会推测你想要的是`Double`：
+同理，如果你没有给浮点原始值标明类型，Swift 会推导你想要的是`Double`：
 
     let pi = 3.14159
-    // pi 会被推测为 Double 类型
+    // pi 会被推导为 Double 类型
 
-当推测浮点数的类型时，Swift 总是会选择`Double`而不是`Float`。
+当推导浮点数的类型时，Swift 总是会选择`Double`而不是`Float`。
 
-如果表达式中同时出现了整数和浮点数，会被推测为`Double`类型：
+如果表达式中同时出现了整数和浮点数，会被推导为`Double`类型：
 
     let anotherPi = 3 + 0.14159
-    // anotherPi 会被推测为 Double 类型
+    // anotherPi 会被推导为 Double 类型
 
-原始值`3`没有显式声明类型，而表达式中出现了一个浮点原始值，所以表达式会被推测为`Double`类型。
+原始值`3`没有显式声明类型，而表达式中出现了一个浮点原始值，所以表达式会被推导为`Double`类型。
 
 ## 数值类原始值
 
@@ -244,7 +261,7 @@ Swift 是类型安全的，会在编译你的代码时进行类型检查，如
 
 ## 数值类型转换
 
-通常来讲，即使代码中的整数常量和变量已知非负，也请使用`Int`类型。总是使用默认的整数类型可以保证你的整数常量和变量可以直接被复用并且可以匹配整数类原始值的类型推测。
+通常来讲，即使代码中的整数常量和变量已知非负，也请使用`Int`类型。总是使用默认的整数类型可以保证你的整数常量和变量可以直接被复用并且可以匹配整数类原始值的类型推导。
 只有在必要的时候才使用其他整数类型，比如要处理外部的长度明确的数据或者为了优化性能、内存占用等等。使用显式指定长度的类型可以及时发现值溢出并且可以暗示正在处理特殊数据。
 
 ### 整数转换
@@ -264,7 +281,7 @@ Swift 是类型安全的，会在编译你的代码时进行类型检查，如
     let one: UInt8 = 1
     let twoThousandAndOne = twoThousand + UInt16(one)
 
-现在两个数字的类型都是`UInt16`，可以进行相加。目标常量`twoThousandAndOne`的类型被推测为`UInt16`，因为它是两个`UInt16`值的合。
+现在两个数字的类型都是`UInt16`，可以进行相加。目标常量`twoThousandAndOne`的类型被推导为`UInt16`，因为它是两个`UInt16`值的合。
 
 `SomeType(ofInitialValue)`是调用 Swift 构造器并传入一个初始值的默认方法。在语言内部，`UInt16`有一个构造器，可以接受一个`UInt8`类型的值，所以这个构造器可以用现有的`UInt8`来创建一个新的`UInt16`。注意，你并不能传入任意类型的值，只能传入`UInt16`内部有对应构造器的值。不过你可以扩展现有的类型来让它可以接收其他类型的值（包括自定义类型），详情参见`扩展(链接待添加)`.
 
@@ -275,16 +292,274 @@ Swift 是类型安全的，会在编译你的代码时进行类型检查，如
     let three = 3
     let pointOneFourOneFiveNine = 0.14159
     let pi = Double(three) + pointOneFourOneFiveNine
-    // pi 等于 3.14159，所以被推测为 Double 类型
+    // pi 等于 3.14159，所以被推导为 Double 类型
 
 这个例子中，常量`three`的值被用来创建一个`Double`类型的值，所以加号两边的数类型相同。如果不进行转换，两者无法相加。
 
 浮点数转换为整数也一样，整数类型可以用`Double`或者`Float`类型来初始化：
 
     let integerPi = Int(pi)
-    // integerPi 等于 3，所以被推测为 Int 类型
+    // integerPi 等于 3，所以被推导为 Int 类型
 
 当用这种方式来初始化一个新的整数值时，浮点值会被截断。也就是说`4.75`会变成`4`，`-3.9`会变成`3`。
 
-> 注意：结合数字类常量和变量不同于结合数字类原始值。原始值`3`可以直接和原始值`0.14159`相加，因为数字原始值本身没有明确的类型。它们的类型只在编译器需要求值的时候被推测。
+> 注意：结合数字类常量和变量不同于结合数字类原始值。原始值`3`可以直接和原始值`0.14159`相加，因为数字原始值本身没有明确的类型。它们的类型只在编译器需要求值的时候被推导。
+
+## 类型别名
+
+类型别名就是给现有类型定义一个可选名字。你可以使用`typealias`关键字来定义类型别名。
+
+当你想要给现有类型起一个更有意义的名字时，类型别名非常有用。假设你正在处理特定长度的外部资源的数据：
+
+    typealias AudioSample = UInt16
+
+定义了一个类型别名之后，你可以在任何使用原始名的地方使用别名：
+
+    var maxAmplitudeFound = AudioSample.min
+    // maxAmplitudeFound 现在是 0
+
+本例中，`AudioSample`被定义为`UInt16`的一个别名。因为它是别名，`AudioSample.min`实际上是`UInt16.min`，所以会给`maxAmplitudeFound`赋一个初值`0`。
+
+## 布尔值
+
+Swift 有一个基本的布尔类型，叫做`Bool`。布尔值是指逻辑，因为它们只能是真或者假。Swift 有两个布尔常量，`true`和`false`：
+
+    let orangesAreOrange = true
+    let turnipsAreDelicious = false
+
+`orangesAreOrange`和`turnipsAreDelicious`的类型会被推导为`Bool`，因为它们的初值是布尔原始值。就像之前提到的`Int`和`Double`一样，如果你创建变量的时候给它们赋值`true`或者`false`，那你不需要给常量或者变量标明`Bool`类型。初始化常量或者变量的时候如果所赋的值类型已知，就可以触发类型推导，这让 Swift 代码更加简洁并且可读性更高。
+
+当你编写条件语句比如`if`语句的时候，布尔值非常有用：
+
+    if turnipsAreDelicious {
+        println("Mmm, tasty turnips!")
+    } else {
+        println("Eww, turnips are horrible.")
+    }
+    // 输出 "Eww, turnips are horrible."
+
+条件语句比如`if`语句的详细介绍参见`控制流(待添加链接)`。
+
+如果你在需要使用`Bool`类型的地方使用了非布尔值，Swift 的类型安全机制会报错。下面的例子会报告一个编译时错误：
+
+    let i = 1
+    if i {
+        // 这个例子不会通过编译，会报错
+    }
+
+然而，下面的例子是合法的：
+
+    let i = 1
+    if i == 1 {
+        // 这个例子会编译成功
+    }
+
+`i == 1`的比较结果是`Bool`类型，所以第二个例子可以通过类型检查。类似`i == 1`这样的比较会在`基本操作符(待添加链接)`中详细讨论。
+
+和 Swift 中的其他类型安全的例子一样，这个方法可以避免错误并保证这块代码的作用总是在意料之中。
+
+## 元组
+
+元组把多个值组合成一个复合值。元组内的值可以使任意类型，并不要求是相同类型。
+
+下面这个例子中，`(404, "Not Found")`是一个描述 HTTP 状态码的元组。HTTP 状态码是当你请求网页的时候 web 服务器返回的一个特殊值。如果你请求的网页不存在就会返回一个`404 Not Found`状态码。
+
+    let http404Error = (404, "Not Found")
+    // http404Error 的类型是 (Int, String)，值是 (404, "Not Found")
+
+`(404, "Not Found")`元组把一个`Int`值和一个`String`值组合起来表示 HTTP 状态码的两个部分：一个数字和一个可以读懂的描述。这个元组可以被描述为“一个类型为`(Int, String)`的元组”。
+
+你可以把任意顺序的类型组合成一个元组，这个元组可以包含所有类型。只要你想，你可以创建一个类型为`(Int, Int, Int)`或者`(String, Bool)`或者包含其他类型的元组。
+
+你可以将一个元组的内容分解成单独的常量和变量，然后你就可以正常使用它们了：
+
+    let (statusCode, statusMessage) = http404Error
+    println("The status code is \(statusCode)")
+    // 输出 "The status code is 404"
+    println("The status message is \(statusMessage)")
+    // 输出 "The status message is Not Found"
+
+如果你只需要一部分元组值，分解的时候可以把要忽略的部分设置成`_`：
+
+    let (justTheStatusCode, _) = http404Error
+    println("The status code is \(justTheStatusCode)")
+    // 输出 "The status code is 404"
+
+此外，你还可以通过下标来访问元组中的单个元素，下标从零开始：
+
+    println("The status code is \(http404Error.0)")
+    // 输出 "The status code is 404"
+    println("The status message is \(http404Error.1)")
+    // 输出 "The status message is Not Found"
+
+你可以在定义元组的时候给单个元素命名：
+
+    let http200Status = (statusCode: 200, description: "OK")
+
+给元组中的元素命名后，你可以通过名字来获取这些元素的值：
+
+    println("The status code is \(http200Status.statusCode)")
+    // 输出 "The status code is 200"
+    println("The status message is \(http200Status.description)")
+    // 输出 "The status message is OK"
+
+作为函数返回值时，元组非常有用。一个用来获取网页的函数可能会返回一个`(Int, String)`元组来描述是否获取成功。和只能返回一个类型的值比较起来，一个包含两个不同类型值的元组可以让函数的返回信息更有用。详情参见`返回多个值的函数(待添加链接)`。
+
+> 注意：元组在临时组织值的时候很有用，但是并不适合创建复杂的数据结构。如果你的数据结构并不是临时使用，请使用类或者结构体而不是元组。详情参见`类和结构体(待添加链接)`。
+
+## 可选
+
+使用可选来处理值可能缺失的情况。可选表示：
+
+* 有值，等于 x
+
+或者
+
+* 没有值
+
+> 注意：C 和 Objective-C 中并没有可选这个概念。最接近的是 Objective-C 中的一个特性，一个方法要不返回一个对象要不返回`nil`，`nil`表示“缺少一个合法的对象”。然而，这只对对象起作用——对于结构体，基本的 C 类型或者美剧类型不起作用。对于这些类型，Objective-C 方法一般会返回一个特殊值（比如`NSNotFound`）来暗示值缺失。这种方法假设方法的调用者知道并记得对特殊值进行判断。然而，Swift 的可选可以让你暗示任意类型的值缺失，并不需要一个特殊值。
+
+来看一个例子。Swift 的`String`类型有一个叫做`toInt`的方法，作用是将一个`String`值转换成一个`Int`值。然而，并不是所有的字符串都可以转换成一个整数。字符串`"123"`可以被转换成数字`123`，但是字符串`"hello, world"`不行。
+
+下面的例子使用`toInt`方法来尝试将一个`String`转换成`Int`：
+
+    let possibleNumber = "123"
+    let convertedNumber = possibleNumber.toInt()
+    // convertedNumber 被推导为类型 "Int?"， 或者类型 "optional Int"
+
+因为`toInt`方法可能会失败，所以它返回一个可选的`Int`，而不是一个`Int`。一个可选的`Int`被写作`Int?`而不是`Int`。问号暗示包含的值是可选，也就是说可能包含`Int`值也可能不包含值。（不能包含其他任何值比如`Bool`值或者`String`值。只能是`Int`或者什么都没有。）
+
+### if 语句以及强制解析
+
+你可以使用`if`语句来判断一个可选是否包含值。如果可选有值，结果是`true`；如果没有值，结果是`false`。
+
+当你确定可选包含值之后，你可以在可选的名字后面加一个`!`来获取值。这个惊叹号表示“我知道这个可选有值，请使用它。”这被称为可选值的强制解析：
+
+    if convertedNumber {
+        println("\(possibleNumber) has an integer value of \(convertedNumber!)")
+    } else {
+        println("\(possibleNumber) could not be converted to an integer")
+    }
+    // 输出 "123 has an integer value of 123"
+
+更多关于`if`语句的内容参见`控制流(待添加链接)`。
+
+> 注意：使用`!`来获取一个不存在的可选值会导致运行时错误。。使用`!`来强制解析值之前，一定要确定可选包含一个非`nil`的值。
+
+### 可选绑定
+
+使用可选绑定来判断可选是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在`if`和`while`语句中来对可选的值进行判断并把值赋给一个常量或者变量。`if`和`while`语句详情参见`控制流`。
+
+像下面这样写一个可选绑定：
+
+    if let constantName = someOptional {
+        statements
+    }
+
+你可以像上面这样使用可选绑定来重写`possibleNumber`这个例子：
+
+    if let actualNumber = possibleNumber.toInt() {
+        println("\(possibleNumber) has an integer value of \(actualNumber)")
+    } else {
+        println("\(possibleNumber) could not be converted to an integer")
+    }
+    // 输出 "123 has an integer value of 123"
+
+这段代码可以被理解为：
+
+“如果`possibleNumber.toInt`返回的可选`Int`包含一个值，创建一个叫做`actualNumber`的新常量并将可选包含的值赋给它。”
+
+如果转换成功，`actualNumber`常量可以在`if`语句的第一个分支中使用。它已经被可选包含的值初始化过，所以不需要再使用`!`后缀来获取它的值。在这个例子中，`actualNumber`只被用来输出转换结果。
+
+你可以在可选绑定中使用常量和变量。如果你想在`if`语句的第一个分支中操作`actualNumber`的值，你可以改成`if var actualNumber`，这样可选包含的值就会被赋给一个变量。
+
+### nil
+
+你可以给可选变量赋值为`nil`来表示它没有值：
+
+    var serverResponseCode: Int? = 404
+    // serverResponseCode 包含一个可选的 Int 值 404
+    serverResponseCode = nil
+    // serverResponseCode 现在不包含值
+
+> 注意：`nil`不能用于非可选的常量和变量。如果你的代码中有常量或者变量需要处理值缺失的情况，请把它们声明成对应的可选类型。
+
+如果你声明一个可选常量或者变量但是没有赋值，它们会自动被设置为`nil`：
+
+    var surveyAnswer: String?
+    // surveyAnswer 被自动设置为 nil
+
+> 注意：Swift 的`nil`和 Objective-C 中的`nil`并不一样。在 Objective-C 中，`nil`是一个指向不存在对象的指针。在 Swift 中，`nil`不是指针——它是一个确定的值，用来表示值缺失。任何类型的可选都可以被设置为`nil`，不只是对象类型。
+
+### 隐式解析可选
+
+如上所述，可选暗示了常量或者变量可以“没有值”。可选可以通过`if`语句来判断是否有值，如果有值的话可以通过可选绑定来解析值。
+
+有时候在程序架构中，第一次被赋值之后，可以确定一个可选总会有值。在这种情况下，每次都要判断和解析可选值是非常低效的，因为可以确定它总会有值。
+
+这种类型的可选被定义为隐式解析可选。把后缀`?`改成`!`来声明一个隐式解析可选，比如`String!`。
+
+当可选被第一次赋值之后就可以确定之后一直有值的时候，隐式解析可选非常有用。隐式解析可选主要被用在 Swift 中类的构造过程中，详情参见`无主引用和隐式解析可选属性(Unowned References and Implicitly Unwrapped Optional Properties待添加链接)`。
+
+一个隐式解析可选其实就是一个普通的可选，但是可以被当做非可选来使用，并不需要每次都使用解析来获取可选值。下面的例子展示了可选`String`和隐式解析可选`String`之间的区别：
+
+    let possibleString: String? = "An optional string."
+    println(possibleString!) // 需要惊叹号来获取值
+    // 输出 "An optional string."
+
+    let assumedString: String! = "An implicitly unwrapped optional string."
+    println(assumedString)  // 不需要惊叹号
+    // 输出 "An implicitly unwrapped optional string."
+
+你可以把隐式解析可选当做一个可以自动解析的可选。你要做的只是声明的时候把惊叹号放到类型的结尾，而不是每次获取值的变量结尾。
+
+> 注意：如果你在隐式解析可选没有值的时候尝试获取，会触发运行时错误。和你在没有值的普通可选后面加一个惊叹号一样。
+
+你仍然可以把隐式解析可选当做普通可选来判断它是否包含值：
+    if assumedString {
+        println(assumedString)
+    }
+    // 输出 "An implicitly unwrapped optional string."
+
+你也可以在可选绑定中使用隐式解析可选来检查并解析它的值：
+    if let definiteString = assumedString {
+        println(definiteString)
+    }
+    // 输出 "An implicitly unwrapped optional string."
+
+> 注意：如果一个变量之后可能变成`nil`的话请不要使用隐式解析可选。如果你需要在变量的生命周期中判断是否是`nil`的话，请使用普通可选类型。
+
+## 断言
+
+可选可以让你判断值是否存在，你可以在代码中优雅地处理值缺失的情况。然而，在某些情况下，如果值缺失或者值并不满足特定的条件，你的代码可能并不需要继续执行。这时，你可以在你的代码中触发一个断言来结束代码运行并通过调试来找到值缺失的原因。
+
+### 使用断言来调试
+
+断言会在运行时判断一个逻辑条件是否为`true`。从字面意思来说，断言“断言”一个条件是否为真。你可以使用断言来保证在运行其他代码之前，某些重要的条件已经被满足。如果条件判断为`true`，代码运行会继续进行；如果条件判断为`false`，代码运行停止，你的应用被终止。
+
+如果你的代码在调试环境下触发了一个断言，比如你在 Xcode 中构建并运行一个应用，你可以清楚地看到不合法的状态发生在哪里并检查断言被触发时你的应用的状态。此外，断言允许你附加一条调试信息。
+
+你可以使用全局`assert`函数来写一个断言。给`assert`函数传入一个结果为`true`或者`false`的表达式以及一条信息，当表达式为`false`的时候这条信息会被显示：
+
+    let age = -3
+    assert(age >= 0, "A person's age cannot be less than zero")
+    // 因为 age < 0，所以断言会触发
+
+在这个例子中，只有`age >= 0`为`true`的时候代码运行才会继续，也就是说，当`age`的值非负的时候。如果`age`的值是负数，就像代码中那样，`age >= 0`为`false`，断言被触发，结束应用。
+
+断言信息不能使用字符串插值。断言信息可以省略，就像这样：
+
+    assert(age >= 0)
+
+### 何时使用断言
+
+当条件可能为假时使用断言，但是最终一定要保证条件为真，这样你的代码才能继续运行。断言的适用情景：
+
+* 整数的下标(subscript)索引被传入一个自定义下标实现，但是下标索引值可能太小或者太大。
+* 需要给函数传入一个值，但是非法的值可能导致函数不能正常执行。
+* 一个可选值现在是`nil`，但是后面的代码运行需要一个非`nil`值。
+
+查看`下标(链接待添加)`和`函数(链接待添加)`。
+
+> 注意：断言可能导致你的应用终止运行，所以你应当仔细设计你的代码来让非法条件不会出现。然而，在你的应用发布之前，有时候非法条件可能出现，这时使用断言可以快速发现问题。