Go 中的数组 - 芒果文档

Golang 或 Go 编程语言中的数组与其他编程语言非常相似。在程序中，有时我们需要存储一组相同类型的数据，比如学生成绩列表。这种类型的集合使用数组存储在程序中。数组是一个固定长度的序列，用于在内存中存储同构元素。由于它们的固定长度数组不像 Go 语言中的 Slice 那样受欢迎。
在数组中，您可以在其中存储零个或多个零个元素。数组的元素通过使用 [] 索引运算符及其从零开始的位置进行索引，这意味着第一个元素的索引是array[0] ，最后一个元素的索引是array[len(array)-1] .

golang中的数组

创建和访问数组

在 Go 语言中，数组以两种不同的方式创建：

使用 var 关键字：在 Go 语言中，使用具有名称、大小和元素的特定类型的 var 关键字创建数组。

句法：

Var array_name[length]Type
or
var array_name[length]Typle{item1, item2, item3, ...itemN}

要点：

在 Go 语言中，数组是可变的，因此您可以在赋值的左侧使用 array[index] 语法将数组的元素设置在给定的索引处。
```
Var array_name[index] = element
```
您可以通过使用索引值或使用 for 循环来访问数组的元素。
在 Go 语言中，数组类型是一维的。
数组的长度是固定不变的。

您可以在数组中存储重复的元素。

例子：

// Go program to illustrate how to 
// create an array using the var keyword 
// and accessing the elements of the
// array using their index value
package main
  
import "fmt"
  
func main() {
  
// Creating an array of string type 
// Using var keyword
var myarr[3]string
  
// Elements are assigned using index
myarr[0] = "GFG"
myarr[1] = "GeeksforGeeks"
myarr[2] = "Geek"
  
// Accessing the elements of the array 
// Using index value
fmt.Println("Elements of Array:")
fmt.Println("Element 1: ", myarr[0])
fmt.Println("Element 2: ", myarr[1])
fmt.Println("Element 3: ", myarr[2])
}

输出：

Elements of Array:
Element 1:  GFG
Element 2:  GeeksforGeeks
Element 3:  Geek

使用速记声明：在 Go 语言中，数组也可以使用速记声明进行声明。它比上面的声明更灵活。

句法：

array_name:= [length]Type{item1, item2, item3,...itemN}

例子：

// Go program to illustrate how to create
// an array using shorthand declaration 
// and accessing the elements of the 
// array using for loop
package main
  
import "fmt"
  
func main() {
  
// Shorthand declaration of array
arr:= [4]string{"geek", "gfg", "Geeks1231", "GeeksforGeeks"}
  
// Accessing the elements of 
// the array Using for loop
fmt.Println("Elements of the array:")
  
for i:= 0; i < 3; i++{
fmt.Println(arr[i])
}
  
}

输出：

Elements of the array:
geek
gfg
Geeks1231

多维数组

正如我们已经知道数组是一维的，但您可以创建一个多维数组。多维数组是相同类型数组的数组。在 Go 语言中，您可以使用以下语法创建多维数组：

Array_name[Length1][Length2]..[LengthN]Type

您可以使用 Var 关键字或使用速记声明创建多维数组，如下例所示。

注意：在多维数组中，如果一个单元格没有被用户初始化为某个值，那么它会被编译器自动初始化为零。 Golang 中没有未初始化的概念。

例子：

// Go program to illustrate the
// concept of multi-dimension array
package main
  
import "fmt"
  
func main() {
  
// Creating and initializing 
// 2-dimensional array 
// Using shorthand declaration
// Here the (,) Comma is necessary
arr:= [3][3]string{{"C#", "C", "Python"}, 
                   {"Java", "Scala", "Perl"},
                    {"C++", "Go", "HTML"},}
  
// Accessing the values of the 
// array Using for loop
fmt.Println("Elements of Array 1")
for x:= 0; x < 3; x++{
for y:= 0; y < 3; y++{
fmt.Println(arr[x][y])
}
}
  
// Creating a 2-dimensional
// array using var keyword
// and initializing a multi
// -dimensional array using index
var arr1 [2][2] int
arr1[0][0] = 100
arr1[0][1] = 200
arr1[1][0] = 300
arr1[1][1] = 400
  
// Accessing the values of the array
fmt.Println("Elements of array 2")
for p:= 0; p<2; p++{
for q:= 0; q<2; q++{
fmt.Println(arr1[p][q])
  
}
}
}

