大家好,最近在系统写Go方面入门文章,如果感兴趣的同学可以点点关注,如果遇到相关方面的问题也可以评论,或者是私聊。你的关注是作者持续更新下去的动力。
array
数组类型,定义方式如下:
var arr [n]type
arr
: 表示变量名称n
: 表示数组长度type
: 表示数据类型
常见的数组操作如下:
func main() {
var arr [5]string // 声明了一个string类型的数组
arr[0] = "a1" // 数组下标是从0开始的
arr[1] = "b2" // 赋值操作
fmt.Printf("The first element is %sn", arr[0]) // 获取数据
fmt.Printf("The second element is %sn", arr[1])
}
数组下标都是从 0
开始
由于长度是数组类型的属性,因此 [3]int
与 [4]int
属于不同的类型,数组也就不能改变长度。
数组之间的赋值是值的赋值,即当把一个数组作为参数传入函数的时候,传入的其实是该数组的副本,而不是它的指针。
func testArray(arr [5]string){ // 数组的长度
arr[2] = "c3"
return
}
func main() {
var arr [5]string // 声明了一个string类型的数组
arr[0] = "a1" // 数组下标是从0开始的
arr[1] = "b2" // 赋值操作
testArray(arr)
fmt.Printf("The first element is %sn", arr[0]) // 获取数据
fmt.Printf("The second element is %sn", arr[1])
fmt.Printf("The second element is %sn", arr[2]) // 输出结果为空
}
数组作为函数传递是按值进行传递,并非指针形式。
数组的其他定义方式:
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 会自动根据元素个数来计算长度
// 二维数组定义方式
doubleArray := [2][4]int{[4]int{1, 2, 3, 4}, [4]int{5, 6, 7, 8}}
slice(切片)
在很多应用场景中,数组并不能满足我们的需求。在初始定义数组时,我们并不知道需要多大的数组,因此我们就需要 “动态数组”。在 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]
,它的长度是 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
时,方括号内没有任何字符。
// 声明一个数组
var array = [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
// 声明两个 slice
var aSlice, bSlice []byte
aSlice = array[3: 7]
bSlice = array[3: 5]
fmt.Println(aSlice) // [100 101 102 103] 字符对应的ASCII码
fmt.Println(bSlice) // [100 101]
aSlice[1] = 'm'
fmt.Println(aSlice) // [100 109 102 103]
fmt.Println(bSlice) // [100 109]
fmt.Println(array) // [97 98 99 100 109 102 103 104 105 106]
// 我们可以看到改了 aSlice 中的某个值后,array, aSlice, bSlice 全部都发生了改变
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]
上面代码的存储结构如下图所示
slice
有几个有用的内置函数:
len
获取slice
的长度cap
获取slice
的最大容量append
向slice
里面追加一个或者多个元素,然后返回一个和slice
一样类型的slice
copy
函数copy
从源slice
的src
中复制元素到目标dst
,并且返回复制的元素的个数.
append
函数会改变 slice
所引用的数组的内容,从而影响到引用同一数组的其它 slice
。
但当 slice
中没有剩余空间(即 (cap-len) == 0 )
时,此时将动态分配新的数组空间。
返回的 slice
数组指针将指向这个空间,而原数组的内容将保持不变; 其它引用此数组的 slice
则不受影响。
例如下面例子:
// 声明一个数组
var array = [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
// 声明两个 slice
var aSlice, bSlice []byte
aSlice = array[3: 7]
bSlice = array[4: 5]
fmt.Printf("aSlice: (%d, %d), bSlice: (%d, %d), array: %d n", len(aSlice), cap(aSlice), len(bSlice), cap(bSlice), len(array))
// aSlice: (4, 7), bSlice: (1, 6), array: 10
// 下面是append方法对切片引用的影响
bSlice = append(bSlice, 'x')
fmt.Println(aSlice) // [100 109 120 103] 因为长度已经超过
fmt.Println(bSlice) // [100 109 120]
fmt.Println(array) // [97 98 99 100 109 120 103 104 105 106]
slice
从数组中截取切片的时候,len
是区间长度,cap
是到数组结尾长度。- 使用
append
方法向区间中放数据,在没有超出容量cap
情况下,同样会影响到其他的内容。 - 如果
slice
的长度不够用,会产生一个新的空间,这样就不会影响到数组和其他了。
例如下面的:
slice := array[2:4:7]
fmt.Print("slice:", len(slice), cap(slice)) // slice:2 5
上面这个的容量通过额外的参数进行指定。如上 7-2
,即 5
。这样这个产生的新的 slice
就没办法访问最后的三个元素。
如果 slice
是这样的形式 array[:i:j]
,即第一个参数为空,默认值就是 0
。
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
可以很容易的把key
为one
的字典值改为11
在 Go
中,没有值可以安全地进行并发读写,它不是 thread-safe
,在多个 go-routine
存取时,必须使用 mutex lock
机制。
map
的初始化可以通过 key:val
的方式初始化值,同时 map
内置有判断是否存在 key
的方式
通过 delete
删除 map
的元素。
map
也是一种引用类型,如果两个 map
同时指向一个底层,那么一个改变,另一个也相应的改变.
make、new 操作
make
用于内建类型(map
、slice
和 channel
)的内存分配。new
用于各种类型的内存分配。
官方定义:new
是一个分配内存的内置函数,第一个参数是类型,而不是值,返回的值是指向该类型新分配的零值的指针。
内建函数 new
本质上说跟其它语言中的同名函数功能一样:new(T)
分配了零值填充的 T
类型的内存空间,并且返回其地址,即一个 *T
类型的值。用 Go
的术语说,它返回了一个指针,指向新分配的类型 T
的零值。
new 返回指针。
内建函数 make(T, args)
与 new(T)
有着不同的功能,make
只能创建 slice
、map
和 channel
,并且返回一个有初始值 (非零) 的 T
类型,而不是 *T
。
本质来讲,导致这三个类型有所不同的原因是指向数据结构的引用在使用前必须被初始化。
例如,一个 slice
,是一个包含指向数据(内部 array
)的指针、长度和容量的三项描述符;在这些项目被初始化之前,slice
为 nil
。对于 slice
、map
和 channel
来说,make
初始化了内部的数据结构,填充适当的值。
make 返回初始化后的(非零)值。
更多的学习可以参考这里的文章: Go语言中make和new有什么区别?