fix 2.18 type casting

source/chapter2/18_Type_Casting.md

@@ -1,5 +1,4 @@
 > 翻译：xiehurricane  
-
 > 校对：happyming  
 
 # 类型转换（Type Casting）
@@ -26,15 +25,18 @@
 
 第一个代码片段定义了一个新的基础类`MediaItem`。这个类为任何出现在数字媒体库的媒体项提供基础功能。特别的，它声明了一个 `String` 类型的 `name` 属性，和一个`init name`初始化器。（它假定所有的媒体项都有个名称。）
 
+```swift
 class MediaItem {
     var name: String
     init(name: String) {
         self.name = name
     }
 }
+```
 
 下一个代码段定义了 `MediaItem` 的两个子类。第一个子类`Movie`，在父类（或者说基类）的基础上增加了一个 `director`（导演） 属性，和相应的初始化器。第二个类在父类的基础上增加了一个 `artist`（艺术家） 属性，和相应的初始化器：
 
+```swift
 class Movie: MediaItem {
     var director: String
     init(name: String, director: String) {
@@ -50,10 +52,11 @@
         super.init(name: name)
     }
 }
+```
 
-  最后一个代码段创建了一个数组常量 `library`
+最后一个代码段创建了一个数组常量 `library`，包含两个`Movie`实例和三个`Song`实例。`library`的类型是在它被初始化时根据它数组中所包含的内容推断来的。Swift 的类型检测器能够演绎出`Movie` 和 `Song` 有共同的父类 `MediaItem` ，所以它推断出 `MediaItem[]` 类作为 `library` 的类型。
-  ，包含两个`Movie`实例和三个`Song`实例。`library`的类型是在它被初始化时根据它数组中所包含的内容推断来的。Swift 的类型检测器能够演绎出`Movie` 和 `Song` 有共同的父类 `MediaItem` ，所以它推断出 `MediaItem[]` 类作为 `library` 的类型。
 
+```swift
 let library = [
     Movie(name: "Casablanca", director: "Michael Curtiz"),
     Song(name: "Blue Suede Shoes", artist: "Elvis Presley"),
@@ -62,6 +65,7 @@
     Song(name: "Never Gonna Give You Up", artist: "Rick Astley")
 ]
 // the type of "library" is inferred to be MediaItem[]
+```
 
 在幕后`library` 里存储的媒体项依然是 `Movie` 和 `Song` 类型的，但是，若你迭代它，取出的实例会是 `MediaItem` 类型的，而不是 `Movie` 和 `Song` 类型的。为了让它们作为它们本来的类型工作，你需要检查它们的类型或者向下转换它们的类型到其它类型，就像下面描述的一样。
 
@@ -72,6 +76,7 @@
 
 下面的例子定义了两个变量，`movieCount` 和 `songCount`，用来计算数组`library` 中 `Movie` 和 `Song` 类型的实例数量。
 
+```swift
 var movieCount = 0
 var songCount = 0
 
@@ -85,6 +90,7 @@
 
 println("Media library contains \(movieCount) movies and \(songCount) songs")
 // prints "Media library contains 2 movies and 3 songs"
+```
 
 示例迭代了数组 `library` 中的所有项。每一次， `for`-`in` 循环设置
 `item` 为数组中的下一个 `MediaItem`。
@@ -108,6 +114,7 @@
 
 在这个示例中，数组中的每一个`item`可能是 `Movie` 或 `Song`。   事前你不知道每个`item`的真实类型，所以这里使用可选形式的类型转换 （`as?`）去检查循环里的每次下转。
 
+```swift
 for item in library {
     if let movie = item as? Movie {
         println("Movie: '\(movie.name)', dir. \(movie.director)")
@@ -121,6 +128,7 @@
 // Movie: 'Citizen Kane', dir. Orson Welles
 // Song: 'The One And Only', by Chesney Hawkes
 // Song: 'Never Gonna Give You Up', by Rick Astley
+```
 
 示例首先试图将 `item` 下转为 `Movie`。因为 `item` 是一个 `MediaItem`
 类型的实例，它可能是一个`Movie`；同样，它可能是一个 `Song`，或者仅仅是基类
