Golang 菜鸟教程

Golang 控制语句

Golang 函数 & 方法

Golang 结构体

Golang 切片 & 数组

Golang 字符串(String)

Golang 指针

Golang 接口

Golang 并发

Golang 异常(Error)

Golang 其他杂项

Go 数组复制 Go 函数用作结构体字段

Go 语言数组

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

golang中的数组

创建和访问数组

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

使用var关键字：在Go语言中，使用具有名称，大小和元素的特定类型的var关键字创建数组。
语法：
```
Var array_name[length]Type
或
var array_name[length]Typle{item1, item2, item3, ...itemN}
```
重要事项：

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

示例

//使用var关键字创建一个数组
//使用其索引值访问数组
package main

import "fmt"

func main() {

    //使用var关键字，创建一个字符串类型的数组
    var myarr [3]string

    //使用索引分配元素
    myarr[0] = "GFG"
    myarr[1] = "www.cainiaoplus.com"
    myarr[2] = "nhooo"

    //访问数组的元素
    //使用索引值
    fmt.Println("数组的元素:")
    fmt.Println("元素 1: ", myarr[0])
    fmt.Println("元素 2: ", myarr[1])
    fmt.Println("元素 3: ", myarr[2])
}

输出：

数组的元素:
元素 1:  GFG
元素 2:  www.cainiaoplus.com
元素 3:  nhooo

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

语法：

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

示例

//使用简写声明的数组
//使用for循环访问数组
package main

import "fmt"

func main() {

    //数组的简写声明
    arr := [4]string{"nhooo", "gfg", "nhooos1231", "www.cainiaoplus.com"}

    //访问的元素,使用for循环的数组
    fmt.Println("数组的元素:")

    for i := 0; i < 3; i++ {
        fmt.Println(arr[i])
    }

}

输出：

数组的元素:
nhooo
gfg
nhooos1231

多维数组

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

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

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

注意：在多维数组中，如果用户未使用某个值初始化单元格，则编译器将自动将其初始化为零。Golang中没有未初始化的概念。

示例

package main

import "fmt"

func main() {

    //创建和初始化
    //二维数组
    //使用简写声明
    //这里需要用（，）逗号
    arr := [3][3]string{{"C#", "C", "Python"},
        {"Java", "Scala", "Perl"},
        {"C++", "Go", "HTML"}}

    //访问的值
    //数组使用for循环
    fmt.Println("数组的元素 1")
    for x := 0; x < 3; x++ {
        for y := 0; y < 3; y++ {
            fmt.Println(arr[x][y])
        }
    }

    //创建二维数组
    //使用var关键字的数组
    //并初始化一个
    //使用索引的维数组
    var arr1 [2][2]int
    arr1[0][0] = 100
    arr1[0][1] = 200
    arr1[1][0] = 300
    arr1[1][1] = 400

    //访问数组的值
    fmt.Println("数组的元素 2")
    for p := 0; p < 2; p++ {
        for q := 0; q < 2; q++ {
            fmt.Println(arr1[p][q])

        }
    }
}

输出：

数组的元素 1
C#
C
Python
Java
Scala
Perl
C++
Go
HTML
数组的元素 2
100
200
300
400

关于数组的注意事项

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

示例

package main 
  
import "fmt"
  
func main() { 
  
//创建一个int类型的数组,存储两个元素
//在这里，我们不初始化数组，所以数组的值为零
var myarr[2]int 
fmt.Println("数组元素 :", myarr) 
  
}

输出：

数组元素 : [0 0]

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

示例

package main

import "fmt"

func main() {

    //创建数组
    //使用简写声明
    arr1 := [3]int{9, 7, 6}
    arr2 := [...]int{9, 7, 6, 4, 5, 3, 2, 4}
    arr3 := [3]int{9, 3, 5}

    // 使用len方法计算数组大小
    fmt.Println("数组1的长度是:", len(arr1))
    fmt.Println("数组2的长度是:", len(arr2))
    fmt.Println("数组3的长度是:", len(arr3))
}

输出：

数组1的长度是: 3
数组2的长度是: 8
数组3的长度是: 3

在数组中，如果省略号“ ...”在长度位置处可见，则数组的长度由初始化的元素确定。如下例所示：

示例

//数组中省略号的使用方法
package main

import "fmt"

func main() {

    //创建大小已确定的数组
    //根据其中元素的数量
    //使用省略号
    myarray := [...]string{"GFG", "gfg", "nhooos", "www.cainiaoplus.com", "nhooo"}

    fmt.Println("数组元素: ", myarray)

    //数组的长度
    //由...决定
    //使用len()方法
    fmt.Println("数组的长度为:", len(myarray))
}

输出：

数组元素:  [GFG gfg nhooos www.cainiaoplus.com nhooo]
数组的长度为: 5

在数组中，允许您在array 的元素范围内进行迭代。如下例所示：

示例

//如何迭代数组
package main

import "fmt"

func main() {

    //创建一个数组，其大小
    //用省略号表示
    myarray := [...]int{29, 79, 49, 39, 20, 49, 48, 49}

    //使用for循环迭代数组
    for x := 0; x < len(myarray); x++ {
        fmt.Printf("%d\n", myarray[x])
    }
}

输出：

在Go语言中，数组的值类型不是引用类型。因此，当将数组分配给新变量时，在新变量中所做的更改不会影响原始数组。如下例所示：

示例

package main

import "fmt"

func main() {

    //创建一个数组，其大小
    //用省略号表示
    my_array := [...]int{100, 200, 300, 400, 500}
    fmt.Println("原始数组(改变前):", my_array)

    //创建一个新变量
    //并使用my_array进行初始化
    new_array := my_array

    fmt.Println("新数组(改变前):", new_array)

    //将索引0处的值更改为500
    new_array[0] = 500

    fmt.Println("新数组(改变后):", new_array)

    fmt.Println("原始数组(改变后):", my_array)
}

输出：

原始数组(改变前): [100 200 300 400 500]
新数组(改变前): [100 200 300 400 500]
新数组(改变后): [500 200 300 400 500]
原始数组(改变后): [100 200 300 400 500]

在数组中，如果数组的元素类型是可比较的，则数组类型也是可比较的。因此，我们可以使用==运算符直接比较两个数组。如下例所示：

示例

//如何比较两个数组
package main

import "fmt"

func main() {

    arr1 := [3]int{9, 7, 6}
    arr2 := [...]int{9, 7, 6}
    arr3 := [3]int{9, 5, 3}

    //使用==运算符比较数组
    fmt.Println(arr1 == arr2)
    fmt.Println(arr2 == arr3)
    fmt.Println(arr1 == arr3)

    //这将给出和错误，因为
    // arr1和arr4的类型不匹配
    /*
       arr4:= [4]int{9,7,6}
       fmt.Println(arr1==arr4)
    */
}

输出：

true
false
false

Go 数组复制 Go 函数用作结构体字段