diff --git a/ch4/ch4-01.md b/ch4/ch4-01.md
index f8aebca..2ff528b 100644
--- a/ch4/ch4-01.md
+++ b/ch4/ch4-01.md
@@ -1,6 +1,6 @@
 ## 4.1. 數組
 
-數組是一個由固定長度的特定類型元素組成的序列，一個數組可以由零個或多個元素組成。因爲數組的長度是固定的，因此在Go語言中很少直接使用數組。Slice（切片），是可以增長和收縮動態序列，slice功能也更靈活，但是要理解slice工作原理的話需要先理解數組。
+數組是一個由固定長度的特定類型元素組成的序列，一個數組可以由零個或多個元素組成。因爲數組的長度是固定的，因此在Go語言中很少直接使用數組。和数组对应的类型是Slice（切片），它是可以增長和收縮動態序列，slice功能也更靈活，但是要理解slice工作原理的話需要先理解數組。
 
 數組的每個元素可以通過索引下標來訪問，索引下標的范圍是從0開始到數組長度減1的位置。內置的len函數將返迴數組中元素的個數。
 
@@ -28,7 +28,7 @@ var r [3]int = [3]int{1, 2}
 fmt.Println(r[2]) // "0"
 ```
 
-在數組字面值中，如果在數組的長度位置出現的是“...”省略號，則表示數組的長度是根據初始化值的個數來計算的。因此，上面q數組的定義可以簡化爲
+在數組字面值中，如果在數組的長度位置出現的是“...”省略號，則表示數組的長度是根據初始化值的個數來計算。因此，上面q數組的定義可以簡化爲
 
 ```Go
 q := [...]int{1, 2, 3}
@@ -42,7 +42,7 @@ q := [3]int{1, 2, 3}
 q = [4]int{1, 2, 3, 4} // compile error: cannot assign [4]int to [3]int
 ```
 
-我們將會發現，數組、slice、map和結構體字面值的寫法都很相似。上面的形式是直接提順序供初始化值序列，但是也可以指定一個索引和對應值列表的方式初始化，就像下面這樣：
+我們將會發現，數組、slice、map和結構體字面值的寫法都很相似。上面的形式是直接提供順序初始化值序列，但是也可以指定一個索引和對應值列表的方式初始化，就像下面這樣：
 
 ```Go
 type Currency int
@@ -67,7 +67,7 @@ r := [...]int{99: -1}
 
 定義了一個含有100個元素的數組r，最後一個元素被初始化爲-1，其它元素都是用0初始化。
 
-如果一個數組的元素類型是可以相互比較的，那麽數組類型也是可以相互比較的，這時候我們可以直接通過==比較運算符來比較兩個數組，隻有當兩個數組的所有元素都是相等的時候數組才是相等的。是不相等比較運算符!=遵循同樣的規則。
+如果一個數組的元素類型是可以相互比較的，那麽數組類型也是可以相互比較的，這時候我們可以直接通過==比較運算符來比較兩個數組，隻有當兩個數組的所有元素都是相等的時候數組才是相等的。不相等比較運算符!=遵循同樣的規則。
 
 ```Go
 a := [2]int{1, 2}
@@ -97,9 +97,9 @@ func main() {
 }
 ```
 
-上面例子中，兩個消息雖然隻有一個字符的差異，但是生成的消息摘要則幾乎有一半的bit位是不相同的。需要註意Printf函數的%x參數，它用於指定以十六進製的格式打印數組或slice全部的元素，%t參數是用於打印布爾型數據，%T參數是用於顯示一個值對應的數據類型。
+上面例子中，兩個消息雖然隻有一個字符的差異，但是生成的消息摘要則幾乎有一半的bit位是不相同的。需要註意Printf函數的%x副词參數，它用於指定以十六進製的格式打印數組或slice全部的元素，%t副词參數是用於打印布爾型數據，%T副词參數是用於顯示一個值對應的數據類型。
 
