这篇博客涵盖了Golangauage中数组的初级指南和实例。
Golang数组简介
数组是一种数据结构，它包含了一个元素的集合，这些元素被称为相同的名字，并被归入相同的数据类型。它的长度是固定的。
以下是本篇文章涉及的主题
- 阵列语法
- 数组声明
- 用数组字样声明
- 用数组的椭圆进行初始化
- 访问数组中的元素
- 数组的大小
- 使用for循环和range关键字对元素进行迭代
- 用字词创建多维数组，速记语法
- 阵列结构或对象的例子 - 创建、访问、迭代
- 寻找数组变量类型
- 数组类型不能用不同的长度来分配
- 数组是价值类型
- 线性搜索实例
- 流行的数组运行时错误
以下是Go语言中数组的一些主要特点
- 数组包含一个以相同数据类型的顺序存储的元素列表。
- 数组的大小是固定的
- 数组中的元素是按顺序存储的，可以用索引0访问。
- 声明一个数组的变量时，应与普通变量一样，在数据类型前加上[]。
- 使用sizeof()方法可以找到数组的长度。
数组可以包含原始类型和自定义类型。存储在内存中的值是并排的。数组可以是单维或多维数组。
Golang中的数组语法
数组可以创建单维或多维的数组。
var variable-name [size]datatype // single dimensional array
var variable-name [size][size]datatype // Multi dimensional array
var 是Golang中的一个关键字，用于声明一个变量variable-name 是变量的名称,size 是一个固定大小的数组， datatype可以是一个原始类型或自定义类型。
如何在Golang中声明和创建一个数组？
数组声明包含var 关键字，variable 名称和datatype 。
我们可以声明一个固定大小为n的T类型的数组。
一旦一个数组的大小被声明为n，大小将不会增长，因为这是固定的。
让我们看一个声明大小为5的整数阵的例子
以下是声明数组的例子
package main
import "fmt"
func main() {
// An array with 5 integers
var v1 [5]int
fmt.Println(v1)
// An array of 5 float
var v2 [5]float64
fmt.Println(v2)
// An array of 5 boolean
var v3 [5]bool
fmt.Println(v3)
// An array of 5 string
var v4 [5]string
fmt.Println(v4)
// An array of 5 byte
var v5 [5]byte
fmt.Println(v5)
// An array with 5 complex numbers
var v6 [5]complex128
fmt.Println(v6)
}
上述程序的输出是
[0 0 0 0 0]
[0 0 0 0 0]
[false false false false false]
[ ]
[0 0 0 0 0]
[(0+0i) (0+0i) (0+0i) (0+0i) (0+0i)]
在上面的程序中:
- 一个数组被声明为不同的类型
- 数组没有被赋值，因此，Go编译器假定并为数组类型的每个元素分配默认的零值。
- 零值是指数字值，布尔值是指假值，字符串是指空字符串，复数128是指(0+0i)值。
如何声明数组并使用数组文字进行初始化？
有时，一个数组的大小和元素的类型已经知道，可以使用数组字面。
这是另一种在一个步骤中创建和初始化数值的方法。
// Declare and initialize array values
var arr = [5]int{21, 3, 1, 4, 2}
它包含两个部分:
- 左边的部分包含了数组变量的名称。
- 右手边的部分称为数组字面。
- 这里的数组变量没有用arr [5]int声明，编译器可以从数组值中推断出来。
- 同样可以用速记的数组变量声明语法来重写。
- 这里var没有像任何变量声明那样被声明，数组变量是用这种语法声明和初始化的
//Short hand array variable declaration and initialize
arr := [5]int{21, 3, 1, 4, 2}
下面的程序代码:
- 用速记变量创建了一个固定大小为5的数组。
- 但只有3个值被初始化。
- 剩下的两个值用默认的零值填充。
// Short hand Array variable Creation and initialized with values
arr := [5]int{5, 3, 1}
// Display length to console
fmt.Println(len(arr))
如何用椭圆符号声明一个数组？
可以用literal syntax 来声明和初始化数组，但没有指定数组的长度。
我们也可以用椭圆符号来声明一个数组。编译器会根据元素的数量计算出长度。
例子:
package main
import "fmt"
func main() {
// Short hand Array variable Creation and initialized with values
arr := [...]int{5, 3, 1}
// Display length to console
fmt.Println(len(arr))
fmt.Println(arr)
}
输出:
v1[0] = 5, v1[1] = 2, v1[2] = 0,, v1[3] = 1, v1[4] = 4
v1= [5 2 0 1 4]
分配元素和使用索引访问元素？
- 数组是按顺序存储元素的。
- 数组的索引总是从0开始，最后一个元素是数组的大小-1。
- 在下面的程序中，创建了5个整数的数组，一些值v1[2]被自动初始化为默认值。
- 剩余的元素是明确分配的，使用索引访问数组中的元素 - v1[index] 。
package main
import "fmt"
func main() {
// An array with 5 integers
var v1 [5]int
v1[0] = 5
v1[1] = 2
v1[3] = 1
v1[4] = 4
fmt.Printf("v1[0] = %d, v1[1] = %d, , v1[2] = %d, v1[3] = %d, v1[4] = %d\n", v1[0], v1[1], v1[2], v1[3], v1[4])
fmt.Println("v1= ", v1)
}
上述程序的输出是
v1[0] = 5, v1[1] = 2, v1[2] = 0,, v1[3] = 1, v1[4] = 4
v1= [5 2 0 1 4]
如何找到一个数组的长度--元素的数量？
通常情况下，我们需要找到数组中的元素数。len() 是用来寻找数组长度的函数。
在下面的程序代码中，首先打印出数组的长度，然后在数组中加入一个元素并打印出长度。
package main
import "fmt"
func main() {
// Array Creation and initialized with values
arr := []int{5, 3, 11, 1}
// Display length to console
fmt.Println(len(arr))
// Assign an value to array
arr = append(arr, 61)
fmt.Println(len(arr))
}
上述程序代码的输出是
4
5
如何使用for循环遍历数组中的一个元素
有时我们需要循环一个数组中的所有元素。
Golang有for loop 用来迭代元素。你可以查看另一篇关于在Golang中用for循环来迭代数组元素的文章。
len() 函数用于检索数组中的元素数量。
package main
import "fmt"
func main() {
// Array Creation and initialized with values
arr := []int{5, 3, 11, 1}
for i := 0; i < len(arr); i++ {
fmt.Println(arr[i])
}
}
上述程序代码执行的输出是
5
3
11
1
如何在Golang中使用一个范围来迭代数组中的一个元素
这是另一种方法，在for循环中使用range 关键字来迭代数组元素。
range 数组循环中的关键字在迭代过程中返回两个元素，第一个元素是一个索引，第二个是实际的元素。
package main
import "fmt"
func main() {
// Array Creation and initialized with values
arr := []int{5, 3, 11, 1}
for index, element := range arr {
fmt.Printf("%d = %d\n", index, element)
}
}
上述程序代码执行的输出是
0 = 5
1 = 3
2 = 11
3 = 1
如果我们不需要索引值，在这种情况下，我们将使用后面的标识符(_)和for range语法。
数组的数组 - Golang中的多维数组
像其他编程语言一样，Go语言也支持Multidimensional 数组。Multidimensional 数组是包含数组的数组。
下面是一个多维数组的语法
var variablename [n1][n2]...[n3] type
变量名是标识符 类型是原始类型或自定义类型
让我们看一个创建二维整数数组的例子。
如果这些元素被明确地初始化，编译器会将元素类型的默认值分配为零。
var arr [2][2] int
下面的例子解释了多维数组的用法
- 使用简单的、字面的、速记的语法声明和创建二维数组
- 初始化二维数组
- 访问二维数组的元素
- 二维数组的迭代
package main
import "fmt"
func main() {
/* Two dimensional array declare and initilize */
var array1 = [3][2]int{{0, 1}, {1, 2}, {2, 3}}
// shorthand two dimensional array variable declaration
array2 := [2][2]int{{0, 1}, {1, 2}}
var i, j int
/* Iterating elements array1 */
for i = 0; i < 3; i++ {
for j = 0; j < 2; j++ {
fmt.Printf("array1[%d][%d] = %d\n", i, j, array1[i][j])
}
}
/* Iterating elements array2 */
for i = 0; i < 2; i++ {
for j = 0; j < 2; j++ {
fmt.Printf("array2[%d][%d] = %d\n", i, j, array2[i][j])
}
}
}
上述程序的输出是
array1[0][0] = 0
array1[0][1] = 1
array1[1][0] = 1
array1[1][1] = 2
array1[2][0] = 2
array1[2][1] = 3
array2[0][0] = 0
array2[0][1] = 1
array2[1][0] = 1
array2[1][1] = 2
如何在Golang中创建数组对象--结构示例
像普通的原始数组创建一样，Struct 或自定义对象数组也可以被创建。用与原始数组相同的语法进行声明和初始化。
下面是一个创建Struct数组和访问结构元素的例子
package main
import "fmt"
type employee struct {
id int
name string
}
func main() {
emps := []employee{
{
name: "kiran",
id: 1,
},
{
name: "john",
id: 2,
},
}
fmt.Println(emps)
}
上述程序的输出是
[{1 kiran} {2 john}]
如何在Golang中检查数组变量的数据类型？
像变量类型检查一样，数组类型可以使用Reflection API -reflect.TypeOf()或fmt.Printf与%T格式检查。
下面是一个查找Array变量类型的例子
package main
import (
"fmt"
"reflect"
)
func main() {
v4 := []string{"one", "two", "three"} //// string array variable
fmt.Println("============== Using Reflection ==============")
fmt.Println("string array variable type: ", reflect.TypeOf(v4))
fmt.Println("============== Using Printlnf formatting ==============")
fmt.Printf("%T\n", v4)
}
上述程序代码执行的输出是
A:\Golang\work>go run array.go
============== Using Reflection ==============
string array variable type: []string
============== Using Printlnf formatting ==============
[]string
golang中的错误--数组类型不能以不同的长度进行分配
- 数组包含两个重要的东西，即类型和长度。
- 数组大小是类型的一部分。
- 一旦数组被声明，数组的大小和类型不能被分配给另一个数组。
在下面的代码中，编译器认为两个数组--array2 [5] 和 array1 [2] 是不同的，因为大小是数组类型的一部分。
array1被分配到不同的数组类型。
这是不允许的，会产生编译错误--在赋值中不能将array1（类型[2]int）作为类型[5]int使用。
package main
func main() {
array1 := [2]int{2, 3}
var array2 [5]int
array2 = array1
}
上述程序代码的输出是
A:\Golang\work>go run array.go
# command-line-arguments
.\array.go:6:9: cannot use array1 (type [2]int) as type [5]int in assignment
在Golang中的错误 - 数组赋值是值类型而不是引用类型
Golang中的数组是基于值类型的。当你把一个数组赋值给新的变量时，整个数值会被复制到一个新的数组变量。
如果你修改或改变原来的数组，新的数组将不会被改变，而且如果新的数组有任何改变，也不会反映在原来的数组中。
package main
import "fmt"
func main() {
array1 := [...]string{"one", "two", "three"}
array2 := array1 //array assigment values are copied, not reference
array2[0] = "three"
fmt.Println("array1: ", array1)
fmt.Println("array2: ", array2)
}
上述代码的输出是
A:\Golang\work>go run array.go
array1: [one two three]
array2: [three two three]
如何检查一个数组中的搜索/包含的元素？
Golang没有任何预定义的函数来检查数组中的元素是否存在。
在下面的代码中，contain 函数被声明，返回true - 如果元素存在，false - 不存在。
以下是线性搜索与元素检查的例子
package main
import "fmt"
// Check element exists in array
func contain(str [3]string, element string) bool {
for _, value := range str {
if element == value {
return true
}
}
return false
}
func main() {
array1 := [...]string{"one", "two", "three"}
fmt.Println(contain(array1, "one")) // true
fmt.Println(contain(array1, "one1")) // false
}
输出是
true
false
这也将被用于传递一个数组给函数。
- panic: runtime error: index out of range- 当你访问索引的值大于数组长度-1时，会抛出这个错误。
- array1已声明但未使用- 当一个变量被声明但未使用时，编译器会给出一个错误。
- *在数组字面之外使用[...]数组--*在有字符串数组参数的函数声明中不使用椭圆符号，只用于字符串字面。
总结
我们已经学习了不同语法的简单数组和多维数组。
