Programming-With-Love
diff --git a/‎1.基本结构.go renamed to ‎01.基本结构.go b/‎1.基本结构.go renamed to ‎01.基本结构.go
diff --git a/‎2.类型与变量.md renamed to ‎02.类型与变量.md b/‎2.类型与变量.md renamed to ‎02.类型与变量.md
diff --git a/‎3.常量与运算符.md renamed to ‎03.常量与运算符.md b/‎3.常量与运算符.md renamed to ‎03.常量与运算符.md
diff --git a/‎4.控制语句.md renamed to ‎04.控制语句.md b/‎4.控制语句.md renamed to ‎04.控制语句.md
diff --git a/‎5.数组Array.md renamed to ‎05.数组 array.md
+1-1 b/‎5.数组Array.md renamed to ‎05.数组 array.md
+1-1
diff --git a/‎6.切片Slice.md renamed to ‎06.切片 slice.md
+6-6 b/‎6.切片Slice.md renamed to ‎06.切片 slice.md
+6-6
diff --git a/‎7.Map.md renamed to ‎07.map.md
+1-1 b/‎7.Map.md renamed to ‎07.map.md
+1-1
diff --git a/‎8.函数Function.md renamed to ‎08.函数 function.md
+2-2 b/‎8.函数Function.md renamed to ‎08.函数 function.md
+2-2
diff --git a/‎9.结构Struct.md renamed to ‎09.结构 struct.md
+1-1 b/‎9.结构Struct.md renamed to ‎09.结构 struct.md
+1-1
diff --git a/‎10.方法Method.md renamed to ‎10.方法 method.md
+1-1 b/‎10.方法Method.md renamed to ‎10.方法 method.md
+1-1
diff --git a/‎11.反射Reflection.md renamed to ‎11.反射 reflection.md
+1-1 b/‎11.反射Reflection.md renamed to ‎11.反射 reflection.md
+1-1
diff --git a/‎11.接口Interface.md renamed to ‎11.接口 interface.md
+1-1 b/‎11.接口Interface.md renamed to ‎11.接口 interface.md
+1-1
diff --git a/‎12.并发Concurrency.md renamed to ‎12.并发 concurrency.md b/‎12.并发Concurrency.md renamed to ‎12.并发 concurrency.md
@@ -1,4 +1,4 @@
-## 数组Array
+## 数组 `array`
 -定义数组的格式 `var <varName> [n]<type>` , n 必须 >=0  
 -数组长度也是类型的一部分，因此具有不同长度的数组的不同类型  
 -注意区分指向数组的指针和指针数组  
 
@@ -1,4 +1,4 @@
-## 切片Slice
+## 切片 `slice`
 -其分身并不是数组，他指向底层的数组  
 -作为变长数组的替代方案，可以关联底层数组的局部或全部  
 -为引用类型  
@@ -36,7 +36,7 @@
 
 	fmt.Println(sl)
 
-## Slice 与底层数组的对应关系
+## `slice` 与底层数组的对应关系
 ![Slice 与底层数组的对应关系](./resource/slice_about.png)
 
     Array_ori := []byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k'}
@@ -45,12 +45,12 @@
     Slice_b := Array_ori[3:5]
     fmt.Println(string(Slice_b))
 
-## Reslice
--`Reslice`时索引以被 `slice` 的切片为准   
+## `reslice`
+-`reslice`时索引以被 `slice` 的切片为准   
 -索引不可以超过被 `slice` 的切片的容量 `cap()`值  
 -索引越界不会导致底层数组的重新分配而是引发错误  
 
-## Append
+## `append`
 -可以在 `slice` 尾部追加元素  
 -可以将一个 `slice` 追加在另一个 `slice` 尾部  
 -如果最终长度未超过追加到 `slice` 的容量则返回原始 `slice`  
@@ -65,7 +65,7 @@
 	a = append(a, 1, 2, 3)
 	fmt.Printf("%v %p\n", a, a)
 
-## Copy
+## `copy`
 
     a := []int{1,2,3,4,5,6}
     b := []int{7,8,9}
 
@@ -1,4 +1,4 @@
-## Map
+## `map`
 -类似其他语言中的哈希表或者字典，以 `key-value` 形式存储数据  
 -`key` 必须是支持 `==` 或 `!=` 比较运算的类型，不可以是函数，`map`或`slice`  
 -`map` 查找比线性搜索快很多，但比使用索引访问数据的类型慢100倍  
 
@@ -1,4 +1,4 @@
-## 函数Function
+## 函数 `function`
 -Go 函数**不支持** 嵌套，重载 和 默认函数   
 -但支持一下特性:  
 &nbsp;&nbsp;&nbsp;&nbsp;无需声明原型，不定长度变参，多返回值，命名返回值参数，匿名函数，闭包  