-當調用一個函數的時候，函數的每個調用參數將會被賦值給函數內部的參數變量，所以函數參數變量接收的是一個複製的副本，併不是原始調用的參數。因爲函數參數傳遞的機製導致傳遞大的數組類型將是低效的，併且對數組參數的任何的脩改都是發生在複製的數組上，併不能直接脩改調用時原始的數組變量。在這個方面，Go語言對待數組的方式和其它很多編程語言不同，其它編程語言可能會隱式地將數組作爲引用或指針對象傳入被調用的函數。
+當調用一個函數的時候，函數的每個調用參數將會被賦值給函數內部的參數變量，所以函數參數變量接收的是一個複製的副本，併不是原始調用的变量。因爲函數參數傳遞的機製導致傳遞大的數組類型將是低效的，併且對數組參數的任何的脩改都是發生在複製的數組上，併不能直接脩改調用時原始的數組變量。在這個方面，Go語言對待數組的方式和其它很多編程語言不同，其它編程語言可能會隱式地將數組作爲引用或指針對象傳入被調用的函數。
 
 當然，我們可以顯式地傳入一個數組指針，那樣的話函數通過指針對數組的任何脩改都可以直接反饋到調用者。下面的函數用於給[32]byte類型的數組清零：
 
diff --git a/ch4/ch4-02-1.md b/ch4/ch4-02-1.md
index 8c1302b..99976cf 100644
--- a/ch4/ch4-02-1.md
+++ b/ch4/ch4-02-1.md
@@ -10,7 +10,7 @@ for _, r := range "Hello, 世界" {
 fmt.Printf("%q\n", runes) // "['H' 'e' 'l' 'l' 'o' ',' ' ' '世' '界']"
 ```
 
-在循環中使用append函數構建一個有九個rune字符構成的slice，當然對應這個特殊的問題我們可以通過Go語言內置的[]rune("Hello, 世界")轉換操作完成。
+在循環中使用append函數構建一個由九個rune字符構成的slice，當然對應這個特殊的問題我們可以通過Go語言內置的[]rune("Hello, 世界")轉換操作完成。
 
 append函數對於理解slice底層是如何工作的非常重要，所以讓我們仔細査看究竟是發生了什麽。下面是第一個版本的appendInt函數，專門用於處理[]int類型的slice：
 
diff --git a/ch4/ch4-02.md b/ch4/ch4-02.md
index 063173b..31c6d09 100644
--- a/ch4/ch4-02.md
+++ b/ch4/ch4-02.md
@@ -1,8 +1,8 @@
 ## 4.2. Slice
 
-Slice（切片）代表變長的序列，序列中每個元素都有相同的類型。一個slice類型一般寫作[]T，其中T代表slice中元素的類型；語法和數組很像隻是沒有長度而已。
+Slice（切片）代表變長的序列，序列中每個元素都有相同的類型。一個slice類型一般寫作[]T，其中T代表slice中元素的類型；語法和數組很像，隻是沒有固定長度而已。
 
-數組和slice之間有着緊密的聯繫。一個slice是一個輕量級的數據結果，提供了訪問數組子序列（或者全部）元素的功能，因爲slice的底層確實引用一個數組對象。一個slice有三個部分構成：指針、長度和容量。指針指向第一個元素對應的底層數組元素的地址，slice的第一個元素併不一定就是數組的第一個元素。長度對應slice中元素的數目；長度不能超過容量，容量一般是從slice的開始位置到底層數據的結尾位置。內置的len和cap函數分别返迴slice的長度和容量。
+數組和slice之間有着緊密的聯繫。一個slice是一個輕量級的數據结构，提供了訪問數組子序列（或者全部）元素的功能，因爲slice的底層確實引用一個數組對象。一個slice由三個部分構成：指針、長度和容量。指針指向第一個slice元素對應的底層數組元素的地址，要注意的是slice的第一個元素併不一定就是數組的第一個元素。長度對應slice中元素的數目；長度不能超過容量，容量一般是從slice的開始位置到底層數據的結尾位置。內置的len和cap函數分别返迴slice的長度和容量。
 
 多個slice之間可以共享底層的數據，併且引用的數組部分區間可能重疊。圖4.1顯示了表示一年中每個月份名字的字符串數組，還有重疊引用了該數組的兩個slice。數組這樣定義
 
@@ -12,7 +12,7 @@ months := [...]string{1: "January", /* ... */, 12: "December"}
 
 因此一月份是months[1]，十二月份是months[12]。通常，數組的第一個元素從索引0開始，但是月份一般是從1開始的，因此我們聲明數組時直接第0個元素，第0個元素會被自動初始化爲空字符串。
 
-slice的操作s[i:j]，其中0 ≤ i≤ j≤ cap(s)，用於創建一個新的slice，引用s的從第i個元素開始到第j-1個元素的子序列。新的slice將隻有j-i個元素。如果i位置的索引被省略的話將使用0代替，如果j位置的索引被省略的話將使用len(s)代替。因此，months[1:13]切片操作將引用全部有效的月份，和months[1:]操作等價；months[:]切片操作則是引用整個數組。讓我們分别定義表示第二季度和北方夏天的slice，它們有重疊部分：
+slice的切片操作s[i:j]，其中0 ≤ i≤ j≤ cap(s)，用於創建一個新的slice，引用s的從第i個元素開始到第j-1個元素的子序列。新的slice將隻有j-i個元素。如果i位置的索引被省略的話將使用0代替，如果j位置的索引被省略的話將使用len(s)代替。因此，months[1:13]切片操作將引用全部有效的月份，和months[1:]操作等價；months[:]切片操作則是引用整個數組。讓我們分别定義表示第二季度和北方夏天月份的slice，它們有重疊部分：
 
 ![](../images/ch4-01.png)
 
@@ -35,7 +35,7 @@ for _, s := range summer {
 }
 ```
 
-如果切片操作長處cap(s)的上限將導致一個panic異常，但是超出len(s)則是擴展了slice，因此新slice的長度會變大：
+如果切片操作超出cap(s)的上限將導致一個panic異常，但是超出len(s)則是意味着擴展了slice，因为新slice的長度會變大：
 
 ```Go
 fmt.Println(summer[:20]) // panic: out of range
@@ -46,7 +46,7 @@ fmt.Println(endlessSummer)  // "[June July August September October]"
 
 另外，字符串的切片操作和[]byte字節類型切片的切片操作是類似的。它們都寫作x[m:n]，併且都是返迴一個原始字節繫列的子序列，底層都是共享之前的底層數組，因此切片操作對應常量時間複雜度。x[m:n]切片操作對於字符串則生成一個新字符串，如果x是[]byte的話則生成一個新的[]byte。
 
-因爲slice值包含指向第一個元素的指針，因此向函數傳遞slice將運行在函數內部脩改底層數組的元素。換句話説，複雜一個slice隻是對底層的數組創建了一個新的slice别名（§2.3.2）。下面的reverse函數在原內存空間將[]int類型的slice反轉，而且它可以用於任意長度的slice。
+因爲slice值包含指向第一個slice元素的指針，因此向函數傳遞slice將允许在函數內部脩改底層數組的元素。換句話説，复制一個slice隻是對底層的數組創建了一個新的slice别名（§2.3.2）。下面的reverse函數在原內存空間將[]int類型的slice反轉，而且它可以用於任意長度的slice。
 
 ```Go
 gopl.io/ch4/rev
@@ -80,7 +80,7 @@ fmt.Println(s) // "[2 3 4 5 0 1]"
 
 要註意的是slice類型的變量s和數組類型的變量a的初始化語法的差異。slice和數組的字面值語法很類似，它們都是用花括弧包含一繫列的初始化元素，但是對於slice併沒有指明序列的長度。這會隱式地創建一個合適大小的數組，然後slice的指針指向底層的數組。就像數組字面值一樣，slice的字面值也可以按順序指定初始化值序列，或者是通過索引和元素值指定，或者的兩種風格的混合語法初始化。
 
-和數組不同的是，slice不能比較，因此我們不能使用==操作符來判斷兩個slice是否有相同的元素。不過標準庫提供了高度優化的bytes.Equal函數來判斷兩個字節型slice是否相等（[]byte），但是對於其他類型的slice，我們必鬚自己展開每個元素進行比較：
+和數組不同的是，slice之间不能比較，因此我們不能使用==操作符來判斷兩個slice是否含有全部相等元素。不過標準庫提供了高度優化的bytes.Equal函數來判斷兩個字節型slice是否相等（[]byte），但是對於其他類型的slice，我們必鬚自己展開每個元素進行比較：
 
 ```Go
 func equal(x, y []string) bool {
@@ -96,11 +96,11 @@ func equal(x, y []string) bool {
 }
 ```
 
-上面關於兩個slice的深度相等測試，運行的時間併不比支持==操作的數組或字符串更多，但是爲何slice卻不支持比較運算符呢？這方面有兩個原因。第一個原因，一個slice的元素是間接引用的，一個slice甚至可以包含自身。雖然有很多辦法處理這種情形，但是沒有一個是簡單有效的。
+上面關於兩個slice的深度相等測試，運行的時間併不比支持==操作的數組或字符串更多，但是爲何slice不直接支持比較運算符呢？這方面有兩個原因。第一個原因，一個slice的元素是間接引用的，一個slice甚至可以包含自身。雖然有很多辦法處理這種情形，但是沒有一個是簡單有效的。
 
 第二個原因，因爲slice的元素是間接引用的，一個固定值的slice在不同的時間可能包含不同的元素，因爲底層數組的元素可能會被脩改。併且Go語言中map等哈希表之類的數據結構的key隻做簡單的淺拷貝，它要求在整個聲明週期中相等的key必鬚對相同的元素。對於像指針或chan之類的引用類型，==相等測試可以判斷兩個是否是引用相同的對象。一個針對slice的淺相等測試的==操作符可能是有一定用處的，也能臨時解決map類型的key問題，但是slice和數組不同的相等測試行爲會讓人睏惑。因此，安全的做飯是直接禁止slice之間的比較操作。
 
-slice唯一合法的比較是和nil比較，例如：
+slice唯一合法的比較操作是和nil比較，例如：
 
 ```Go
 if summer == nil { /* ... */ }
@@ -115,7 +115,7 @@ s = []int(nil) // len(s) == 0, s == nil
 s = []int{}    // len(s) == 0, s != nil
 ```
 
-如果你需要測試一個slice是否是空的，使用len(s) == 0來判斷，而不是用s == nil來判斷。除了和nil相等比較外，一個nil值的slice的行爲和其它任意0産長度的slice一樣；例如reverse(nil)也是安全的。除了文檔已經明確説明的地方，所有的Go語言函數應該以相同的方式對待nil值的slice和0長度的slice。
+如果你需要測試一個slice是否是空的，使用len(s) == 0來判斷，而不应该用s == nil來判斷。除了和nil相等比較外，一個nil值的slice的行爲和其它任意0産長度的slice一樣；例如reverse(nil)也是安全的。除了文檔已經明確説明的地方，所有的Go語言函數應該以相同的方式對待nil值的slice和0長度的slice。
 
 內置的make函數創建一個指定元素類型、長度和容量的slice。容量部分可以省略，在這種情況下，容量將等於長度。
 
diff --git a/ch4/ch4.md b/ch4/ch4.md
index 570022e..431778e 100644
--- a/ch4/ch4.md
+++ b/ch4/ch4.md
@@ -1,6 +1,6 @@
 # 第四章 複合數據類型
 
-在第三章我們討論了基本數據類型，它們是用於構建程序中數據結構，是Go語言的世界的原子。在本章，我們將討論複合數據類型，以不同的方式組合基本類型可以構造出複合數據類型。我們主要討論四種類型——數組、slice、map和結構體——同時在本章的最後，我們將演示如何使用結構體來解碼和編碼到對應的JSON格式的數據，併且通過結合使用模闆來生成HTML頁面。
+在第三章我們討論了基本數據類型，它們可以用於構建程序中數據結構，是Go語言的世界的原子。在本章，我們將討論複合數據類型，它是以不同的方式組合基本類型可以構造出来的複合數據類型。我們主要討論四種類型——數組、slice、map和結構體——同時在本章的最後，我們將演示如何使用結構體來解碼和編碼到對應JSON格式的數據，併且通過結合使用模闆來生成HTML頁面。
 
-數組和結構體是聚合類型；它們的值由許多元素或成員的值組成。數組是由同構的元素組成——每個數組元素都有完全相同的類型——結構體則是由異構的元素組成的。數組和結構體都是固定內存大小的數據結構。相比之下，slice和map則是動態的數據結構，它們將根據需要動態增長。
+數組和結構體是聚合類型；它們的值由許多元素或成員字段的值組成。數組是由同構的元素組成——每個數組元素都是完全相同的類型——結構體則是由異構的元素組成的。數組和結構體都是有固定內存大小的數據結構。相比之下，slice和map則是動態的數據結構，它們將根據需要動態增長。