Go|Go 语言数组 Go语言数组

Go 语言数组
引言
??数组是相同数据类型的一组数据的集合，数组一旦定义长度不能修改，数组可以通过下标（或者叫索引)来访问元素。
??相对于去声明 number0, number1, ..., number99 的变量，使用数组形式 numbers[0], numbers[1] ..., numbers[99] 更加方便且易于扩展。
数组元素可以通过索引（位置）来读取（或者修改），索引从0 开始，第一个元素索引为 0，第二个索引为1，以此类推。

文章图片

一、数组的定义 1. 语法

var variable_name [SIZE] variable_type

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

2. 示例

package mainimport "fmt"func main() { var a [3]int//定义一个int类型的数组a，长度是3 var b [2]string //定义一个字符串类型的数组b，长度是2 fmt.Printf("a: %T\n", a) //使用%T来输出类型 fmt.Printf("b: %T\n", b) fmt.Printf("a: %v\n", a) fmt.Printf("b: %v\n", b) }//输出结果如下，可以看到没初始化的值，int是0，而字符串则是空的字符串 a: [3]int b: [2]string a: [0 0 0] b: [ ]

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

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

package mainimport "fmt"func main() { var a [2]bool var b [2]int var c [3]string var d [3]float32 fmt.Printf("a: %v\n", a) fmt.Printf("b: %v\n", b) fmt.Printf("c: %v\n", c) fmt.Printf("d: %v\n", d)}//输出结果如下 a: [false false] b: [0 0] c: [] d: [0 0 0]

2. 使用初始化列表

package mainimport "fmt"func main() { var a = [3]int{1, 2, 3} var b = [2]string{"hello world"} var c = [2]bool{true, false} a1 := [2]int{1, 2} //类型推断 fmt.Printf("a: %v\n", a) fmt.Printf("b: %v\n", b) fmt.Printf("c: %v\n", c) fmt.Printf("a1: %v\n", a1) }//输出结果如下 a: [1 2 3] b: [hello world ] c: [true false] a1: [1 2]

使用初始化列表，就是将值写在大括号里面

3. 省略数组长度如果数组长度不确定，可以使用 ...代替数组的长度，编译器会根据元素个数自行推断数组的长度

package mainimport "fmt"func main() { var a = [...]int{1, 2, 3, 4, 5} var b = [...]string{"hello", "world", "hello", "go"} var c = [...]bool{true, false} a1 := [...]int{1, 2} //类型推断 fmt.Printf("a: %v\n", a) fmt.Printf("b: %v\n", b) fmt.Printf("c: %v\n", c) fmt.Printf("a1: %v\n", a1) }//输出结果如下 a: [1 2 3 4 5] b: [hello world hello go] c: [true false] a1: [1 2]

4. 指定索引值的方式来初始化可以通过指定所有方式来初始化，未指定的所有默认值为零值

package mainimport "fmt"func main() { var a = [...]int{0: 1, 2: 2} var b = [...]string{1: "hello", 2: "go"} var c = [...]bool{2: true, 5: false} a1 := [...]int{1, 2} //类型推断 fmt.Printf("a: %v\n", a) fmt.Printf("b: %v\n", b) fmt.Printf("c: %v\n", c) fmt.Printf("a1: %v\n", a1) }//输出结果如下 a: [1 0 2] b: [ hello go] c: [false false true false false false] a1: [1 2]

总结
初始化数组中{}中的元素个数不能大于[]中的数字。
如果忽略[]中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：
5. 访问数组元素数组元素可以通过索引（位置）来读取。
格式为数组名后加中括号，中括号中为索引的值。数组的最大下标为数组长度-1，大于这个下标会发生数组越界。
示例

package mainimport "fmt"func main() { var a [2]int a[0] = 100 a[1] = 200 fmt.Printf("a[0]: %v\n", a[0]) fmt.Printf("a[1]: %v\n", a[1]) //对数组进行修改 a[0] = 1 a[1] = 2 fmt.Println("---------修改后--------") fmt.Printf("a[0]: %v\n", a[0]) fmt.Printf("a[1]: %v\n", a[1]) }//输出结果如下 a[0]: 100 a[1]: 200 ---------修改后-------- a[0]: 1 a[1]: 2

文章图片

6. 根据数组长度遍历数组可以根据数组长度，通过for循环的方式来遍历数组，数组的长度可以使用len函数获得
使用len()函数获取数组的长度

package mainimport "fmt"func main() { var a1 = [3]int{1, 2, 3} fmt.Printf("len(a1): %v\n", len(a1)) var a2 = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9} fmt.Printf("len(a2): %v\n", len(a2)) }//输出结果如下 len(a1): 3 len(a2): 9

数组遍历，根据长度和下标

package mainimport "fmt"func main() { a := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9} for i := 0; i < len(a); i++ { fmt.Printf("a[%d]:%v\n", i, a[i]) } }//输出结果如下 a[0]:1 a[1]:2 a[2]:3 a[3]:4 a[4]:5 a[5]:6 a[6]:7 a[7]:8 a[8]:9

使用for range

package mainimport "fmt"func main() { var a = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9} for i, v := range a {//i也可以使用空白标识符代替，不接受索引的值 fmt.Printf("a[%v]:%v\n", i, v) } }//输出结果如下 a[0]:1 a[1]:2 a[2]:3 a[3]:4 a[4]:5 a[5]:6 a[6]:7 a[7]:8 a[8]:9

总结