5 分组声明与array, slice, map
九路 612 13

在 Go 语言中,同时声明多个常量、变量,或者导入多个包时,可采用分组的方式进行声明。

例如下面的代码:

import "fmt"
import "os"

const i = 100
const pi = 3.1415
const prefix = "Go_"

var i int
var pi float32
var prefix string

可以改成下面的方式

import(
    "fmt"
    "os"
)

const(
    i = 100
    pi = 3.1415
    prefix = "Go_"
)

var(
    i int
    pi float32
    prefix string
)

iota 枚举

Go 里面有一个关键字 iota,这个关键字用来声明enum 的时候采用,它默认开始值是 0,每调用一次加 1

const(
    x = iota // x == 0
    y = iota // y == 1
    z = iota // z == 2
    w // 常量声明省略值时,默认和之前一个值的字面相同。
      //这里隐式地说 w =
      //iota,因此 w == 3。其实上面 y 和 z 可同样不用"= iota"
)

注:const v = iota // 每遇到一个 const 关键字,iota 就会重置,此时 v == 0

Go 程序设计的一些规则

Go 之所以会那么简洁,是因为它有一些默认的行为:

  • 大写字母开头的变量是可导出的,也就是其它包可以读取的,是公用变量;小写字母开头的就是不可导出的,是私有变量

  • 大写字母开头的函数也是一样,相当于 class 中的带 public 关键词的公有函数;小写字母开头的就是有 private 关键词的私有函数。

数组

array 就是数组,它的定义方式如下: var arr [n]type[n]type中,n 表示数组的长度,type 表示存储元素的类型。对数组的操作和其它语言类 似,都是通过[]来进行读取或赋值:

var arr [10]int // 声明了一个 int 类型的数组
arr[0] = 42 // 数组下标是从 0 开始的
arr[1] = 13 // 赋值操作
fmt.Printf("The first element is %d
", arr[0]) // 获取数据,返回 42
fmt.Printf("The last element is %d
", arr[9]) //返回未赋值的最后一个元素,默认返回 0

由于长度也是数组类型的一部分,因此[3]int[4]int 是不同的类型,数组也就不能改变长度。

数组之间的赋值是值的赋值,即当把一个数组作为参数传入函数的时候,传入的其实是该数组的副本,而不是它的指针。

如果要使用指针,那么就需要用到后面介绍的 slice 类型了。

数组可以使用另一种:=来声明

a := [3]int{1, 2, 3} // 声明了一个长度为 3 的 int 数组
b := [10]int{1, 2, 3} // 声明了一个长度为 10 的 int 数组,其中前三个元素初始化为 1、2、3,其它默认
为 0
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}}

// 如果内部的元素和外部的一样,那么上面的声明可以简化,直接忽略内部的
类型
easyArray := [2][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}}

数组的分配如下所示: 5 分组声明与array, slice, map

切片

在很多应用场景中,数组并不能满足我们的需求。在初始定义数组时,我们并不知道需要多 大的数组,因此我们就需要“动态数组”。在 Go 里面这种数据结构叫 slice , 翻译过来就是切片的意思,大白话就是切成一片一片的

  • slice 并不是真正意义上的动态数组,而是一个引用类型。
  • slice 总是指向一个底层array
  • slice 的声明也可以像 array 一样,只是不需要长度。
// 和声明 array 一样,只是少了长度
var fslice []int

接下来我们可以声明一个 slice,并初始化数据,如下所示:

slice := []byte {'a', 'b', 'c', 'd'}
  • slice 可以从一个数组或一个已经存在的 slice 中再次声明。
  • slice 通过 array[i:j]来获取,其中 i 是数组的开始位置,j 是结束位置,但不包含 array[j],即[i,j),前包括后不包括, 它的长度是 j-i
