Go语言学习笔记(4)复合类型

 

 

Go语言的复合类型，包括数组、切片和映射等。

值、指针和引用类型

通常情况下Go语言中的变量持有相应的值。也就是说，我们可以将一个变量想象成它所持有的值来使用。其中有些例外，通道、函数、方法、映射、切片是 引用变量，它们持有的都是引用，也即保存指针的变量。值在传递给函数或者方法的时候会被复制一次，对于布尔类型和数值类型来说这非常廉价，但是对于大型变 量代价却非常大。而且复制传参的方式，修改值只是修改了副本，这能保证原始变量不被修改，但也一定程度上增加了修改原始值的麻烦。幸好在Go语言中有指 针，使用指针时，我们每次传递给函数或者方法的只是变量的内存地址，这是非常廉价的。而且一个被指针指向的变量可以通过该指针来修改，这就很方便的在函数 或者防止中通过指针修改原始变量。Go语言中的指针操作符也是使用&和*操作符，其中&用于取地址，*用于解引用，也就是获取指针指向的值。

使用VIM创建源文件pointer.go，输入以下源文件：

package main

 

import (

    "fmt"

)

 

func swap1(x, y, p *int) {

    if *x > *y {

        *x, *y = *y, *x

    }

    *p = *x * *y

}

 

func swap2(x, y int) (int, int, int) {

    if x > y {

        x, y = y, x

    }

    return x, y, x * y

}

 

func main() {

    i := 9

    j := 5

    product := 0

    swap1(&i, &j, &product)

    fmt.Println(i, j, product)

 

    a := 64

    b := 23

    a, b, p := swap2(a, b)

    fmt.Println(a, b, p)

}

以上源码中，我们首先创建了swap1函数，其通过指针原地的交换值，同时swap2函数通过复制的方式交换了变量的值。

运行结果如下：

$ go run pointer.go

5 9 45

23 64 1472

三. 数组和切片

1. 数组

Go语言的数组是一个定长的序列，其中的元素类型相同。多维数组可以简单地使用自身为数组的元素来创建。数组的元素使用操作符号[ ]来索引，索引从0开始，到len(array)-1结束。数组使用以下语法创建：

• [length]Type
• [N]Type{value1, value2, ..., valueN}
• [...]Type{value1, value2, ..., valueN}

如果使用了...（省略符）操作符，Go语言会为我们自动计算数组的长度。在任何情况下，一个数组的长度都是固定的并且不可修改。数组的长度可以使用len()函数获得。由于数组的长度是固定的，因此数组的长度和容量都是一样的，因此对于数组而言cap()和len()函数返回值都是一样的。数组也可以使用和切片一样的语法进行切片，只是其结果为一个切片，而非数组。同样的，数组也可以使用range进行索引访问。

2. 切片

一般而言，Go语言的切片比数组更加灵活，强大而且方便。数组是按值传递的（即是传递的副本），而切片是引用类型，传递切片的成本非常小，而且是定长的。而且数组是定长的，而切片可以调整长度。创建切片的语法如下：

• make([ ]Type, length, capacity)
• make([ ]Type, length)
• [ ]Type{}
• [ ]Type{value1, value2, ..., valueN}

内置函数make()用于创建切片、映射和通道。当用于创建一个切片时，它会创建一个隐藏的初始化为零值的数组，然后返回一个引用该隐藏数组的切片。该隐藏的数组与Go语言中的所有数组一样，都是固定长度，如果使用第一种语法创建，那么其长度为切片的容量capacity；如果是第二种语法，那么其长度记为切片的长度length。一个切片的容量即为隐藏数组的长度，而其长度则为不超过该容量的任意值。另外可以通过内置的函数append()来增加切片的容量。切片可以支持以下操作：

我们练习下，使用VIM创建源文件slice_array.go，输入以下代码：

package main

 

import (

    "fmt"

)

 

func main() {

    a := [...]int{1, 2, 3, 4, 5, 6, 7}

    fmt.Printf("len and cap of array %v is: %d and %d\n", a, len(a), cap(a))

    fmt.Printf("item in array: %v is:", a)

    for _, value := range a {

        fmt.Printf("% d", value)

    }

 

    fmt.Println()

 

    s1 := a[3:6]

    fmt.Printf("len and cap of slice: %v is: %d and %d\n", s1, len(s1), cap(s1))

    fmt.Printf("item in slice: %v is:", s1)

    for _, value := range s1 {

        fmt.Printf("% d", value)

    }

 

    fmt.Println()

 

    s1[0] = 456

    fmt.Printf("item in array changed after changing slice: %v is:", s1)

    for _, value := range a {

        fmt.Printf("% d", value)

    }

 

    fmt.Println()

 

    s2 := make([]int, 10, 20)

    s2[4] = 5

    fmt.Printf("len and cap of slice: %v is: %d and %d\n", s2, len(s2), cap(s2))

    fmt.Printf("item in slice %v is:", s2)

    for _, value := range s2 {

        fmt.Printf("% d", value)

    }

 

    fmt.Println()

}

