其实《go in action》是一本不错的go入门书，但是由于在这本书的最开始不讲基本的语法，搞得本人在第二章直接被劝退了，这样一拖就是大半年。之后又陆陆续续地读了几本书，包括《go语言趣学指南》、《go语言编程之旅》、《go语言实战（go in practice）》，但是总是感觉读不进去，最后还是看了《Head First go》才把基本的语法搞清楚了，再读剩下的这几本书，也就更加如鱼得水了。

这篇文档主要是简单记录一下go的基本语法，做一个简单的读书笔记

1 数组

1.1 数组的声明

数组的声明主要可以使用以下几种方法：

• 指定数组的长度，赋值为默认零值

var my_array [5]int

• 指定数组的长度，赋值为指定的值

var my_array [5]int{1, 2, 3, 4, 5}

• 不指定数组的长度，赋值为指定的值，数组长度由初始化时数组的元素个数来确定

var my_array [...]int{1, 2, 3, 4, 5}

• 指定数组的长度，特定的位置赋值为特定的值

var my_array [5]int{1:10, 3:30}

1.2 数组的使用

数组的赋值

在go中，可以把类型和长度相同的数组进行赋值操作：

var array1 [5]string

var array2 = [5]string{"Red", "Blue", "Green", "Yello", "Pink"}

array1 = array2
fmt.Printf("Array1 is %#v\n", array1)
fmt.Printf("Array2 is %#v\n", array2)

array1[1] = "Other"

fmt.Printf("Array1 is %#v\n", array1)
fmt.Printf("Array2 is %#v\n", array2)

复制之后，两个数组的内容完全一致，且并不为同一数组，执行之后的结果如下：

Array1 is [5]string{"Red", "Blue", "Green", "Yello", "Pink"}
Array2 is [5]string{"Red", "Blue", "Green", "Yello", "Pink"}
Array1 is [5]string{"Red", "Other", "Green", "Yello", "Pink"}
Array2 is [5]string{"Red", "Blue", "Green", "Yello", "Pink"}

数组的传递

在将数组作为一个参数传递给函数的时候，其实会复制一个新的数组，因此如果数组规模较大的时候，会造成较大的开销，更好地方式可能是使用一个数组的指针进行传递。

2 切片

切片可以理解为一种动态数组，能够根据需求来自动增加和缩减长度，其数据结构主要包括三个字段，分别是：

• 地址指针
• 长度（能够访问的元素的个数）
• 容量（允许增加到的元素个数）

2.1 切片的创建

• 使用长度创建切片

slice := make([]string, 5)

• 使用长度和容量创建切片

slice := make([]string, 3, 5)

• 使用字面量来创建切片

slice := []string{"Red", "Blue", "Green", "Yellow", "Pink"}

• 使用索引声明切片

slice := []string{99: ""}

2.2 nil和空切片

• nil切片：

var slice []int

• 空切片：

slice := make([]int, 0)

slice := []int{}

2.3 切片的选择

当使用一个或者两个索引时，golang中的切片与Python的List完全一致，需要注意的是在选择切片时，底层使用的是同一个底层数组，所以进行修改时，会使得多个切片同时发生变化。

2.4 切片增长

切片的增长是一个比较麻烦的东东，先来看如下的代码

slice := []int{10, 20, 30, 40, 50}
newSlice := slice[1:3]
newSlice = append(newSlice, 60)
fmt.Printf("slice is %#v\n", slice)
fmt.Printf("newSlice is %#v\n", newSlice)

运行结果如下：

slice is []int{10, 20, 30, 60, 50}
newSlice is []int{20, 30, 60}

可以看到，在执行append后，slice和newSlice仍然共享相同的底层数组，但是执行另一段代码时：

slice := []int{10, 20, 30, 40}
newSlice := slice[1:4]
newSlice = append(newSlice, 50)
fmt.Printf("slice is %#v\n", slice)
fmt.Printf("newSlice is %#v\n", newSlice)

其结果为：

slice is []int{10, 20, 30, 40}
newSlice is []int{20, 30, 40, 50}

在上述代码中，在执行append函数后，slice和newSlice却不再共享底层的数组了。这是因为如果底层的数组如果没有足够的空间后，就会创建一个新的底层数组，使新的切片与原切片不再共享同一个底层数组了！！！

2.5 三个索引

slice[i:j:k]：

• i：开始的位置
• j：开始的位置+希望包括的元素的个数（和两个索引的时候一样）
• k：开始的位置+希望容量的个数

source := []string{"Apple", "Orange", "Plum", "Banana", "Grape"}
slice := source[2:3:4]
fmt.Printf("source is %#v\n", source)
fmt.Printf("slice is %#v\n", slice)

其结果为：

source is []string{"Apple", "Orange", "Plum", "Banana", "Grape"}
slice is []string{"Plum"}

使用第三个参数，可以防止在调用append函数时出现的不明确是否创建新的底层数组的问题。可以看如下的代码：

source := []string{"Apple", "Orange", "Plum", "Banana", "Grape"}
slice := source[2:3:3]
slice = append(slice, "Kiwi")
fmt.Printf("source is %#v\n", source)
fmt.Printf("slice is %#v\n", slice)

其结果为：

source is []string{"Apple", "Orange", "Plum", "Banana", "Grape"}
slice is []string{"Plum", "Kiwi"}

可见slice和原来的source并未共享相同的底层数组，这是因为“如果在创建切片时设置的切片容量和长度一样，就可以强制让新切片的第一个append操作创建新的底层数组”，从而与原有的底层数组进行分离。

2.6 获得长度和容量

• len：获得切片的长度
• cap：获得切片的容量

3 映射

3.1 映射的创建

• 使用make创建

dict := make(map[string]int)

• 使用字面量创建

dict := map[string]string{
    "Red"    :"#da1337",
    "Orange" :"#e95a22"
}

3.2 映射的使用

键是否存在

测试映射里是否存在特定的值：

v, exists := colors["Blue"]

其中v是键"Blue"对应的值，但是该值有可能本身就是nil，因此直接利用v==nil来判断键"Blue"是否存在是不合适的，需要使用第二个参数exists

删除

要删除键值对，需要使用delete函数，其格式为：

delete(<map>, <key>)

参数传递

在调用函数传递映射参数时，并不会创建映射的副本。这个和切片十分类似。

---