diff --git a/source/chapter2/01_The_Basics.md b/source/chapter2/01_The_Basics.md
index 27333623..f00b1bbb 100755
--- a/source/chapter2/01_The_Basics.md
+++ b/source/chapter2/01_The_Basics.md
@@ -535,7 +535,7 @@ let convertedNumber = possibleNumber.toInt()
 当你确定可选类型_确实_包含值之后，你可以在可选的名字后面加一个感叹号（`!`）来获取值。这个惊叹号表示“我知道这个可选有值，请使用它。”这被称为可选值的_强制解析（forced unwrapping）_：
 
 ```swift
-if convertedNumber {
+if convertedNumber != nil {
     println("\(possibleNumber) has an integer value of \(convertedNumber!)")
 } else {
     println("\(possibleNumber) could not be converted to an integer")
diff --git a/source/chapter2/02_Basic_Operators.md b/source/chapter2/02_Basic_Operators.md
index 9614c27a..d5fcecf1 100755
--- a/source/chapter2/02_Basic_Operators.md
+++ b/source/chapter2/02_Basic_Operators.md
@@ -323,9 +323,9 @@ Swift 也提供恒等`===`和不恒等`!==`这两个比较符来判断两个对
 
 另一种情况，分配一个非空值(`non-nil`)给 `userDefinedColorName`，再次执行空合运算，运算结果为封包在`userDefaultColorName`中的值，而非默认值。
 
-	userDefinedColor = "green"
+	userDefinedColorName = "green"
 	colorNameToUse = userDefinedColorName ?? defaultColorName
-	//userDefinedColor非空，因此colorNameToUsede的值为绿色
+	//userDefinedColorName非空，因此colorNameToUsede的值为绿色
 
 <a name="range_operators"></a>
 ## 区间运算符
diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md
index 3bc1b248..19e9eea4 100755
--- a/source/chapter2/03_Strings_and_Characters.md
+++ b/source/chapter2/03_Strings_and_Characters.md
@@ -52,9 +52,7 @@ let someString = "Some string literal value"
 字符串字面量可以包含以下特殊字符：
 
 * 转义字符`\0`(空字符)、`\\`(反斜线)、`\t`(水平制表符)、`\n`(换行符)、`\r`(回车符)、`\"`(双引号)、`\'`(单引号)。
-* 单字节 Unicode 标量，写成`\xnn`，其中`nn`为两位十六进制数。
-* 双字节 Unicode 标量，写成`\unnnn`，其中`nnnn`为四位十六进制数。
-* 四字节 Unicode 标量，写成`\Unnnnnnnn`，其中`nnnnnnnn`为八位十六进制数。
+* Unicode 标量，写成`\u{n}`(u为小写)，其中`n`为任意的一到八位十六进制数。
 
 下面的代码为各种特殊字符的使用示例。
 `wiseWords`常量包含了两个转移特殊字符 (双括号)；
@@ -63,9 +61,9 @@ let someString = "Some string literal value"
 ```swift
 let wiseWords = "\"我是要成为海贼王的男人\" - 路飞"
 // "我是要成为海贼王的男人" - 路飞
-let dollarSign = "\x24"             // $,  Unicode 标量 U+0024
-let blackHeart = "\u2665"           // ♥,  Unicode 标量 U+2665
-let sparklingHeart = "\U0001F496"  // 💖, Unicode 标量 U+1F496
+let dollarSign = "\u{24}"             // $,  Unicode 标量 U+0024
+let blackHeart = "\u{2665}"           // ♥,  Unicode 标量 U+2665
+let sparklingHeart = "\u{1F496}"  // 💖, Unicode 标量 U+1F496
 ```
 
 <a name="initializing_an_empty_string"></a>
@@ -172,7 +170,7 @@ println("unusualMenagerie has \(countElements(unusualMenagerie)) characters")
 ```swift
 let string1 = "hello"
 let string2 = " there"
-var welcome = string1 +　string２
+var welcome = string1 +　string2
 // welcome 现在等于 "hello there"
 ```
 