输出：

Elements of Array 1
C#
C
Python
Java
Scala
Perl
C++
Go
HTML
Elements of array 2
100
200
300
400

关于数组的重要观察

在数组中，如果数组未显式初始化，则该数组的默认值为 0 。

例子：

// Go program to illustrate an array
package main
  
import "fmt"
  
func main() {
  
// Creating an array of int type
// which stores, two elements
// Here, we do not initialize the 
// array so the value of the array
// is zero
var myarr[2]int 
fmt.Println("Elements of the Array :", myarr)
  
}

输出：

Elements of the Array : [0 0]

在数组中，您可以使用len() 方法找到数组的长度，如下所示：

例子：

// Go program to illustrate how to find
// the length of the array
package main
  
import "fmt"
  
func main() {
  
// Creating array
// Using shorthand declaration    
arr1:= [3]int{9,7,6}
arr2:= [...]int{9,7,6,4,5,3,2,4}
arr3:= [3]int{9,3,5}
  
// Finding the length of the 
// array using len method
fmt.Println("Length of the array 1 is:", len(arr1))
fmt.Println("Length of the array 2 is:", len(arr2))
fmt.Println("Length of the array 3 is:", len(arr3))
}

输出：

Length of the array 1 is: 3
Length of the array 2 is: 8
Length of the array 3 is: 3

在数组中，如果省略号 ”…”在 length 处可见，则数组的长度由初始化的元素决定。如下例所示：

例子：

// Go program to illustrate the
// concept of ellipsis in an array
package main
  
import "fmt"
  
func main() {
      
// Creating an array whose size is determined 
// by the number of elements present in it
// Using ellipsis
myarray:= [...]string{"GFG", "gfg", "geeks",
                    "GeeksforGeeks", "GEEK"}
  
fmt.Println("Elements of the array: ", myarray)
  
// Length of the array
// is determine by 
// Using len() method
fmt.Println("Length of the array is:", len(myarray))
}

输出：

Elements of the array:  [GFG gfg geeks GeeksforGeeks GEEK]
Length of the array is: 5

在数组中，您可以遍历数组元素的范围。如下例所示：

例子：

// Go program to illustrate 
// how to iterate the array
package main
  
import "fmt"
  
func main() {
      
// Creating an array whose size
// is represented by the ellipsis
myarray:= [...]int{29, 79, 49, 39,
                   20, 49, 48, 49}
  
// Iterate array using for loop
for x:=0; x < len(myarray); x++{
fmt.Printf("%d\n", myarray[x])
}
}

输出：

在 Go 语言中，数组是值类型而不是引用类型。所以当数组被赋值给一个新变量时，那么在新变量中所做的改变不会影响到原来的数组。如下例所示：

例子：

// Go program to illustrate value type array
package main
  
import "fmt"
  
func main() {
      
// Creating an array whose size 
// is represented by the ellipsis
my_array:= [...]int{100, 200, 300, 400, 500}
fmt.Println("Original array(Before):", my_array)
  
// Creating a new variable 
// and initialize with my_array
new_array := my_array
  
fmt.Println("New array(before):", new_array)
  
// Change the value at index 0 to 500
new_array[0] = 500
  
fmt.Println("New array(After):", new_array)
  
fmt.Println("Original array(After):", my_array)
}

输出：

Original array(Before): [100 200 300 400 500]
New array(before): [100 200 300 400 500]
New array(After): [500 200 300 400 500]
Original array(After): [100 200 300 400 500]

在数组中，如果数组的元素类型具有可比性，那么数组类型也具有可比性。所以我们可以直接使用 ==运算符比较两个数组。如下例所示：

例子：

// Go program to illustrate 
// how to compare two arrays
package main
  
import "fmt"
  
func main() {
  
// Arrays    
arr1:= [3]int{9,7,6}
arr2:= [...]int{9,7,6}
arr3:= [3]int{9,5,3}
  
// Comparing arrays using == operator
fmt.Println(arr1==arr2)
fmt.Println(arr2==arr3)
fmt.Println(arr1==arr3)
  
// This will give and error because the 
// type of arr1 and arr4 is a mismatch 
/*
arr4:= [4]int{9,7,6}
fmt.Println(arr1==arr4)
*/
}

输出：

true
false
false