golang读书笔记(一)

其实《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>)

参数传递

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

推荐阅读更多精彩内容