@@ -296,6 +294,8 @@ println("\(mansionCount) mansion scenes; \(cellCount) cell scenes")
 您可以通过字符串的`uppercaseString`和`lowercaseString`属性来访问大写/小写版本的字符串。
 
 ```swift
+import Foundation
+
 let normal = "Could you help me, please?"
 let shouty = normal.uppercaseString
 // shouty 值为 "COULD YOU HELP ME, PLEASE?"
diff --git a/source/chapter2/09_Classes_and_Structures.md b/source/chapter2/09_Classes_and_Structures.md
index 9f3d9e65..3eee71bb 100755
--- a/source/chapter2/09_Classes_and_Structures.md
+++ b/source/chapter2/09_Classes_and_Structures.md
@@ -284,6 +284,6 @@ Swift 中`数组（Array）`和`字典（Dictionary）`类型均以结构体的
 以下对`数组`和`结构体`的行为描述与对`NSArray`和`NSDictionary`的行为描述在本质上不同，后者是以类的形式实现，前者是以结构体的形式实现。`NSArray`和`NSDictionary`实例总是以对已有实例引用,而不是拷贝的方式被赋值和传递。
 
 > 注意：
-以下是对于数组，字典，字符串和其它值的`拷贝`的描述。
+以上是对于数组，字典，字符串和其它值的`拷贝`的描述。
 在你的代码中，拷贝好像是确实是在有拷贝行为的地方产生过。然而，在 Swift 的后台中，只有确有必要，`实际（actual）`拷贝才会被执行。Swift 管理所有的值拷贝以确保性能最优化的性能，所以你也没有必要去避免赋值以保证最优性能。（实际赋值由系统管理优化）
 
diff --git a/source/chapter2/14_Initialization.md b/source/chapter2/14_Initialization.md
index 98638fc6..49816951 100755
--- a/source/chapter2/14_Initialization.md
+++ b/source/chapter2/14_Initialization.md
@@ -513,7 +513,7 @@ class RecipeIngredient: Food {
         self.quantity = quantity
         super.init(name: name)
     }
-    convenience init(name: String) {
+    override convenience init(name: String) {
         self.init(name: name, quantity: 1)
     }
 }
@@ -527,7 +527,7 @@ class RecipeIngredient: Food {
 
 `RecipeIngredient`也定义了一个便利构造器`init(name: String)`，它只通过`name`来创建`RecipeIngredient`的实例。这个便利构造器假设任意`RecipeIngredient`实例的`quantity`为1，所以不需要显示指明数量即可创建出实例。这个便利构造器的定义可以让创建实例更加方便和快捷，并且避免了使用重复的代码来创建多个`quantity`为 1 的`RecipeIngredient`实例。这个便利构造器只是简单的将任务代理给了同一类里提供的指定构造器。
 
-注意，`RecipeIngredient`的便利构造器`init(name: String)`使用了跟`Food`中指定构造器`init(name: String)`相同的参数。尽管`RecipeIngredient`这个构造器是便利构造器，`RecipeIngredient`依然提供了对所有父类指定构造器的实现。因此，`RecipeIngredient`也能自动继承了所有父类的便利构造器。
+注意，`RecipeIngredient`的便利构造器`init(name: String)`使用了跟`Food`中指定构造器`init(name: String)`相同的参数。因为这个便利构造器重写要父类的指定构造器`init(name: String)`，必须在前面使用使用`override`标识。
 
 在这个例子中，`RecipeIngredient`的父类是`Food`，它有一个便利构造器`init()`。这个构造器因此也被`RecipeIngredient`继承。这个继承的`init()`函数版本跟`Food`提供的版本是一样的，除了它是将任务代理给`RecipeIngredient`版本的`init(name: String)`而不是`Food`提供的版本。
 
diff --git a/source/chapter2/16_Automatic_Reference_Counting.md b/source/chapter2/16_Automatic_Reference_Counting.md
index 5bb00b28..72b18bae 100755
--- a/source/chapter2/16_Automatic_Reference_Counting.md
+++ b/source/chapter2/16_Automatic_Reference_Counting.md
@@ -403,7 +403,7 @@ class HTMLElement {
     let name: String
     let text: String?
 
-    @lazy var asHTML: () -> String = {
+    lazy var asHTML: () -> String = {
         if let text = self.text {
             return "<\(self.name)>\(text)</\(self.name)>"
         } else {
@@ -479,7 +479,7 @@ Swift 有如下要求：只要在闭包内使用`self`的成员，就要用`self
 捕获列表放置在闭包参数列表和返回类型之前：
 
 ```swift
-@lazy var someClosure: (Int, String) -> String = {
+lazy var someClosure: (Int, String) -> String = {
     [unowned self] (index: Int, stringToProcess: String) -> String in
     // closure body goes here
 }
@@ -488,7 +488,7 @@ Swift 有如下要求：只要在闭包内使用`self`的成员，就要用`self
 如果闭包没有指定参数列表或者返回类型，则可以通过上下文推断，那么可以捕获列表放在闭包开始的地方，跟着是关键字`in`：
 
 ```swift
-@lazy var someClosure: () -> String = {
+lazy var someClosure: () -> String = {
     [unowned self] in
     // closure body goes here
 }
@@ -511,7 +511,7 @@ class HTMLElement {
     let name: String
     let text: String?
 
-    @lazy var asHTML: () -> String = {
+    lazy var asHTML: () -> String = {
         [unowned self] in
         if let text = self.text {
             return "<\(self.name)>\(text)</\(self.name)>"
diff --git a/source/chapter2/17_Optional_Chaining.md b/source/chapter2/17_Optional_Chaining.md
index 185ed927..841e34db 100755
--- a/source/chapter2/17_Optional_Chaining.md
+++ b/source/chapter2/17_Optional_Chaining.md
@@ -71,7 +71,7 @@ if let roomCount = john.residence?.numberOfRooms {
 
 这告诉 Swift 来链接可选`residence?`属性，如果`residence`存在则取回`numberOfRooms`的值。
 
-因为这种尝试获得`numberOfRooms`的操作有可能失败，可选链会返回`Int?`类型值，或者称作“可选`Int`”。当`residence`是空的时候（上例），选择`Int`将会为空，因此会出先无法访问`numberOfRooms`的情况。
+因为这种尝试获得`numberOfRooms`的操作有可能失败，可选链会返回`Int?`类型值，或者称作“可选`Int`”。当`residence`是空的时候（上例），选择`Int`将会为空，因此会出现无法访问`numberOfRooms`的情况。
 
 要注意的是，即使numberOfRooms是非可选`Int`（`Int?`）时这一点也成立。只要是通过可选链的请求就意味着最后`numberOfRooms`总是返回一个`Int?`而不是`Int`。
 
@@ -111,7 +111,7 @@ class Person {
 
 ```swift
 class Residence {
-    var rooms = Room[]()
+    var rooms = [Room]()
     var numberOfRooms: Int {
     return rooms.count
     }
diff --git a/source/chapter2/20_Extensions.md b/source/chapter2/20_Extensions.md
index cd014f1e..72e094c8 100755
--- a/source/chapter2/20_Extensions.md
+++ b/source/chapter2/20_Extensions.md
@@ -156,7 +156,7 @@ let centerRect = Rect(center: Point(x: 4.0, y: 4.0),
 ```swift
 extension Int {
     func repetitions(task: () -> ()) {
-        for i in 0..self {
+        for i in 0..<self {
             task()
         }
     }
@@ -217,12 +217,13 @@ someInt.square()
 
 ```swift
 extension Int {
-    subscript(digitIndex: Int) -> Int {
+    subscript(var digitIndex: Int) -> Int {
         var decimalBase = 1
-            for _ in 1...digitIndex {
+            while digitIndex > 0 {
                 decimalBase *= 10
+                --digitIndex
             }
-        return (self / decimalBase) % 10
+            return (self / decimalBase) % 10
     }
 }
 746381295[0]
diff --git a/source/chapter2/21_Protocols.md b/source/chapter2/21_Protocols.md
index ad0bcaa4..499f7dd0 100755
--- a/source/chapter2/21_Protocols.md
+++ b/source/chapter2/21_Protocols.md
@@ -112,7 +112,7 @@ class Starship: FullyNamed {
 		self.prefix = prefix
 	}
 	var fullName: String {
-	return (prefix ? prefix! + " " : " ") + name
+	return (prefix != nil ? prefix! + " " : " ") + name
 	}
 }
 var ncc1701 = Starship(name: "Enterprise", prefix: "USS")
@@ -349,9 +349,9 @@ class SnakesAndLadders: DiceGame {
 	let finalSquare = 25
 	let dice = Dice(sides: 6, generator: LinearCongruentialGenerator())
 	var square = 0
-	var board: Int[]
+	var board: [Int]
 	init() {
-		board = Int[](count: finalSquare + 1, repeatedValue: 0)
+		board = [Int](count: finalSquare + 1, repeatedValue: 0)
 		board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
 		board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08
 	}
@@ -508,7 +508,7 @@ println(somethingTextRepresentable.asText())
 协议类型可以被集合使用，表示集合中的元素均为协议类型:
 
 ```swift
-let things: TextRepresentable[] = [game,d12,simonTheHamster]
+let things: [TextRepresentable] = [game,d12,simonTheHamster]
 ```
 
 如下所示，`things`数组可以被直接遍历，并调用其中元素的`asText()`函数:
@@ -675,7 +675,7 @@ class Animal {
 `Circle，Country，Animal`并没有一个相同的基类，因而采用`AnyObject`类型的数组来装载在他们的实例，如下所示:
 
 ```swift
-let objects: AnyObject[] = [
+let objects: [AnyObject] = [
 	Circle(radius: 2.0),
 	Country(area: 243_610),
 	Animal(legs: 4)
@@ -718,8 +718,8 @@ for object in objects {
 
 ```swift
 @objc protocol CounterDataSource {
-    @optional func incrementForCount(count: Int) -> Int
-    @optional var fixedIncrement: Int { get }
+    optional func incrementForCount(count: Int) -> Int
+    optional var fixedIncrement: Int { get }
 }
 ```
 
diff --git a/source/chapter2/22_Generics.md b/source/chapter2/22_Generics.md
index ef69d439..12b40044 100755
--- a/source/chapter2/22_Generics.md
+++ b/source/chapter2/22_Generics.md
@@ -180,7 +180,7 @@ struct IntStack {
 
 ```swift
 struct Stack<T> {
-    var items = T[]()
+    var items = [T]()
     mutating func push(item: T) {
         items.append(item)
     }
@@ -254,7 +254,7 @@ func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {
 这里有个名为`findStringIndex`的非泛型函数，该函数功能是去查找包含一给定`String`值的数组。若查找到匹配的字符串，`findStringIndex`函数返回该字符串在数组中的索引值（`Int`），反之则返回`nil`：
 
 ```swift
-func findStringIndex(array: String[], valueToFind: String) -> Int? {
+func findStringIndex(array: [String], valueToFind: String) -> Int? {
     for (index, value) in enumerate(array) {
         if value == valueToFind {
             return index
@@ -356,7 +356,7 @@ protocol Container {
 ```swift
 struct IntStack: Container {
     // IntStack的原始实现
-    var items = Int[]()
+    var items = [Int]()
     mutating func push(item: Int) {
         items.append(item)
     }
@@ -389,7 +389,7 @@ struct IntStack: Container {
 ```swift
 struct Stack<T>: Container {
     // original Stack<T> implementation
-    var items = T[]()
+    var items = [T]()
     mutating func push(item: T) {
         items.append(item)
     }
@@ -447,7 +447,7 @@ func allItemsMatch<
         }
 
         // 检查两个Container相应位置的元素彼此是否相等
-        for i in 0..someContainer.count {
+        for i in 0..<someContainer.count {
             if someContainer[i] != anotherContainer[i] {
                 return false
             }