苏公网安备
32050902101537号
Go语言教程之边写边学：数组array
数组是一种数据结构，由单个类型的元素集合组成，或者简单地说是一个特殊变量，它可以一次容纳多个值。数组保存的值称为其元素或项。数组包含特定数量的元素，并且它不能增长或收缩。不同的数据类型可以作为数组中的元素进行处理，例如Int、String、bool等。数组任何维度的第一个元素的索引为0，任何数组维度的第二个元素的索引为1，依此类推。
声明数组
package main
import (
"fmt"
"reflect"
)
func main() {
var intArray [5]int
var strArray [5]string
fmt.Println(reflect.ValueOf(intArray).Kind())
fmt.Println(reflect.ValueOf(strArray).Kind())
}输出
array
array
赋值和访问
您可以通过引用索引号来访问或赋值数组元素。索引在方括号中指定。
package main
import "fmt"
func main() {
var theArray [3]string
theArray[0] = "India"
theArray[1] = "Canada"
theArray[2] = "Japan"
fmt.Println(theArray[0])
fmt.Println(theArray[1])
fmt.Println(theArray[2])
}输出
India
Canada
Japan初始化数组
您可以初始化具有预定义值的数组。使用大括号和符合指定类型的元素初始化数组。
package main
import "fmt"
func main() {
x := [5]int{10, 20, 30, 40, 50}
var y [5]int = [5]int{10, 20, 30}
fmt.Println(x)
fmt.Println(y)
}输出
[10 20 30 40 50]
[10 20 30 0 0]初始化带有省略号的数组
当我们使用...而不是指定长度。编译器可以根据数组声明中指定的元素标识数组的长度。
package main
import (
"fmt"
"reflect"
)
func main() {
x := [...]int{10, 20, 30}
fmt.Println(reflect.ValueOf(x).Kind())
fmt.Println(len(x))
}输出
array
3初始化特定元素的值
当数组使用数组文本声明时，可以为特定元素初始化值。
值10分配给第二个元素（索引1），值30分配给第四个元素（索引3）。
package main
import "fmt"
func main() {
x := [5]int{1: 10, 3: 30}
fmt.Println(x)
}输出
[0 10 0 30 0]循环访问索引数组
可以使用for循环遍历数组元素。
package main
import "fmt"
func main() {
intArray := [5]int{10, 20, 30, 40, 50}
fmt.Println("\n---------------Example 1--------------------\n")
for i := 0; i < len(intArray); i++ {
fmt.Println(intArray[i])
}
fmt.Println("\n---------------Example 2--------------------\n")
for index, element := range intArray {
fmt.Println(index, "=>", element)
}
fmt.Println("\n---------------Example 3--------------------\n")
for _, value := range intArray {
fmt.Println(value)
}
j := 0
fmt.Println("\n---------------Example 4--------------------\n")
for range intArray {
fmt.Println(intArray[j])
j++
}
}拷贝数组
您可以通过按值或引用将数组分配给新变量来创建数组的副本。
package main
import "fmt"
func main() {
strArray1 := [3]string{"Japan", "Australia", "Germany"}
strArray2 := strArray1 // 传递值
strArray3 := &strArray1 // 传递引用
fmt.Printf("strArray1: %v\n", strArray1)
fmt.Printf("strArray2: %v\n", strArray2)
strArray1[0] = "Canada"
fmt.Printf("strArray1: %v\n", strArray1)
fmt.Printf("strArray2: %v\n", strArray2)
fmt.Printf("*strArray3: %v\n", *strArray3)
}输出
strArray1: [Japan Australia Germany]
strArray2: [Japan Australia Germany]
strArray1: [Canada Australia Germany]
strArray2: [Japan Australia Germany]
*strArray3: [Canada Australia Germany]检查元素是否存在
此Go程序检查数组中是否存在元素。该程序将数组和项目作为输入参数，并返回一个布尔值，指示该项目是否存在于数组中。
该程序使用Go中的反射包来确定输入数组的数据类型类型。如果输入不是数组，程序会死机并显示“无效的数据类型”错误。
程序中的itemExists()函数使用循环循环访问输入数组的元素。它使用反射的索引方法。值类型，用于访问每个索引处数组元素的值。然后，它使用reflect.Value方法将该值与输入项进行比较。如果找到匹配项，则该函数返回true，指示该项存在于数组中。如果未找到匹配项，则该函数返回false。
在 main 函数中，程序创建一个字符串数组并调用itemExists()函数两次，以检查数组中是否存在项“canada”和“Africa”。程序打印函数调用的返回值，这些值为true或false，具体取决于数组中是否存在这些项。
package main
import (
"fmt"
"reflect"
)
func main() {
strArray := [5]string{"India", "Canada", "Japan", "Germany", "Italy"}
fmt.Println(itemExists(strArray, "Canada"))
fmt.Println(itemExists(strArray, "Africa"))
}
func itemExists(arrayType interface{}, item interface{}) bool {
arr := reflect.ValueOf(arrayType)
if arr.Kind() != reflect.Array {
panic("Invalid data-type")
}
for i := 0; i < arr.Len(); i++ {
if arr.Index(i).Interface() == item {
return true
}
}
return false
}输出
true
false筛选数组元素
您可以使用以下方法过滤数组元素 : 如下所示
值10分配给第二个元素（索引 1），值30分配给第四个元素（索引 3）。
package main
import "fmt"
func main() {
countries := [...]string{"India", "Canada", "Japan", "Germany", "Italy"}
fmt.Printf("Countries: %v\n", countries)
fmt.Printf(":2 %v\n", countries[:2])
fmt.Printf("1:3 %v\n", countries[1:3])
fmt.Printf("2: %v\n", countries[2:])
fmt.Printf("2:5 %v\n", countries[2:5])
fmt.Printf("0:3 %v\n", countries[0:3])
fmt.Printf("Last element: %v\n", countries[len(countries)-1])
fmt.Printf("All elements: %v\n", countries[0:len(countries)])
fmt.Println(countries[:])
fmt.Println(countries[0:])
fmt.Println(countries[0:len(countries)])
fmt.Printf("Last two elements: %v\n", countries[len(countries)-2:len(countries)])
}输出
Countries: [India Canada Japan Germany Italy]
:2 [India Canada]
1:3 [Canada Japan]
2: [Japan Germany Italy]
2:5 [Japan Germany Italy]
0:3 [India Canada Japan]
Last element: Italy
All elements: [India Canada Japan Germany Italy]
[India Canada Japan Germany Italy]
[India Canada Japan Germany Italy]
[India Canada Japan Germany Italy]
Last two elements: [Germany Italy]