@@ -55,7 +55,7 @@
         }
     }
 
-## 延迟调用函数 defer
+## 延迟调用函数 `defer`
 -在函数体执行结束后按照调用顺序的**相反顺序**逐个执行  
 -**即使函数发生严重错误也会执行**  
 -支持匿名函数的调用  
 
@@ -1,4 +1,4 @@
-## 结构Struct
+## 结构 `struct`
 -Go 中的 `struct` 与 C 中的 `struct` 非常相似，并且 Go 没有 `class`  
 -使用 `type <Name> struct{}` 定义结构，名称遵循可见性规则   
 -支持指向自身的指针类型成员  
 
@@ -1,4 +1,4 @@
-## 方法Method
+## 方法 `method`
 -Go 中虽没有 `class` ，但依旧有 `method`  
 -通过显示说明 `receiver` 来实现与某个类型的组合  
 -只能为同一个包中的类型定义方法  
 
@@ -1,4 +1,4 @@
-## 反射Reflection
+## 反射 `reflection`
 -反射可以大大提高程序的灵活性，使得 `interface{}` 有更大的发挥余地  
 -反射使用 `TypeOf` 和 `ValueOf` 函数从接口中获取目标对象信息  
 -反射会将匿名字段作为独立字段（匿名字段本质）  
 
@@ -1,4 +1,4 @@
-## 接口Interface
+## 接口 `interface`
 -接口是一个或多个方法签名的集合  
 -只要某个类型拥有该接口的索引方法签名，即算实现该接口，无需显示声明实现了哪个接口，这称为 `Structural Typing`  
 -接口只有方法声明，没有实现，没有数据字段
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-## 数组Array`
	`1`	+## 数组 `array`
`2`	`2`	-定义数组的格式 `var <varName> [n]<type>` , n 必须 >=0
`3`	`3`	`-数组长度也是类型的一部分，因此具有不同长度的数组的不同类型`
`4`	`4`	`-注意区分指向数组的指针和指针数组`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-## Map`
	`1`	+## `map`
`2`	`2`	-类似其他语言中的哈希表或者字典，以 `key-value` 形式存储数据
`3`	`3`	-`key` 必须是支持 `==` 或 `!=` 比较运算的类型，不可以是函数，`map`或`slice`
`4`	`4`	-`map` 查找比线性搜索快很多，但比使用索引访问数据的类型慢100倍
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-## 函数Function`
	`1`	+## 函数 `function`
`2`	`2`	`-Go 函数不支持嵌套，重载和默认函数`
`3`	`3`	`-但支持一下特性:`
`4`	`4`	`    无需声明原型，不定长度变参，多返回值，命名返回值参数，匿名函数，闭包`
`@@ -55,7 +55,7 @@`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`
`58`		`-## 延迟调用函数 defer`
	`58`	+## 延迟调用函数 `defer`
`59`	`59`	`-在函数体执行结束后按照调用顺序的相反顺序逐个执行`
`60`	`60`	`-即使函数发生严重错误也会执行`
`61`	`61`	`-支持匿名函数的调用`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-## 结构Struct`
	`1`	+## 结构 `struct`
`2`	`2`	-Go 中的 `struct` 与 C 中的 `struct` 非常相似，并且 Go 没有 `class`
`3`	`3`	-使用 `type <Name> struct{}` 定义结构，名称遵循可见性规则
`4`	`4`	`-支持指向自身的指针类型成员`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-## 方法Method`
	`1`	+## 方法 `method`
`2`	`2`	-Go 中虽没有 `class` ，但依旧有 `method`
`3`	`3`	-通过显示说明 `receiver` 来实现与某个类型的组合
`4`	`4`	`-只能为同一个包中的类型定义方法`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-## 反射Reflection`
	`1`	+## 反射 `reflection`
`2`	`2`	-反射可以大大提高程序的灵活性，使得 `interface{}` 有更大的发挥余地
`3`	`3`	-反射使用 `TypeOf` 和 `ValueOf` 函数从接口中获取目标对象信息
`4`	`4`	`-反射会将匿名字段作为独立字段（匿名字段本质）`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-## 接口Interface`
	`1`	+## 接口 `interface`
`2`	`2`	`-接口是一个或多个方法签名的集合`
`3`	`3`	-只要某个类型拥有该接口的索引方法签名，即算实现该接口，无需显示声明实现了哪个接口，这称为 `Structural Typing`
`4`	`4`	`-接口只有方法声明，没有实现，没有数据字段`