golang数组

一、数组及声明

数组不难理解,就是array类型的数据,Go不允许在数组中混合使用不同类型的元素(比如整数和字符串)。所以数组是类型相同的元素的集合。例如,整数 5, 8, 9, 79, 76 的集合就构成了一个数组。var a [3]int 这里就命名了一个名称为a,里面包含三个值的整型数组。所以我们总结为:数组的类型为 n[T],其中 n 表示数组中元素的个数,T 表示数组中元素的类型。

package main
import (
    "fmt"
)
func main() {
    var a [3]int //int array with length 3
    fmt.Println(a)
}

上面var a [3]int 声明了一个长度为 3 的整型数组。数组中的所有元素都被自动赋值为元素类型的 0 值。比如这里 a 是一个整型数组,因此 a 中的所有元素都被赋值为 0(即整型的 0 值)。运行上面的程序,输出为:[0 0 0]。数组的索引从 0 开始到 length - 1 结束,再看一个示例:

package main
import (
	"fmt"
)
func main() {
	var a [3]int //int array with length 3
	a[0] = 12    // array index starts at 0
	a[1] = 78
	a[2] = 50
	fmt.Println(a)
}

a[0]表示数组中的第一个元素。程序的输出为:[12 78 50]。同样可以利用速记声明(shorthand declaration)的方式来创建同样的数组,上面的数据a值的定义可以直接使用a := [3]int{12, 78, 50} 完成定义,这时候再打印a的输出是一样的。在速记声明中,没有必要为数组中的每一个元素指定初始值。看下面的代码:

package main
import (
    "fmt"
)
func main() {
    a := [3]int{12}
    fmt.Println(a)
}

上面程序的:a := [3]int{12} 声明了一个长度为 3 的数组,但是只提供了一个初值 12。剩下的两个元素被自动赋值为 0。程序 的输出为:[12 0 0]。

在声明数组时你可以忽略数组的长度并用 ... 代替,让编译器为你自动推导数组的长度。比如下面的程序:

package main
import (
    "fmt"
)
func main() {
    a := [...]int{12, 78, 50} // ... makes the compiler determine the length
    fmt.Println(a)
}

上面已经提到,数组的长度是数组类型的一部分。因此 [5]int 和 [25]int 是两个不同类型的数组。正是因为如此,一个数组不能动态改变长度。看下面一个例子,如果我们把一个长度为3的数组和一个长度为5的数组进行赋值时就会报错。

package main
func main() {
    a := [3]int{5, 78, 8}
    var b [5]int
    b = a //not possible since [3]int and [5]int are distinct types
}

在上面程序的第 6 行,我们试图将一个 [3]int 类型的数组赋值给一个 [5]int 类型的数组,这是不允许的。编译会报错:main.go:6: cannot use a (type [3]int) as type [5]int in assignment。

二、数组的拷贝

在 Go 中数组是值类型而不是引用类型。这意味着当数组变量被赋值时,将会获得原数组(译者注:也就是等号右面的数组)的拷贝。新数组中元素的改变不会影响原数组中元素的值。

package main
import "fmt"
func main() {
	a := [...]string{"USA", "China", "India", "Germany", "France"}
	b := a // a copy of a is assigned to b
	b[0] = "Singapore"
	fmt.Println("a is ", a)
	fmt.Println("b is ", b)
}

上面程序将数组 a 的拷贝赋值给数组 b。而后我们将 b 的第一个元素赋值为 Singapore。这将不会影响到原数组 a。程序的输出为:

a is [USA China India Germany France]
b is [Singapore China India Germany France] 

同样的,如果将数组作为参数传递给函数,仍然是值传递,在函数中对(作为参数传入的)数组的修改不会造成原数组的改变。

package main
import "fmt"
func changeLocal(num [5]int) {
	num[0] = 55
	fmt.Println("inside function ", num)
}
func main() {
	num := [...]int{5, 6, 7, 8, 8}
	fmt.Println("before passing to function ", num)
	changeLocal(num) //num is passed by value
	fmt.Println("after passing to function ", num)
}

