数组
作为后端开发语言，可能数组用的是最多的了。
数组是指一系列同一类型数据的集合。数组中包含的每个数据被称为数组元素（element），一个数组包含的元素个数被称为数组的长度。
数组⻓度必须是常量，且是类型的组成部分。 [2]int 和 [3]int 是不同类型。
定义：
var b [10]int
v：= [10] int
//注意：定义数组时，指定的数组元素个数必须是常量
//n := 10
//var c [n]int //err non-constant array bound n
通过下标访问：len()获取数组的长度
id := [50]int
//操作数组，通过下标， 从0开始，到len()-1
for i := 0; i < len(id); i++ {
id[i] = i + 1
fmt.Printf("id[%d] = %d\n", i, id[i])
}
初始化，没有初始化的就是0
//全部初始化或部分初始化
id := [50]int{1,2,3,4,5} //前面5个赋值，后面全是0
//指定某个元素初始化
d := [5]int{2: 10, 4: 20} //d = [0 0 10 0 20]
b := [...]int{1, 2, 3} // 通过初始化值确定数组长度
多维数组
package main //必须有个main包
import "fmt"
func main() {
//有多少个[]就是多少维
//有多少个[]就用多少个循环
var a [3][4]int
k := 0
for i := 0; i < 3; i++ {
for j := 0; j < 4; j++ {
k++
a[i][j] = k
fmt.Printf("a[%d][%d] = %d, ", i, j, a[i][j])
}
fmt.Printf("\n")
}
/*
a[0][0] = 1, a[0][1] = 2, a[0][2] = 3, a[0][3] = 4,
a[1][0] = 5, a[1][1] = 6, a[1][2] = 7, a[1][3] = 8,
a[2][0] = 9, a[2][1] = 10, a[2][2] = 11, a[2][3] = 12,
*/
fmt.Println("a = ", a)//a = [[1 2 3 4] [5 6 7 8] [9 10 11 12]]
//多维数组初始化
//有3个元素，每个元素又是一维数组[4]int
b := [3][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}
fmt.Println("b = ", b)
//部分初始化，没有初始化的值为0
c := [3][4]int{{1, 2, 3}, {5, 6, 7, 8}, {9, 10}}
fmt.Println("c = ", c)//c = [[1 2 3 0] [5 6 7 8] [9 10 0 0]]
d := [3][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}}
fmt.Println("d = ", d)//d = [[1 2 3 4] [5 6 7 8] [0 0 0 0]]
e := [3][4]int{1: {5, 6, 7, 8}}
fmt.Println("e = ", e)//e = [[0 0 0 0] [5 6 7 8] [0 0 0 0]]
}
数组遍历
//for循环遍历
for i := 0; i < len(a); i++ {
fmt.Printf("a[%d] = %d\n", i, a[i])
}
//迭代器遍历
//第一个返回下标，第二个返回元素
for i, data := range a {
fmt.Printf("a[%d] = %d\n", i, data)
}
数组的比较和赋值
package main //必须有个main包
import "fmt"
func main() {
//支持比较，只支持 == 或 !=, 比较是不是每一个元素都一样，2个数组比较，数组类型要一样
a := [5]int{1, 2, 3, 4, 5}
b := [5]int{1, 2, 3, 4, 5}
c := [5]int{1, 2, 3}
fmt.Println(" a == b ", a == b) //a == b true
fmt.Println(" a == c ", a == c) //a == c false
//同类型的数组可以赋值
var d [5]int
d = a
fmt.Println("d = ", d)
}
数组做参数
package main
import "fmt"
func main() {
/* 数组长度为 5 */
var balance = [5]int {1000, 2, 3, 17, 50}
var avg float32
/* 数组作为参数传递给函数 */
avg = getAverage( balance, 5 ) ;
/* 输出返回的平均值 */
fmt.Printf( "平均值为: %f ", avg );
}
func getAverage(arr [5]int, size int) float32 {
var i,sum int
var avg float32
for i = 0; i < size;i++ {
sum += arr[i]
}
avg = float32(sum) / float32(size)
return avg;
}
数组指针
一个int需要8套别墅，8个int需要64套别墅，一样的道理，只需要告诉别人首地址，然后后面64套都是我的，别人怎么知道64？因为通过类型和长度可以推导出来。
package main //必须有个main包
import "fmt"
func modify(p *[5]int) {
(*p)[0] = 666
fmt.Println("modify *a = ", *p) //modify *a = [666 2 3 4 5]
}
func main() {
a := [5]int{1, 2, 3, 4, 5} //初始化
modify(&a) //地址传递
fmt.Println("main: a = ", a) //main: a = [666 2 3 4 5]
}
这里数组指针做函数参数就很明显可以看出来，是传引用（地址传递），而数组做参数是值传递。
网友评论