【Go】24、golang数组

• 数组是相同数据类型的一组数据的集合，数组一旦定义长度不能修改，数组可以通过下标(或者叫索引)来访问元素

1、go语言数组的定义

var variable_name [SIZE] variable_type

• variable_name：数组名称
• SIZE：数组长度，必须是常量
• variable_type：数组保存元素的类型

2、实例

func test1() {
	var a1 [2]int // 定义数组
	var a2 [3]string

	fmt.Printf("a1: %T\n", a1)
	fmt.Printf("a2: %T\n", a2)
	fmt.Printf("a1: %v\n", a1)
	fmt.Printf("a2: %v\n", a2)
}

func main() {
	test1()
}
# 输出结果
    a1: [2]int
    a2: [3]string
    a1: [0 0]
    a2: [  ]

• 从上面运行结果，我们可以看出，数组长度和元素类型共同组成了数组的类型

3、go语言数组的初始化

• 初始化，就是给数组的元素赋值，默认元素都是零值，布尔类型是false，字符串是空字符串
• 没有初始化的数组

func test1() {
	var a1 [2]int // 定义数组
	var a2 [3]string
	var a3 [2]bool

	fmt.Printf("a1: %T\n", a1)
	fmt.Printf("a2: %T\n", a2)
	fmt.Printf("a1: %v\n", a1)
	fmt.Printf("a2: %v\n", a2)
	fmt.Printf("a3: %T\n", a3)
	fmt.Printf("a3: %v\n", a3)
}

func main() {
	test1()
}
# 输出结果
    a1: [2]int
    a2: [3]string
    a1: [0 0]
    a2: [  ]
    a3: [2]bool
    a3: [false false]

3.1、数组初始化的第一种方式：初始化数组时可以使用初始化列表来设置数组元素的值

var variable_name = [SIZE]variable_type{元素值}
# 如果元素值小于设置的SIZE长度，默认元素都是零值，布尔类型是false，字符串是空字符串来补充

func test2() {
	// 数组的初始化
	var a1 = [2]int{1, 2}
	fmt.Printf("a1: %v\n", a1)

	var a2 = [3]int{1, 2}
	fmt.Printf("a2: %v\n", a2)

	var a3 = [2]string{"tom", "1"}
	fmt.Printf("a3: %v\n", a3)

	var a4 = [2]bool{true, false}
	fmt.Printf("a4: %v\n", a4)
}

func main() {
	test2()
}
# 输出结果：
    a1: [1 2]
    a2: [1 2 0]
    a3: [tom 1]
    a4: [true false]

3.2、省略数组长度初始化

• 按照上面的方法每次都要确保提供的初始值和数组长度一致，一般情况下我们可以让编译器根据初始值的个数自行推断数组的长度

var variable_name = [...]variable_type{元素值}

func test3() {
	// 省略数组长度
	var b1 = [...]int{1, 2}
	fmt.Printf("b1: %v\n", b1)

	var b2 = [...]string{"name", "age"}
	fmt.Printf("b2: %v\n", b2)

	b3 := [...]bool{false, true}
	fmt.Printf("b3: %v\n", b3)
}

func main() {
	test3()
}
# 输出结果：
    b1: [1 2]
    b2: [name age]
    b3: [false true]

3.3、指定索引值的方式来初始化

• 可以通过指定索引的方式来初始化，未指定所有的默认为零值；布尔类型是false，字符串是空字符串来补充

var variable_name = [...]variable_type{索引下标:元素值}

func test4() {
	// 指定索引值的方式来初始化数组
	var c1 = [...]int{0: 1, 3: 100, 5: 10}
	fmt.Printf("c1: %v\n", c1) // [1 0 0 100 0 10]
	var c2 = [...]bool{2: true, 5: false}
	fmt.Printf("c2: %v\n", c2)
	var c3 = [...]string{1: "tom", 4: "lilei"}
	fmt.Printf("c3: %v\n", c3)
}

func main() {
	test4()
}
# 输出结果：
    c1: [1 0 0 100 0 10]
    c2: [false false true false false false]
    c3: [ tom   lilei]