fix 2.8 Enumerations

source/chapter2/08_Enumerations.md

@@ -1,17 +1,15 @@
-> 翻译：yankuangshi
+> 翻译：yankuangshi  
-
+> 校对：shinyzhu  
-> 校对：shinyzhu
 
 # 枚举（Enumerations）
-
 ---
 
 本页内容包含：
 
--	[枚举语法（Enumeration Syntax）](#enumeration_syntax)
+- [枚举语法（Enumeration Syntax）](#enumeration_syntax)
--	[匹配枚举值与`Swith`语句（Matching Enumeration Values with a Switch Statement）](#matching_enumeration_values_with_a_switch_statement)
+- [匹配枚举值与`Swith`语句（Matching Enumeration Values with a Switch Statement）](#matching_enumeration_values_with_a_switch_statement)
--	[实例值（Associated Values）](#associated_values)
+- [实例值（Associated Values）](#associated_values)
--	[原始值（Raw Values）](#raw_values)
+- [原始值（Raw Values）](#raw_values)
 
 枚举定义了一个通用类型的一组相关的值，使你可以在你的代码中以一个安全的方式来使用这些值。
 
@@ -28,38 +26,47 @@
 
 使用`enum`关键词并且把它们的整个定义放在一对大括号内：
 
-	enum SomeEumeration {
+```swift
-		// enumeration definition goes here
+enum SomeEumeration {
-	}
+  // enumeration definition goes here
+}
+```
 
 以下是指南针四个方向的一个例子：
 
-	enum CompassPoint {
+```swift
-		case North
+enum CompassPoint {
-		case South
+  case North
-		case East
+  case South
-		case West
+  case East
-	}
+  case West
+}
+```
 
 一个枚举中被定义的值（例如 `North`，`South`，`East`和`West`）是枚举的***成员值***（或者***成员***）。`case`关键词表明新的一行成员值将被定义。
 
-> 注意：
+> 注意：  
->
+> 不像 C 和 Objective-C 一样，Swift 的枚举成员在被创建时不会被赋予一个默认的整数值。在上面的`CompassPoints`例子中，`North`，`South`，`East`和`West`不是隐式的等于`0`，`1`，`2`和`3`。相反的，这些不同的枚举成员在`CompassPoint`的一种显示定义中拥有各自不同的值。  
-> 不像 C 和 Objective-C 一样，Swift 的枚举成员在被创建时不会被赋予一个默认的整数值。在上面的`CompassPoints`例子中，`North`，`South`，`East`和`West`不是隐式的等于`0`，`1`，`2`和`3`。相反的，这些不同的枚举成员在`CompassPoint`的一种显示定义中拥有各自不同的值。
 
 多个成员值可以出现在同一行上，用逗号隔开：
 
-	enum Planet {
+```swift
-		case Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Nepturn
+enum Planet {
-	}
+  case Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Nepturn
+}
+```
 
 每个枚举定义了一个全新的类型。像 Swift 中其他类型一样，它们的名字（例如`CompassPoint`和`Planet`）必须以一个大写字母开头。给枚举类型起一个单数名字而不是复数名字，以便于读起来更加容易理解：
 
-	var directionToHead = CompassPoint.West
+```swift
+var directionToHead = CompassPoint.West
+```
 
 `directionToHead`的类型被推断当它被`CompassPoint`的一个可能值初始化。一旦`directionToHead`被声明为一个`CompassPoint`，你可以使用更短的点（.）语法将其设置为另一个`CompassPoint`的值：
 
-	directionToHead = .East
+```swift
+directionToHead = .East
+```
 
 `directionToHead`的类型已知时，当设定它的值时，你可以不再写类型名。使用显示类型的枚举值可以让代码具有更好的可读性。
 
@@ -68,18 +75,20 @@
 
 你可以匹配单个枚举值和`switch`语句：
 
-	directionToHead = .South
+```swift
-	switch directionToHead {
+directionToHead = .South
-	case .North:
+switch directionToHead {
-    	println("Lots of planets have a north")
+case .North:
-	case .South:
+    println("Lots of planets have a north")
-    	println("Watch out for penguins")
+case .South:
-	case .East:
+    println("Watch out for penguins")
-    	println("Where the sun rises")
+case .East:
-	case .West:
+    println("Where the sun rises")
-    	println("Where the skies are blue")
+case .West:
-	}
+    println("Where the skies are blue")
-	// 输出 "Watch out for penguins”
+}
+// 输出 "Watch out for penguins”
+```
 
 你可以如此理解这段代码：
 
@@ -91,14 +100,16 @@
 
 当不需要匹配每个枚举成员的时候，你可以提供一个默认`default`分支来涵盖所有未明确被提出的任何成员：
 
-	let somePlanet = Planet.Earth
+```swift
-	switch somePlanet {
+let somePlanet = Planet.Earth
-	case .Earth:
+switch somePlanet {
-    	println("Mostly harmless")
+case .Earth:
-	default:
+    println("Mostly harmless")
-    	println("Not a safe place for humans")
+default:
-	}
+    println("Not a safe place for humans")
-	// 输出 "Mostly harmless”
+}
+// 输出 "Mostly harmless”
+```
 
 <a name="associated_values"></a>
 ## 实例值（Associated Values）
@@ -119,10 +130,12 @@
 
 在 Swift 中，用来定义两种商品条码的枚举是这样子的：
 
-	enum Barcode {
+```swift
-		case UPCA(Int, Int, Int)
+enum Barcode {
-		case QRCode(String)
+  case UPCA(Int, Int, Int)
-	}
+  case QRCode(String)
+}
+```
 
 以上代码可以这么理解：
 
@@ -132,35 +145,43 @@
 
 然后可以使用任何一种条码类型创建新的条码，如：
 
-	var productBarcode = Barcode.UPCA(8, 85909_51226, 3)
+```swift
+var productBarcode = Barcode.UPCA(8, 85909_51226, 3)
+```
 
 以上例子创建了一个名为`productBarcode`的新变量，并且赋给它一个`Barcode.UPCA`的实例元组值`(8, 8590951226, 3)`。提供的“标识符”值在整数字中有一个下划线，使其便于阅读条形码。
 
 同一个商品可以被分配给一个不同类型的条形码，如：
 
-	productBarcode = .QRCode("ABCDEFGHIJKLMNOP")
+```swift
+productBarcode = .QRCode("ABCDEFGHIJKLMNOP")
+```
 
 这时，原始的`Barcode.UPCA`和其整数值被新的`Barcode.QRCode`和其字符串值所替代。条形码的常量和变量可以存储一个`.UPCA`或者一个`.QRCode`（连同它的实例值），但是在任何指定时间只能存储其中之一。
 
 像以前那样，不同的条形码类型可以使用一个 switch 语句来检查，然而这次实例值可以被提取作为 switch 语句的一部分。你可以在`switch`的 case 分支代码中提取每个实例值作为一个常量（用`let`前缀）或者作为一个变量（用`var`前缀）来使用：
 
-	switch productBarcode {
+```swift
-	case .UPCA(let numberSystem, let identifier, let check):
+switch productBarcode {
-    	println("UPC-A with value of \(numberSystem), \(identifier), \(check).")
+case .UPCA(let numberSystem, let identifier, let check):
-	case .QRCode(let productCode):
+    println("UPC-A with value of \(numberSystem), \(identifier), \(check).")
-    	println("QR code with value of \(productCode).")
+case .QRCode(let productCode):
-	}
+    println("QR code with value of \(productCode).")
-	// 输出 "QR code with value of ABCDEFGHIJKLMNOP.”
+}
+// 输出 "QR code with value of ABCDEFGHIJKLMNOP.”
+```
 
 如果一个枚举成员的所有实例值被提取为常量，或者它们全部被提取为变量，为了简洁，你可以只放置一个`var`或者`let`标注在成员名称前：
 
-	switch productBarcode {
+```swift
-	case let .UPCA(numberSystem, identifier, check):
+switch productBarcode {
-    	println("UPC-A with value of \(numberSystem), \(identifier), \(check).")
+case let .UPCA(numberSystem, identifier, check):
-	case let .QRCode(productCode):
+    println("UPC-A with value of \(numberSystem), \(identifier), \(check).")
-    	println("QR code with value of \(productCode).")
+case let .QRCode(productCode):
-	}
+    println("QR code with value of \(productCode).")
-	// 输出 "QR code with value of ABCDEFGHIJKLMNOP."
+}
+// 输出 "QR code with value of ABCDEFGHIJKLMNOP."
+```
 
 <a name="raw_values"></a>
 ## 原始值（Raw Values）
@@ -169,11 +190,13 @@
 
 这里是一个枚举成员存储原始 ASCII 值的例子：
 
-	enum ASCIIControlCharacter: Character {
+```swift
-    	case Tab = "\t"
+enum ASCIIControlCharacter: Character {
-    	case LineFeed = "\n"
+    case Tab = "\t"
-    	case CarriageReturn = "\r"
+    case LineFeed = "\n"
-	}
+    case CarriageReturn = "\r"
+}
+```
 
 在这里，称为`ASCIIControlCharacter`的枚举的原始值类型被定义为字符型`Character`，并被设置了一些比较常见的 ASCII 控制字符。字符值的描述请详见字符串和字符`Strings and Characters`部分。
 
@@ -183,37 +206,46 @@
 
 下面的枚举是对之前`Planet`这个枚举的一个细化，利用原始整型值来表示每个 planet 在太阳系中的顺序：
 
-	enum Planet: Int {
+```swift
-    	case Mercury = 1, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
+enum Planet: Int {
-	}
+    case Mercury = 1, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
+}
+```
 
 自动递增意味着`Planet.Venus`的原始值是`2`，依次类推。
 
 使用枚举成员的`toRaw`方法可以访问该枚举成员的原始值：
 
-	let earthsOrder = Planet.Earth.toRaw()
+```swift
-	// earthsOrder is 3
+let earthsOrder = Planet.Earth.toRaw()
+// earthsOrder is 3
+```
 
 使用枚举的`fromRaw`方法来试图找到具有特定原始值的枚举成员。这个例子通过原始值`7`识别`Uranus`：
 
-	let possiblePlanet = Planet.fromRaw(7)
+```swift
-	// possiblePlanet is of type Planet? and equals Planet.Uranus
+let possiblePlanet = Planet.fromRaw(7)
+// possiblePlanet is of type Planet? and equals Planet.Uranus
+```
 
 然而，并非所有可能的`Int`值都可以找到一个匹配的行星。正因为如此，`fromRaw`方法可以返回一个***可选***的枚举成员。在上面的例子中，`possiblePlanet`是`Planet?`类型，或“可选的`Planet`”。
 
 如果你试图寻找一个位置为9的行星，通过`fromRaw`返回的可选`Planet`值将是`nil`：
 
-	let positionToFind = 9
+```swift
-	if let somePlanet = Planet.fromRaw(positionToFind) {
+let positionToFind = 9
-    	switch somePlanet {
+if let somePlanet = Planet.fromRaw(positionToFind) {
-    	case .Earth:
+    switch somePlanet {
-        	println("Mostly harmless")
+    case .Earth:
-    	default:
+        println("Mostly harmless")
-        	println("Not a safe place for humans")
+    default:
-    	}
+        println("Not a safe place for humans")
-	} else {
+    }
-    	println("There isn't a planet at position \(positionToFind)")
+} else {
-	}
+    println("There isn't a planet at position \(positionToFind)")
-	// 输出 "There isn't a planet at position 9
+}
+// 输出 "There isn't a planet at position 9
+```
 
 这个范例使用可选绑定（optional binding），通过原始值`9`试图访问一个行星。`if let somePlanet = Planet.fromRaw(9)`语句获得一个可选`Planet`，如果可选`Planet`可以被获得，把`somePlanet`设置成该可选`Planet`的内容。在这个范例中，无法检索到位置为`9`的行星，所以`else`分支被执行。
+