diff --git a/2.2.md b/2.2.md
index 80fcc08d..5bfc0f97 100644
--- a/2.2.md
+++ b/2.2.md
@@ -257,19 +257,19 @@ Go之所以会那么简洁，是因为它有一些默认的行为：
 
 数组可以使用另一种`:=`来声明
 
-	a := [3]int{1,2,3}   // 声明了一个长度为3的int数组
+	a := [3]int{1, 2, 3} // 声明了一个长度为3的int数组
 
-	b := [10]int{1,2,3}  // 声明了一个长度为10的int数组，其中前三个元素初始化为1、2、3，其它默认为0
+	b := [10]int{1, 2, 3} // 声明了一个长度为10的int数组，其中前三个元素初始化为1、2、3，其它默认为0
 
-	c := [...]int{4,5,6} // 可以省略长度而采用`...`的方式，Go会自动根据元素个数来计算长度
+	c := [...]int{4, 5, 6} // 可以省略长度而采用`...`的方式，Go会自动根据元素个数来计算长度
 
 也许你会说，我想数组里面还是数组，能实现吗？当然咯，Go支持嵌套数组，即多维数组。比如下面的代码就声明了一个二维数组：
 
-	// 声明了一个二维数组，该数组以两个数组作为元素，其中每个数组中又有4个int类型的元素
-	doubleArray := [2][4]int {[4]int{1,2,3,4}, [4]int{5,6,7,8}}
+    // 声明了一个二维数组，该数组以两个数组作为元素，其中每个数组中又有4个int类型的元素
+    doubleArray := [2][4]int{[4]int{1, 2, 3, 4}, [4]int{5, 6, 7, 8}}
 
-	// 如果内部的元素和外部的一样，那么上面的声明可以简化，直接忽略内部的类型
-	easyArray :=[2][4]int{{1,2,3,4}, {5,6,7,8}}
+    // 如果内部的元素和外部的一样，那么上面的声明可以简化，直接忽略内部的类型
+    easyArray := [2][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}}
 
 数组的分配如下所示：
 
@@ -320,21 +320,21 @@ slice有一些简便的操作
 下面这个例子展示了更多关于`slice`的操作：
 
 	// 声明一个数组
-	var array = [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
+	var array = [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
 	// 声明两个slice
-	var aSlice,bSlice
+	var aSlice, bSlice []byte
 
 	// 演示一些简便操作
-	aSlice = array[:3]  // 等价于aSlice = array[0:3] aSlice包含元素: a,b,c
-	aSlice = array[5:]  // 等价于aSlice = array[5:9] aSlice包含元素: f,g,h,i,j
-	aSlice = array[:]   // 等价于aSlice = array[0:9] 这样aSlice包含了全部的元素
+	aSlice = array[:3] // 等价于aSlice = array[0:3] aSlice包含元素: a,b,c
+	aSlice = array[5:] // 等价于aSlice = array[5:9] aSlice包含元素: f,g,h,i,j
+	aSlice = array[:]  // 等价于aSlice = array[0:9] 这样aSlice包含了全部的元素
 
 	// 从slice中获取slice
-	aSlice = array[3:7]   // aSlice包含元素: d,e,f,g，len=4，cap=8
-	bSlice = aSlice[1:3]  // bSlice 包含aSlice[1], aSlice[2] 也就是含有: e,f
-	bSlice = aSlice[:3]   // bSlice 包含 aSlice[0], aSlice[1], aSlice[2] 也就是含有: d,e,f
-	bSlice = aSlice[0:5]  // 对slice的slice可以在cap范围内扩展，此时bSlice包含：c,d,e,f,g
-	bSlice : aSlice[:]    // bSlice包含所有aSlice的元素: d,e,f,g
+	aSlice = array[3:7]  // aSlice包含元素: d,e,f,g，len=4，cap=8
+	bSlice = aSlice[1:3] // bSlice 包含aSlice[1], aSlice[2] 也就是含有: e,f
+	bSlice = aSlice[:3]  // bSlice 包含 aSlice[0], aSlice[1], aSlice[2] 也就是含有: d,e,f
+	bSlice = aSlice[0:5] // 对slice的slice可以在cap范围内扩展，此时bSlice包含：c,d,e,f,g
+	bSlice = aSlice[:]   // bSlice包含所有aSlice的元素: d,e,f,g
 
 `slice`是引用类型，所以当引用改变其中元素的值时，其它的所有引用都会改变该值，例如上面的`aSlice`和`bSlice`，如果修改了`aSlice`中元素的值，那么`bSlice`相对应的值也会改变。