《Go程序设计语言》学习笔记之数组
《Go程序设计语言》学习笔记之数组
一. 环境
Centos8.5, go1.17.5 linux/amd64
二. 概念
数组是具有固定长度且拥有零个或多个相同数据类型元素的序列。
三. 声明
声明一个数组a，然后打印数组、数组a的长度、数组a的类型。从打印的a的类型中可以看出数组的长度是类型的一部分。
// test sample
package main
import (
"fmt"
)
func main() {
var a [3]int
fmt.Printf("a: %d\n", a)
fmt.Printf("len: %d\n", len(a))
fmt.Printf("type: %T\n", a)
}
运行结果如下
四. 初始化
声明与初始化个人感觉是C/C++中的说法，严格来说在Go中不太严谨。在Go中，定义的变量，如果没有显式初始化的话，变量会默认初始化。也就是说，声明即是初始化。Go中有个零值机制。零值机制保障所有的变量是良好定义的，Go里面不存在未初始化变量。
下面示例了4种初始化的方式
第一种，声明了一个长度为3的整型数组a，从打印结果来看， 每个元素初始值为零值。
第二种，声明了一个长度为3的整型数组b，使用数组字面量初始化一个数组。字面量数组中只有两个元素，但是数组b的长度为3，最后一个元素的初始值为零值。
第三种，使用短变量声明的形式，使用数组字面量来初始化整型数组c，数组字面量中的长度是”...“，则数组的长度由初始化数组的元素个数决定。
第四种，先使用常量计数器iota声明一组常量值作为下标，然后将下标与对应位置上的元素的值对应起来。这种的方式好处就是索引可以按照任意顺序出现。
8 func main() {
9 // init way1, zero value
10 var a [3]int
11 for _, v := range a {
12 fmt.Printf("%d\t", v)
13 }
14 fmt.Printf("\n")
15
16 // init way2
17 fmt.Println("----------")
18 var b [3]int = [3]int{1, 2}
19 for _, v := range b {
20 fmt.Printf("%d\t", v)
21 }
22 fmt.Printf("\n")
23
24 // init way3
25 fmt.Println("----------")
26 c := [...]int{4, 5, 6}
27 for _, v := range c {
28 fmt.Printf("%d\t", v)
29 }
30 fmt.Printf("\n")
31
32 // init way4
33 fmt.Println("----------")
34 type Currency int
35
36 const (
37 USD Currency = iota
38 EUR
39 GBP
40 RMB
41 )
42
43 symbol := [...]string{USD: "$", EUR: "€", GBP: "£", RMB: "¥"}
44 for _, v := range symbol {
45 fmt.Printf("%s\t", v)
46 }
47 fmt.Printf("\n")
48 }
运行结果如下
五. 访问
数组中的元素可通过下标进行访问
8 func main() {
9 arr := [3]string{"China", "America", "Japan"}
10 fmt.Printf("%s\n", arr[0])
11 fmt.Printf("%s\n", arr[1])
12 fmt.Printf("%s\n", arr[2])
13 }
运行结果如下
六. 使用
1.变量
作变量使用，这个没什么好说的了。
2.修改元素的值
1) 通过下标指定元素，对指定的元素进行修改
8 func main() {
9 a1 := [...]int{1, 2, 3}
10
11 for i, _ := range a1 {
12 a1[i] += 4
13 }
14
15 fmt.Printf("%d %d %d\n", a1[0], a1[1], a1[2])
16 }
运行结果如下
2) 笔者用过的错误的修改方式，有些想当然了。
Go中基本是值语义的，即是值传递的
for循环中，v是数组中元素的一个副本，对副本的修改不会对原始元素产生影响
8 func main() {
9 a1 := [...]int{1, 2, 3}
10
11 for _, v := range a1 {
12 v += 4
13 }
14
15 fmt.Printf("%d %d %d\n", a1[0], a1[1], a1[2])
16 }
运行结果如下，并未修改成功。
3.比较
如果一个数组的元素类型是可比较的，那这个数组也是可比较的。
8 func main() {
9 a1 := [...]int{1, 2, 3}
10 a2 := [...]int{1, 2, 4}
11 a3 := [3]int{1, 2, 3}
12 fmt.Printf("%t %t %t\n", a1 == a2, a1 == a3, a2 == a3)
13 }
运行结果如下
若两个数组的类型不一致，则不允许进行比较
14 a4 := [4]int{1, 2, 3, 4}
15 fmt.Printf("%t\n", a1 == a4)
编译时报错如下，提示无效操作
invalid operation: a1 == a4 (mismatched types [3]int and [4]int)
4.作函数参数
Go中，数组是值传递的。一般是传递一个数组的指针，这样有两个好处，一是对于较大的数组，效率较高； 二是可以对原数组进行修改。下面示例两种传参方式
1) 值传递，在被调用函数 modifyArrayElement 中，通过打印结果可以看到是修改成功了，但是这只是对传入的数组的副本进行了修改，对原始数组并未产生影响。
8 func modifyArrayElement(array [5]int) {
9 array[0] += 10
10 array[1] += 10
11 array[2] += 10
12 array[3] += 10
13 array[4] += 10
14
15 fmt.Println("...in function...")
16 for _, v := range array {
17 fmt.Println(v)
18 }
19 fmt.Println("...in function...")
20 }
21
22 func main() {
23 a1 := [...]int{1, 2, 3, 4, 5}
24 fmt.Println(a1)
25
26 modifyArrayElement(a1)
27 fmt.Println(a1)
28 }
运行结果如下
2) 指针传递，在被调用函数 modifyArrayElement 的参数中，传入的是长度为5的数组的指针，通过指针可以对原数组进行修改。代码第9行和第10行array前的解引用符号"*"可以省略，可进行隐式转化。
8 func modifyArrayElement(array *[5]int) {
9 for i, _ := range *array {
10 (*array)[i] += 10
11 }
12 }
13
14 func main() {
15 a1 := [...]int{1, 2, 3, 4, 5}
16 fmt.Println(a1)
17
18 modifyArrayElement(&a1)
19 fmt.Println(a1)
20 }
运行结果如下
5.赋值
可以将一个数组赋值给另一个数组
1) 将数组b赋值给数组a
8 func main() {
9 a := [...]int{1, 2, 3}
10 fmt.Println(a)
11 b := [3]int{4, 5, 6}
12
13 a = b
14 fmt.Println(a)
15 }
16
运行结果如下
2) 通过清零函数zero将传入的数组清零，对传入的数组指针进行解引用，然后对数组进行赋值，完成清零操作。
8 func zero(array *[5]int) {
9 *array = [5]int{}
10 }
11
12 func main() {
13 a := [...]int{1, 2, 3, 4, 5}
14 fmt.Println(a)
15
16 zero(&a)
17 fmt.Println(a)
18 }
运行结果如下
4.与slice结合使用
具体参考slice一文
七. 注意
1) 适用场景
适用于固定长度的序列，如使用SHA256加密散列生成的摘要，其长度为256位，即[32]byte。
2) 越界
在访问或修改数组中的元素时，注意越界的问题
示例代码
8 func main() {
9 a := [...]int{1, 2, 3, 4, 5}
10
11 fmt.Println(a)
12 fmt.Println(a[5])
13 }
编译时，提示无效的数组索引5
八.疑问
数组中的元素可以是哪些类型？
1) 基本类型
2) 数组类型
8 func main() {
9 // element type: int
10 a1 := [...]int{1, 2, 3, 4, 5}
11 a11 := [...]int{11, 22, 33, 44, 55}
12 a111 := [...]int{11, 22, 33, 44, 55}
13
14 // element type: string
15 a2 := [...]string{"aa", "bb", "cc", "dd", "ee"}
16
17 // element type: bool
18 a3 := [5]bool{true, false, false, false, false}
19
20 // element type: array
21 a4 := [3][5]int{a1, a11}
22
23 fmt.Println(a1)
24 fmt.Println(a11)
25 fmt.Println(a111)
26
27 fmt.Println("----------")
28 fmt.Println(a2)
29 fmt.Println(a3)
30 fmt.Println(a4)
31 }
运行结果如下
其它类型待完善