上面的程序,数组 num 是通过值传递的方式传递给函数 changeLocal 的,因此该函数执行过程中不会造成 num 的改变。程序输出如下:

before passing to function  [5 6 7 8 8]
inside function  [55 6 7 8 8]
after passing to function  [5 6 7 8 8]  

三、数组的遍历

在了解遍历之前,我们先了解下如何知道一个数组的长度,假如我们定义一个数组:a := [...]float64{67.7, 89.8, 21, 78} ,能过len(a)我们可以获取数组的长度。而遍历需要使用到range函数,该函数在此处通过len函数进行循环遍历就可以得到数组内的所有数据:

package main
import "fmt"
func main() {
	a := [...]float64{67.7, 89.8, 21, 78}
	for i := 0; i < len(a); i++ { //looping from 0 to the length of the array
		fmt.Printf("%d th element of a is %.2f\n", i, a[i])
	}
}

上面的程序使用 for 循环遍历数组中的元素(索引从 0 到 len(a) - 1)。上面的程序输出如下:

0 th element of a is 67.70
1 th element of a is 89.80
2 th element of a is 21.00
3 th element of a is 78.00  

Go 提供了一个更简单,更简洁的遍历数组的方法:使用 range for。range 返回数组的索引和索引对应的值。让我们用 range for 重写上面的程序(除此之外我们还计算了数组元素的总和)。

package main
import "fmt"
func main() {
	a := [...]float64{67.7, 89.8, 21, 78}
	sum := float64(0)
	for i, v := range a { //range returns both the index and value
		fmt.Printf("%d the element of a is %.2f\n", i, v)
		sum += v
	}
	fmt.Println("\nsum of all elements of a", sum)
}

上面的程序中,for i, v := range a 是 range 形式的 for 循环。range 将返回数组的索引和相对应的元素。我们打印这些值并计算数组 a 中所有元素的总和。程序的输出如下:

0 the element of a is 67.70
1 the element of a is 89.80
2 the element of a is 21.00
3 the element of a is 78.00
sum of all elements of a 256.5 

如果你只想访问数组元素而不需要访问数组索引,则可以通过空标识符来代替索引变量:

for _, v := range a { //ignores index
}

上面的代码忽略了索引。同样也可以忽略值。

四、多维数组

上面我们用的都是一组数组,理解了一组数据,多维数组就比较好理解了,看下如下示例:

package main
import (
	"fmt"
)
func printarray(a [3][2]string) {
	for _, v1 := range a {
		for _, v2 := range v1 {
			fmt.Printf("%s ", v2)
		}
		fmt.Printf("\n")
	}
}
func main() {
	a := [3][2]string{
		{"lion", "tiger"},
		{"cat", "dog"},
		{"pigeon", "peacock"}, //this comma is necessary. The compiler will complain if you omit this comma
	}
	printarray(a)
	var b [3][2]string
	b[0][0] = "apple"
	b[0][1] = "samsung"
	b[1][0] = "microsoft"
	b[1][1] = "google"
	b[2][0] = "AT&T"
	b[2][1] = "T-Mobile"
	fmt.Printf("\n")
	printarray(b)
}

利用速记声明创建了一个二维数组 a。其中的逗号是必须的,这是因为词法分析器会根据一些简单的规则自动插入分号。如果你想了解更多,请阅读:https://golang.org/doc/effective_go.html#semicolons 。后面又通过赋值声明了另一个二维数组 b,并通过索引的方式给数组 b 中的每一个元素赋值。这是初始化二维数组的另一种方式。函数 printarray 通过两个嵌套的 range for 打印二维数组的内容。上面代码的执行结果如下:

lion tiger
cat dog
pigeon peacock
apple samsung
microsoft google
AT&T T-Mobile  




本站的发展离不开您的资助,金额随意,欢迎来赏!

You can donate through PayPal.
My paypal id: itybku@139.com
Paypal page: https://www.paypal.me/361way

  1. 本文目前尚无任何评论.
  1. 本文目前尚无任何 trackbacks 和 pingbacks.