@@ -134,7 +142,6 @@
 若向下转型成功，然后`movie`的属性将用于打印一个`Movie`实例的描述，包括它的导演的名字`director`。当`Song`被找到时，一个相近的原理被用来检测 `Song` 实例和打印它的描述。
 
 > 注意：  
->
 转换没有真的改变实例或它的值。潜在的根本的实例保持不变；只是简单地把它作为它被转换成的类来使用。
 
 <a name="type_casting_for_any_and_anyobject"></a>
@@ -143,11 +150,9 @@
 Swift为不确定类型提供了两种特殊类型别名：
 
 * `AnyObject`可以代表任何class类型的实例。
-
 * `Any`可以表示任何类型，除了方法类型（function types）。
 
 > 注意：  
->
 只有当你明确的需要它的行为和功能时才使用`Any`和`AnyObject`。在你的代码里使用你期望的明确的类型总是更好的。
 
 ### `AnyObject`类型
@@ -159,14 +164,17 @@
 
 下面的示例定义了一个 `AnyObject[]` 类型的数组并填入三个`Movie`类型的实例：
 
+```swift
 let someObjects: AnyObject[] = [
     Movie(name: "2001: A Space Odyssey", director: "Stanley Kubrick"),
     Movie(name: "Moon", director: "Duncan Jones"),
     Movie(name: "Alien", director: "Ridley Scott")
 ]
+```
 
 因为知道这个数组只包含 `Movie` 实例，你可以直接用(`as`)下转并解包到不可选的`Movie`类型（ps：其实就是我们常用的正常类型，这里是为了和可选类型相对比）。
 
+```swift
 for object in someObjects {
     let movie = object as Movie
     println("Movie: '\(movie.name)', dir. \(movie.director)")
@@ -174,20 +182,24 @@
 // Movie: '2001: A Space Odyssey', dir. Stanley Kubrick
 // Movie: 'Moon', dir. Duncan Jones
 // Movie: 'Alien', dir. Ridley Scott
+```
 
 为了变为一个更短的形式，下转`someObjects`数组为`Movie[]`类型来代替下转每一项方式。
 
+```swift
 for movie in someObjects as Movie[] {
     println("Movie: '\(movie.name)', dir. \(movie.director)")
 }
 // Movie: '2001: A Space Odyssey', dir. Stanley Kubrick
 // Movie: 'Moon', dir. Duncan Jones
 // Movie: 'Alien', dir. Ridley Scott
+```
 
 ### `Any`类型
 
 这里有个示例，使用 `Any` 类型来和混合的不同类型一起工作，包括非`class`类型。它创建了一个可以存储`Any`类型的数组 `things`。
 
+```swift
 var things = Any[]()
 
 things.append(0)
@@ -197,11 +209,13 @@
 things.append("hello")
 things.append((3.0, 5.0))
 things.append(Movie(name: "Ghostbusters", director: "Ivan Reitman"))
+```
 
 `things` 数组包含两个 `Int` 值，2个 `Double` 值，1个 `String` 值，一个元组 `(Double, Double)` ，Ivan Reitman 导演的电影“Ghostbusters”。
 
 你可以在 `switch` `cases`里用`is` 和 `as` 操作符来发觉只知道是 `Any` 或 `AnyObject`的常量或变量的类型。 下面的示例迭代 `things`数组中的每一项的并用`switch`语句查找每一项的类型。这几种`switch`语句的情形绑定它们匹配的值到一个规定类型的常量，让它们可以打印它们的值：
 
+```swift
 for thing in things {
     switch thing {
     case 0 as Int:
@@ -232,8 +246,8 @@
 // a string value of "hello"
 // an (x, y) point at 3.0, 5.0
 // a movie called 'Ghostbusters', dir. Ivan Reitman
-。
+```
+
 
 > 注意：  
->
 在一个switch语句的case中使用强制形式的类型转换操作符（as, 而不是 as?）来检查和转换到一个明确的类型。在 switch case 语句的内容中这种检查总是安全的。