高朗 阵列

数组是一种数据结构,由一个单一类型的元素集合组成,或者简单地说就是一个特殊变量,一次可以容纳多个值。数组保存的值称为其 元素或项目 。数组包含特定数量的元素,并且不能增长或收缩。可以将不同的数据类型作为数组中的元素来处理,例如 品脱 , , 布尔型 , 和别的。数组任意维度的第一个元素的索引为0,数组任意维度的第二个元素的索引为1,依此类推。


在Go中声明五个元素的整数或字符串数​​组

要声明数组,您需要在方括号([])中指定其持有的元素数量,然后是该数组持有的元素类型。

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

如何在Go中分配和访问数组元素值?

您可以通过引用索引号来访问或分配数组元素。索引在方括号中指定。

package main

import "fmt"

func main() {
	var theArray [3]string
	theArray[0] = "India"  // Assign a value to the first element
	theArray[1] = "Canada" // Assign a value to the second element
	theArray[2] = "Japan"  // Assign a value to the third element

	fmt.Println(theArray[0]) // Access the first element value
	fmt.Println(theArray[1]) // Access the second element valu
	fmt.Println(theArray[2]) // Access the third element valu
}
India
Canada
Japan

如何在Go中使用数组文字初始化数组?

您可以使用数组文字使用预定义的值初始化数组。数组文字包含要放在方括号中的元素数量,其后是元素的类型。紧随其后的是一列初始值,并用花括号内的每个元素的逗号分隔。

package main

import "fmt"

func main() {
	x := [5]int{10, 20, 30, 40, 50}   //  品脱 ialized with values
	var y [5]int = [5]int{10, 20, 30} // Partial assignment

	fmt.Println(x)
	fmt.Println(y)
}
[10 20 30 40 50]
[10 20 30 0 0]

在Go中使用椭圆初始化数组

当我们使用...而不是指定长度时。编译器可以根据数组声明中指定的元素来标识数组的长度。

package main

import (
	"fmt"
	"reflect"
)

func main() {
	x := [...]int{10, 20, 30}

	fmt.Println(reflect.ValueOf(x).Kind())
	fmt.Println(len(x))
}
array
3

在Go中初始化特定数组元素的值

当数组使用数组文字声明时,可以为特定元素初始化值。

将值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")
	 对于  i := 0; i < len(intArray); i++ {
		fmt.Println(intArray[i])
	}

	fmt.Println("\n---------------Example 2--------------------\n")
	 对于  index, element := range intArray {
		fmt.Println(index, "=>", element)

	}

	fmt.Println("\n---------------Example 3--------------------\n")
	 对于  _, value := range intArray {
		fmt.Println(value)
	}

	j := 0
	fmt.Println("\n---------------Example 4--------------------\n")
	 对于  range intArray {
		fmt.Println(intArray[j])
		j++
	}
}

按值复制数组并引用到另一个数组中

通过按值或引用将数组分配给新变量,可以创建数组的副本。

package main

import "fmt"

func main() {

	strArray1 := [3]string{"Japan", "Australia", "Germany"}
	strArray2 := strArray1  // data is passed by value
        strArray3 := &strArray1 // data is passed by refrence

	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]

高朗 检查数组元素是否存在

为了确定数组中是否存在特定元素,我们需要使用for循环迭代每个数组元素,并使用if条件进行检查。

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")
	}

	 对于  i := 0; i < arr.Len(); i++ {
		if arr.Index(i).Interface() == item {
			return true
		}
	}

	return false
}
true
false

在Go中过滤数组元素的技巧

您可以使用以下方法过滤数组元素 : 如下所示

将值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]