以上代码中，我们首先创建了一个数组，数组的长度是由Go语言自动计算出的（省略号语法），然后通过切片操作从数组a中创建了切片s1，接着我们修改了该切片的第一个位置的数值，然后发现数组a中的值也发生了变化。最后我们通过make()函数创建了一个切片，该切片的长度和容量分别为10和20，还可以发现Go语言将未初始化的项自动赋予零值。运行代码输出如下：

$  go run slice_array.go

len and cap of array [1 2 3 4 5 6 7] is: 7 and 7

item in array: [1 2 3 4 5 6 7] is: 1 2 3 4 5 6 7

len and cap of slice: [4 5 6] is: 3 and 4

item in slice: [4 5 6] is: 4 5 6

item in array changed after changing slice: [456 5 6] is: 1 2 3 456 5 6 7

len and cap of slice: [0 0 0 0 5 0 0 0 0 0] is: 10 and 20

item in slice [0 0 0 0 5 0 0 0 0 0] is: 0 0 0 0 5 0 0 0 0 0

四. 映射（map）

Go语言中的映射（map）是一种内置的数据结构，保存键=值对的无序集合，它的容量只受到机器内存的限制，类似于Python中的字典。在一个映射中所有的键都是唯一的而且必须是支持==和!=操作符的类型，大部分Go语言的基本类型都可以作为映射的键，但是切片、不能用于比较的数组、结构体（这些类型的成员或者字段不支持==和!=操作）或者基于这些的自定义类型不能作为键。但是任意类型都可以作为值。映射是引用类型，所以传递非常廉价。

Go语言中的映射可以用以下用法创建：

• make(map[KeyType]VauleType, initialCapacity)
• make(map[KeyType]ValueType)
• map[KeyType]ValueType{ }
• map[KeyType]ValueType{key1: value1, key2: value2, ..., keyN: valueN}

内置的函数make()可以用来创建切片、映射和channel（通道）。当用make()来创建一个映射时候，实际上是得到一个空映射，如果指定了容量(initialCapacity)就会预先申请足够的内存，并随着加入的项越来越多，映射会字段扩容。映射支持以下操作：

语法	含义
m[k] = v	用键k来将值赋值给映射m。如果映射m中的k已存在，则将之前的值舍弃
delete(m, k)	将键k及其相关的值从映射m中删除，如果k不存在则不执行任何操作
v := m[k]	从映射m中取得键k相对应的值并赋值给v。如果k不存在，则将映射类型的0值赋值v
v, found := m[k]	从映射m中取得键k相对应的值并赋值给v， 并将found的值赋值为false。如果k不存在，则found为false
len(m)	返回映射m中的项
k := range m	遍历映射m中的键
k, v := range m	同时遍历映射中的键和值

接下来我们练习下。使用VIM创建源文件map_t.go输入以下代码:

package main

 

import (

    "fmt"

)

 

func main() {

    shiyanlou := make(map[string]string) // 与 map[string]string 相同

    shiyanlou["golang"] = "docker"

    shiyanlou["python"] = "flask web framework"

    shiyanlou["linux"] = "sys administrator"

    fmt.Print("Traverse all keys: ")

    for key := range shiyanlou {    // 遍历了映射的所有键

        fmt.Printf("% s ", key)

    }

    fmt.Println()

 

    delete(shiyanlou, "linux")  // 从映射中删除键"linux"及其值

    shiyanlou["golang"] = "beego web framework" // 更新键“golang"的值

 

    v, found := shiyanlou["linux"]

    fmt.Printf("Found key \"linux\" Yes or False: %t, value of key \"linux\": \"%s\"", found, v)

    fmt.Println()

 

    fmt.Println("Traverse all keys/values after changed:")

    for k, v := range shiyanlou {   //遍历了映射的所有键/值对

        fmt.Printf("\"%s\": \"%s\"\n", k, v)

    }

}

以上代码中，我们首先创建了一个映射，然后赋值了3个键/值对，然后我们遍历了映射中的所有键，使用delete()函数删除了映射中的一个键，然后再次遍历打印了映射。映射的操作都非常简单，多多练习即可。

运行结果如下：

$ go run map_t.go

Traverse all keys: golang python linux

Found key "linux" Yes or False: false, value of key "linux": ""

Traverse all keys/values after changed:

"golang": "beego web framework"

"python": "flask web framework"