// 声明一个含有 10 个元素元素类型为 byte 的数组
var ar = [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
// 声明两个含有 byte 的 slice
var a, b []byte
// a 指向数组的第 3 个元素开始,并到第五个元素结束,
a = ar[2:5]
//现在 a 含有的元素: ar[2]、ar[3]和 ar[4]

// b 是数组 ar 的另一个 slice
b = ar[3:5]
// b 的元素是:ar[3]和 ar[4]

注意 slice 和数组在声明时的区别: 声明数组时,方括号内写明了数组的长度或使用... 自动计算长度,而声明 slice 时,方括号内没有任何字符。

它们的数据结构如下所示 5 分组声明与array, slice, map

slice 有一些简便的操作

  • slice 的默认开始位置是 0,ar[:n]等价于 ar[0:n]
  • slice 的第二个序列默认是数组的长度,ar[n:]等价于ar[n:len(ar)]
  • 如果从一个数组里面直接获取 slice,可以这样 ar[:],因为默认第一个序列是 0,第 二个是数组的长度,即等价于 ar[0:len(ar)]

下面这个例子展示了更多关于 slice 的操作:

// 声明一个数组
var array = [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
// 声明两个 slice
var aSlice, bSlice []byte
// 演示一些简便操作
aSlice = array[:3] // 等价于 aSlice = array[0:3] aSlice 包含元素: a,b,c
aSlice = array[5:] // 等价于 aSlice = array[5:10] aSlice 包含元素: f,g,h,i,j

aSlice = array[:] // 等价于 aSlice = array[0:10] 这样 aSlice 包含了全部的元素
// 从 slice 中获取 slice
aSlice = array[3:7] // aSlice 包含元素: d,e,f,g,len=4,cap=7
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 包含:d,e,f,g,h
bSlice = aSlice[:] // bSlice 包含所有 aSlice 的元素: d,e,f,g

slice 是引用类型,所以当引用改变其中元素的值时,其它的所有引用都会改变该值,例如 上面的 aSlice 和 bSlice,如果修改了 aSlice 中元素的值,那么 bSlice 相对应的值也会改变。 从概念上面来说 slice 像一个结构体,这个结构体包含了三个元素:

  • 一个指针,指向数组中 slice 指定的开始位置
  • 长度,即 slice 的长度
  • 最大长度,也就是 slice 开始位置到数组的最后位置的长度
    Array_a := [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
    Slice_a := Array_a[2:5]

上面代码的真正存储结构如下图所示 5 分组声明与array, slice, map

对于 slice 有几个有用的内置函数:

  • len 获取 slice 的长度
  • cap 获取 slice 的最大容量
  • append 向 slice 里面追加一个或者多个元素,然后返回一个和 slice 一样类型的slice
  • copy 函数 copy 从源 slice 的 src 中复制元素到目标 dst,并且返回复制的元素的个数

append 函数会改变 slice 所引用的数组的内容,从而影响到引用同一数组的其它 slice。 但当 slice 中没有剩余空间(即(cap-len) == 0)时,此时将动态分配新的数组空间。 返回的slice 数组指针将指向这个空间,而原数组的内容将保持不变; 其它引用此数组的 slice 则不受影响。

map

map 也就是 Python 中字典的概念,它的格式为 map[keyType]valueType 我们看下面的代码,map 的读取和设置也类似 slice 一样,通过 key 来操作,只是 slice 的index只能是`int`类型,而 map 多了很多类型,可以是 int,可以是 string 及所有完全定 义了==!=操作的类型。

// 声明一个 key 是字符串,值为 int 的字典,这种方式的声明需要在使用之前使用 make 初始化
var numbers map[string] int
// 另一种 map 的声明方式
numbers := make(map[string]int)
numbers["one"] = 1 //赋值
numbers["ten"] = 10 //赋值
numbers["three"] = 3
fmt.Println("第三个数字是: ", numbers["three"]) // 读取数据
// 打印出来如:第三个数字是: 3

这个 map 就像我们平常看到的表格一样,左边列是 key,右边列是值 使用 map 过程中需要注意的几点:

  • map 是无序的,每次打印出来的 map 都会不一样,它不能通过 index 获取,而必须通过 key 获取
  • map 的长度是不固定的,也就是和 slice 一样,也是一种引用类型
  • 内置的 len 函数同样适用于map,返回 map 拥有的 key 的数量
  • map 的值可以很方便的修改,通过 numbers["one"]=11 可以很容易的把 keyone 的字典值改为 11

map 的初始化可以通过 key:val 的方式初始化值,同时 map 内置有判断是否存在 key 的方式

通过 delete 删除 map 的元素:

// 初始化一个字典
rating := map[string]float32 {"C":5, "Go":4.5, "Python":4.5, "C++":2 }
// map 有两个返回值,第二个返回值,如果不存在 key,那么 ok 为 false,如果存在 ok 为 true
csharpRating, ok := rating["C#"]
if ok {
    fmt.Println("C# is in the map and its rating is ", csharpRating)
} else {
    fmt.Println("We have no rating associated with C# in the map")
}
delete(rating, "C") // 删除 key 为 C 的元素

上面说过了,map 也是一种引用类型,如果两个 map 同时指向一个底层,那么一个改变, 另一个也相应的改变:

m := make(map[string]string)
m["Hello"] = "Bonjour"
m1 := m
m1["Hello"] = "Salut" // 现在 m["hello"]的值已经是 Salut 了

make、new 操作

  • make 用于内建类型(map、slice 和 channel)的内存分配。

  • new 用于各种类型的内存分配。

  • 内建函数 new 本质上说跟其它语言中的同名函数功能一样:new(T)分配了零值填充的 T类型的内存空间,并且返回其地址,即一个*T类型的值。用 Go 的术语说,它返回了一个指针,指向新分配的类型T 的零值。

  • 有一点非常重要:new 返回指针。

  • 内建函数 make(T, args)new(T)有着不同的功能,make只能创建 slicemapchannel,并且返回一个有初始值(非零)的 T 类型,而不是*T

  • 本质来讲,导致这三个类型有所不同的 原因是指向数据结构的引用在使用前必须被初始化。例如,一个 slice,是一个包含指向数 据(内部 array)的指针、长度和容量的三项描述符;在这些项目被初始化之前,slice 为 nil。

  • 对于 slicemapchannel 来说,make 初始化了内部的数据结构,填充适当的值。

  • make返回初始化后的(非零)值。下面这个图详细的解释了 newmake 之间的区别。 5 分组声明与array, slice, map

5 分组声明与array, slice, map

关于“零值”,所指并非是空值,而是一种“变量未填充前”默认值,通常为 0。 此处罗列部分类型 的 “零值”

int     0
int8     0
int32     0
int64     0
uint     0x0
rune     0 //rune 的实际类型是 int32
byte     0x0 // byte 的实际类型是 uint8
float32 0 //长度为 4 byte
float64 0 //长度为 8 byte
bool     false
string     ""
评论区

索引目录