A brief analysis of arrays in Golang

This article will teach you about Golang and talk about arrays in the basics of Go language. I hope it will be helpful to you.

[Programming tutorial recommendation: Programming Teaching]

1. Array definition:

An array is a collection of elements of the same data type. In the Go language, the array is determined from the time of declaration, and the array members can be modified during use, but the size of the array cannot be changed. Basic syntax:

// 定义一个长度为3元素类型为int的数组a
var a [3]int

The length of the group must be constant and the length is part of the array type. Once defined, the length cannot be changed.

var a [3]int
var b [4]int
a = b //不可以这样做，因为此时a和b是不同的类型

The array can be accessed through the subscript. The subscript starts from 0. The last element subscript is: len-1. The access is out of bounds (subscript outside the legal range), an out-of-bounds access is triggered and panic occurs.

2. Initialization of array

①When initializing an array, you can use the initialization list to set the value of the array element.

func main() {
	var testArray [3]int                        //数组会初始化为int类型的零值
	var numArray = [3]int{1, 2}                 //使用指定的初始值完成初始化
	var cityArray = [3]string{"北京", "上海", "深圳"} //使用指定的初始值完成初始化
	fmt.Println(testArray)                      //[0 0 0]
	fmt.Println(numArray)                       //[1 2 0]
	fmt.Println(cityArray)                      //[北京 上海 深圳]
}

② Follow the above method to ensure that the initial value provided is consistent with the length of the array. Generally, we can let the compiler infer the length of the array based on the number of initial values.

func main() {
	var testArray [3]int
	var numArray = [...]int{1, 2}
	var cityArray = [...]string{"北京", "上海", "深圳"}
	fmt.Println(testArray)                          //[0 0 0]
	fmt.Println(numArray)                           //[1 2]
	fmt.Printf("type of numArray:%T\n", numArray)   //type of numArray:[2]int
	fmt.Println(cityArray)                          //[北京 上海 深圳]
	fmt.Printf("type of cityArray:%T\n", cityArray) //type of cityArray:[3]string
}

We can also initialize the array by specifying the index value

func main() {
	a := [...]int{1: 1, 3: 5}
	fmt.Println(a)                  // [0 1 0 5]
	fmt.Printf("type of a:%T\n", a) //type of a:[4]int
}

3. Array traversal

There are two ways to traverse array a Method:

func main() {
	var a = [...]string{"北京", "上海", "深圳"}
	// 方法1：for循环遍历
	for i := 0; i < len(a); i++ {
		fmt.Println(a[i])
	}

	// 方法2：for range遍历
	for index, value := range a {
		fmt.Println(index, value)
	}
}

4. Multi-dimensional array

The Go language supports multi-dimensional arrays. Here we take a two-dimensional array as an example (arrays are nested within arrays).

Definition of two-dimensional array

func main() {
	a := [3][2]string{
		{"北京", "上海"},
		{"广州", "深圳"},
		{"成都", "重庆"},
	}
	fmt.Println(a) //[[北京 上海] [广州 深圳] [成都 重庆]]
	fmt.Println(a[2][1]) //支持索引取值:重庆
}

Traversal of two-dimensional array

func main() {
	a := [3][2]string{
		{"北京", "上海"},
		{"广州", "深圳"},
		{"成都", "重庆"},
	}
	for _, v1 := range a {
		for _, v2 := range v1 {
			fmt.Printf("%s\t", v2)
		}
		fmt.Println()
	}
}


输出：

北京	上海	
广州	深圳	
成都	重庆

Note: Multidimensional arrayOnly the first level can use ... to let the compiler deduce the array length

//支持的写法
a := [...][2]string{
	{"北京", "上海"},
	{"广州", "深圳"},
	{"成都", "重庆"},
}
//不支持多维数组的内层使用...
b := [3][...]string{
	{"北京", "上海"},
	{"广州", "深圳"},
	{"成都", "重庆"},

5. The array is a value type

Arrays are value types, and assignment and parameter passing will copy the entire array. Therefore, changing the value of the copy will not change the value of itself.

func modifyArray(x [3]int) {
	x[0] = 100
}

func modifyArray2(x [3][2]int) {
	x[2][0] = 100
}
func main() {
	a := [3]int{10, 20, 30}
	modifyArray(a) //在modify中修改的是a的副本x
	fmt.Println(a) //[10 20 30]
	b := [3][2]int{
		{1, 1},
		{1, 1},
		{1, 1},
	}
	modifyArray2(b) //在modify中修改的是b的副本x
	fmt.Println(b)  //[[1 1] [1 1] [1 1]]
}

tips:

• Arrays support the "==", "!=" operators because the memory is always initialized.

• [n]*T represents a pointer array, *[n]T represents an array pointer.

##End:

Remind me again that students who need to join the

technical exchange group can add me on WeChat fangdongdong_25, if you need to join the front-end engineer communication group , please note "front-end" , if you need to join the go back-end communication group, , please note "go back-end"

【 Related recommendations:

Go video tutorial】

The above is the detailed content of A brief analysis of arrays in Golang. For more information, please follow other related articles on the PHP Chinese website!