go语法--基础11--数组

一、 数组

1. 数组是具有相同唯一类型的一组已编号且长度固定的数据项序列
2. 类型可以是任意的原始类型,举例如下
   1. 整型
   2. 字符串
   3. 自定义类型
3. 数组元素可以通过索引（位置）来读取（或者修改
4. 索引从 0 开始

二、声明数组

语法

var variable_name [SIZE] variable_type

举例–定义数组 balance 长度为 10 类型为 float32：

var balance [10] float32

三、初始化数组

以下演示了数组初始化：

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

我们也可以通过字面量在声明数组的同时快速初始化数组：

balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

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

var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

或

balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

如果设置了数组的长度，我们还可以通过指定下标来初始化元素：

//  将索引为 1 和 3 的元素初始化
balance := [5]float32{1:2.0,3:7.0}

初始化数组中 {} 中的元素个数不能大于 [] 中的数字。

如果忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：

设置（或读取）第五个元素的值

balance[4] = 50.0

四、举例

package main

import "fmt"

func main() {

	//长度为 10 的数组
	var iArr [10]int

	//设置值
	for k := 0; k < 10; k++ {
		iArr[k] = k;
	}

	fmt.Println("-------------输出值-------------");
	for k := 0; k < 10; k++ {
		fmt.Println("iArr:", iArr[k]);
	}

	fmt.Println("-------------声明数组的同时快速初始化数组-------------");
	balance := [5]int{1, 2, 3, 4, 5}

	for k := 0; k < 5; k++ {
		fmt.Println("balance:", balance[k]);
	}
	fmt.Println("-------------不设置数组大小-------------");
	balance2 := [...]int{1, 2, 3, 4, 5}
	for k := 0; k < 5; k++ {
		fmt.Println("balance2:", balance2[k]);
	}

	fmt.Println("-------------将索引为 1 和 3 的元素初始化-------------");
	balance3 := [5]int{1: 1, 3: 3}
	for k := 0; k < 5; k++ {
		fmt.Println("balance3:", balance3[k]);
	}

}
-------------输出值-------------
iArr: 0
iArr: 1
iArr: 2
iArr: 3
iArr: 4
iArr: 5
iArr: 6
iArr: 7
iArr: 8
iArr: 9
-------------声明数组的同时快速初始化数组-------------
balance: 1
balance: 2
balance: 3
balance: 4
balance: 5
-------------不设置数组大小-------------
balance2: 1
balance2: 2
balance2: 3
balance2: 4
balance2: 5
-------------将索引为 1 和 3 的元素初始化-------------
balance3: 0
balance3: 1
balance3: 0
balance3: 3
balance3: 0

五、多维数组

声明方式：

var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type

以下实例声明了三维的整型数组：

var threedim [5][10][4]int

5.1、二维数组

声明方式

var arrayName [ x ][ y ] variable_type

举例

package main

import "fmt"

func main() {
	arr1:=[][]int{}


	// Step 2: 使用 appped() 函数向空的二维数组添加两行一维数组
	row1 := []int{1, 2, 3}
	row2 := []int{4, 5, 6}
	arr1 = append(arr1, row1)
	arr1 = append(arr1, row2)

	for k, v := range arr1 {
		fmt.Println("一维k:", k,"一维v:", v);
		for k, v := range v {
			fmt.Println("	二维k:", k,"二维v:", v);
		}
		fmt.Println();
	}

}

输出
一维k: 0 一维v: [1 2 3]
	二维k: 0 二维v: 1
	二维k: 1 二维v: 2
	二维k: 2 二维v: 3

一维k: 1 一维v: [4 5 6]
	二维k: 0 二维v: 4
	二维k: 1 二维v: 5
	二维k: 2 二维v: 6

初始化

arr2:=[][]int{
	{1,2,3},
	{4,5,6},
}

arr2倒数第二行的 } 必须要有逗号，因为最后一行的 } 不能单独一行，也可以写成这样

arr3:=[][]int{
	{1,2,3},
	{4,5,6}}

六、向函数传递数组

就是函数的参数是数组类型

package main

func main() {

	arr := []int{1, 2, 3}
	i2 := getSum(arr)

	println("i2=", i2)

}

//向函数传递数组
func getSum(arr []int) int {

	var sum int = 0;
	for i := range arr {
		sum = sum + arr[i];
	}
	return sum
}
输出
i2= 6

七、数组是值类型

package main

import "fmt"

func main() {

	var arr = [5]int{1, 2, 3, 4, 5}
	fmt.Println("--------第一次打印的值---------")
	show(arr)
	fmt.Println("--------函数中修改数组的值---------")
	setValue(arr)
	show(arr)
}

//显示所有数据
func show(arr [5]int) {
	fmt.Println("arr:", arr)
}

//设置值
func setValue(arr [5]int) {
	arr[0] = 111
}

输出

--------第一次打印的值---------
arr: [1 2 3 4 5]
--------函数中修改数组的值---------
arr: [1 2 3 4 5]

---