数组是属于同一类型的元素的集合。例如,整数 5、8、9、79、76 的集合形成一个数组。Go 中不允许混合不同类型的值,例如同时包含字符串和整数的数组。
数组属于类型[n]T
。n
表示数组中元素的数量,T
表示每个元素的类型。元素的数量n
也是类型的一部分
声明数组有不同的方法。让我们一一看看。
package main
import (
"fmt"
)
func main() {
var a [3]int
fmt.Println(a)
}
Run in Playground
var a[3]int声明一个长度为 3 的整数数组。
数组中的所有元素都会自动分配该数组类型的零值。
在本例中a
是一个整数数组,因此 的所有元素都a
被分配给int
为0的零值。运行上面的程序会打印
[0 0 0]
数组的索引从 开始0
,到 结束length - 1
。让我们为上面的数组分配一些值。
package main
import (
"fmt"
)
func main() {
var a [3]int
a[0] = 12
a[1] = 78
a[2] = 50
fmt.Println(a)
}
Run in Playground
a[0] 将值赋给数组的第一个元素。程序将打印
[12 78 50]
让我们使用简写声明创建相同的数组。
package main
import (
"fmt"
)
func main() {
a := [3]int{12, 78, 50}
fmt.Println(a)
}
Run in Playground
上面的程序将打印相同的输出
[12 78 50]
在简写声明期间,不必为数组中的所有元素分配一个值。
package main
import (
"fmt"
)
func main() {
a := [3]int{12}
fmt.Println(a)
}
Run in Playground
在上面的程序中,a := [3]int{12}
声明了一个长度为 3 的数组,但只提供了一个值12
。其余 2 个元素会0
自动分配。该程序将打印
[12 0 0]
您甚至可以忽略声明中数组的长度,并将其替换为...
and 让编译器为您找到长度。这是在以下程序中完成的。
package main
import (
"fmt"
)
func main() {
a := [...]int{12, 78, 50}
fmt.Println(a)
}
Run in Playground
**数组的大小是类型的一部分。**因此[5]int
和[25]int
是不同的类型。因此,数组的大小无法调整。不用担心这个限制,因为slices
存在可以克服这个限制。
package main
func main() {
a := [3]int{5, 78, 8}
var b [5]int
b = a
}
Run in Playground
在上面的程序中,我们试图将一个类型为[3]int
变量分配给一个 类型为[5]int
的变量,因此编译器将打印以下错误
./prog.go:6:7: 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
b[0] = "Singapore"
fmt.Println("a is ", a)
fmt.Println("b is ", b)
}
Run in Playground
在上面的程序中,把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)
}
Run in Playground
在上面的程序中,第 1 行。13、数组num
实际上是按值传递给函数的changeLocal
,因此不会因为函数调用而改变。该程序将打印,
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]
通过将数组作为参数传递给函数来找到数组的长度 len
。
package main
import "fmt"
func main() {
a := [...]float64{67.7, 89.8, 21, 78}
fmt.Println("length of a is",len(a))
}
Run in Playground
上述程序的输出是
length of a is 4
循环for
可用于迭代数组的元素。
package main
import "fmt"
func main() {
a := [...]float64{67.7, 89.8, 21, 78}
for i := 0; i < len(a); i++ {
fmt.Printf("%d th element of a is %.2f\n", i, a[i])
}
}
Run in Playground
上面的程序使用循环来迭代从索引到for
的数组元素。该程序可以运行并打印
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 提供了一种更好、更简洁的方式来迭代数组返回索引和该索引处的值。让我们使用 for range
重写上面的代码。我们还将找到数组所有元素的总和。
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)
}
Run in Playground
上面程序中的for i, v := range a
就是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
}
上面的 for 循环忽略索引。同样,该值也可以忽略。
到目前为止我们创建的数组都是单维的。可以创建多维数组。
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)
}
Run in Playground
在上面的程序中,使用简写语法声明了一个二维字符串数组。
行号末尾的逗号是必要的。这是因为词法分析器根据简单的规则自动插入分号。
如果您有兴趣了解更多关于为什么需要分号的信息,请阅读https://golang.org/doc/ effective_go.html#semicolons 。
另一个二维数组b
并且每个索引都将字符串一一添加到其中。这是初始化二维数组的另一种方法。
函数printarray
。使用两个 for range 循环来打印二维数组的内容。上面的程序会打印
lion tiger
cat dog
pigeon peacock
apple samsung
microsoft google
AT&T T-Mobile
这就是数组。尽管数组看起来足够灵活,但它们有固定长度的限制。无法增加数组的长度。这就是切片发挥作用的地方。事实上,在 Go 中,切片比传统数组更常见。
切片是数组之上的一种方便、灵活且强大的包装器。切片本身不拥有任何数据。它们只是对现有数组的引用。
具有 T 类型元素的切片表示为[]T
package main
import (
"fmt"
)
func main() {
a := [5]int{76, 77, 78, 79, 80}
var b []int = a[1:4] //creates a slice from a[1] to a[3]
fmt.Println(b)
}
Run in Playground
该语法是从数组a[start:end]
中创建一个切片, a
从索引开始start
到索引end - 1
。因此该切片b
具有值[77 78 79]
。
让我们看看另一种创建切片的方法。
package main
import (
"fmt"
)
func main() {
c := []int{6, 7, 8} //creates and array and returns a slice reference
fmt.Println(c)
}
Run in Playground
在上面的程序中,c := []int{6, 7, 8}
创建一个包含 3 个整数的数组并返回存储在 c 中的切片引用。
切片不拥有自己的任何数据。它只是底层数组的表示。对切片所做的任何修改都将反映在底层数组中。
package main
import (
"fmt"
)
func main() {
darr := [...]int{57, 89, 90, 82, 100, 78, 67, 69, 59}
dslice := darr[2:5]
fmt.Println("array before",darr)
for i := range dslice {
dslice[i]++
}
fmt.Println("array after",darr)
}
Run in Playground
在上述程序中,我们从darr
数组的索引 2、3、4 创建了一个切片为dslice
。然后使用for 循环将这些索引中的值加一。当我们在 for 循环之后打印数组时,我们可以看到切片的更改反映在数组中。程序的输出是
array before [57 89 90 82 100 78 67 69 59]
array after [57 89 91 83 101 78 67 69 59]
当多个切片共享相同的底层数组时,每个切片所做的更改都会反映在该数组中。
package main
import (
"fmt"
)
func main() {
numa := [3]int{78, 79 ,80}
nums1 := numa[:] //creates a slice which contains all elements of the array
nums2 := numa[:]
fmt.Println("array before change 1",numa)
nums1[0] = 100
fmt.Println("array after modification to slice nums1", numa)
nums2[1] = 101
fmt.Println("array after modification to slice nums2", numa)
}
Run in Playground
在上述程序中,numa[:]
开始和结束值缺失。start 和 end 的默认值分别是0
和len(numa)
。两个切片nums1
共享nums2
同一个数组。程序的输出是
array before change 1 [78 79 80]
array after modification to slice nums1 [100 79 80]
array after modification to slice nums2 [100 101 80]
从输出中可以清楚地看出,当切片共享相同的数组时。对切片所做的修改会反映在数组中。
切片的长度是切片中的元素数。切片的容量是基础数组中的元素数,从创建切片的索引开始。。**
让我们编写一些代码来更好地理解这一点。
package main
import (
"fmt"
)
func main() {
fruitarray := [...]string{"apple", "orange", "grape", "mango", "water melon", "pine apple", "chikoo"}
fruitslice := fruitarray[1:3]
fmt.Printf("length of slice %d capacity %d", len(fruitslice), cap(fruitslice)) //length of fruitslice is 2 and capacity is 6
}
Run in Playground
在上面的程序中,fruitslice
的容量是根据数组fruitarray 索引 为 1 和 2 创建的,因此容量为2 。
fruitslice
的长度是根据数组fruitarray 索引 为 1 和 6创建的,因此长度为6。
因此打印切片 2 容量 6 的长度。
length of slice 2 capacity 6
切片可以被重新切片至其容量。超出此范围的任何内容都会导致程序抛出运行时错误。
package main
import (
"fmt"
)
func main() {
fruitarray := [...]string{"apple", "orange", "grape", "mango", "water melon", "pine apple", "chikoo"}
fruitslice := fruitarray[1:3]
fmt.Printf("length of slice %d capacity %d\n", len(fruitslice), cap(fruitslice)) //length of is 2 and capacity is 6
fruitslice = fruitslice[:cap(fruitslice)] //re-slicing furitslice till its capacity
fmt.Println("After re-slicing length is",len(fruitslice), "and capacity is",cap(fruitslice))
}
Run in Playground
上面的程序,fruitslice
被重新切片到其容量。上述程序输出,
length of slice 2 capacity 6
After re-slicing length is 6 and capacity is 6
func make([]T, len, cap) []T 可用于通过传递类型、长度和容量来创建切片。
容量参数是可选的,默认为长度。make 函数创建一个数组并返回对该数组的切片引用。
package main
import (
"fmt"
)
func main() {
i := make([]int, 5, 5)
fmt.Println(i)
}
Run in Playground
当使用 make 创建切片时,这些值默认为零。上述程序将输出[0 0 0 0 0]
.
我们已经知道数组的长度被限制为固定并且它们的长度不能增加。切片是动态的,可以使用append
函数将新元素附加到切片。
追加函数的定义是func append(s []T, x ...T) []T
。
x…函数定义中的 T 表示函数接受参数 x 的可变数量的参数。这些类型的函数称为可变参数函数。
不过,有一个问题可能会困扰您。如果切片由数组支持并且数组本身具有固定长度,那么切片为何具有动态长度。
幕后发生的事情是,当新元素添加到切片时,会创建一个新数组。现有数组的元素将复制到此新数组,并返回此新数组的新切片引用。新切片的容量现在是旧切片的两倍)。下面的程序会让事情变得清楚。
package main
import (
"fmt"
)
func main() {
cars := []string{"Ferrari", "Honda", "Ford"}
fmt.Println("cars:", cars, "has old length", len(cars), "and capacity", cap(cars)) //capacity of cars is 3
cars = append(cars, "Toyota")
fmt.Println("cars:", cars, "has new length", len(cars), "and capacity", cap(cars)) //capacity of cars is doubled to 6
}
Run in Playground
在上面的程序中,cars
最初的容量为3。我们向cars
添加了一个新元素append(cars, "Toyota")
。 再次将返回的切片分配给 cars。现在cars的容量增加了一倍,变成了 6 。上述程序的输出是
cars: [Ferrari Honda Ford] has old length 3 and capacity 3
cars: [Ferrari Honda Ford Toyota] has new length 4 and capacity 6
切片类型的零值为nil
。切片nil
的长度和容量为 0。可以nil
使用append 函数将值附加到切片。
package main
import (
"fmt"
)
func main() {
var names []string //zero value of a slice is nil
if names == nil {
fmt.Println("slice is nil going to append")
names = append(names, "John", "Sebastian", "Vinay")
fmt.Println("names contents:",names)
}
}
Run in Playground
在上面的程序中,names
被我们附加了 3 个字符串。程序的输出是
slice is nil going to append
names contents: [John Sebastian Vinay]
还可以使用...
运算符将一个切片附加到另一个切片。您可以在下一节可变参数函数教程中了解有关此运算符的更多信息。
package main
import (
"fmt"
)
func main() {
veggies := []string{"potatoes","tomatoes","brinjal"}
fruits := []string{"oranges","apples"}
food := append(veggies, fruits...)
fmt.Println("food:",food)
}
Run in Playground
上述程序food是通过附加fruits
到 veggies
来创建的。程序的输出是
food: [potatoes tomatoes brinjal oranges apples]
切片可以被认为是由结构类型内部表示的。看起来是这样的,
type slice struct {
Length int
Capacity int
ZerothElement *byte
}
切片包含长度、容量和指向数组第零个元素的指针。
当切片传递给函数时,即使它是按值传递的,指针变量也将引用相同的底层数组。因此,当切片作为参数传递给函数时,函数内部所做的更改在函数外部也是可见的。让我们编写一个程序来检查一下。
package main
import (
"fmt"
)
func subtactOne(numbers []int) {
for i := range numbers {
numbers[i] -= 2
}
}
func main() {
nos := []int{8, 7, 6}
fmt.Println("slice before function call", nos)
subtactOne(nos) //function modifies the slice
fmt.Println("slice after function call", nos) //modifications are visible outside
}
Run in Playground
上述程序 , subtactOne
函数调用将切片的每个元素递减 2。在函数调用后打印切片时,这些更改是可见的。
如果您还记得的话,这与数组不同,在函数内部对数组所做的更改在函数外部不可见。上述程序的输出是
slice before function call [8 7 6]
slice after function call [6 5 4]
与数组类似,切片可以具有多个维度。
package main
import (
"fmt"
)
func main() {
pls := [][]string {
{"C", "C++"},
{"JavaScript"},
{"Go", "Rust"},
}
for _, v1 := range pls {
for _, v2 := range v1 {
fmt.Printf("%s ", v2)
}
fmt.Printf("\n")
}
}
Run in Playground
程序的输出是,
C C++
JavaScript
Go Rust
切片保存对底层数组的引用。只要切片在内存中,数组就无法被垃圾回收。当涉及到内存管理时,这可能会引起关注。假设我们有一个非常大的数组,并且我们只想处理其中的一小部分。此后,我们从该数组创建一个切片并开始处理该切片。这里需要注意的重要一点是,该数组仍将位于内存中,因为切片引用了它。
解决此问题的一种方法是使用复制函数func copy(dst, src []T) int
来复制该切片。这样我们就可以使用新的切片,并且原始数组可以被垃圾收集。
package main
import (
"fmt"
)
func countries() []string {
countries := []string{"USA", "Singapore", "Germany", "India", "Australia"}
neededCountries := countries[:len(countries)-2]
countriesCpy := make([]string, len(neededCountries))
copy(countriesCpy, neededCountries) //copies neededCountries to countriesCpy
return countriesCpy
}
func main() {
countriesNeeded := countries()
fmt.Println(countriesNeeded)
}
Run in Playground
上述程序,neededCountries := countries[:len(countries)-2]
创建了一个切片,countries
除去最后 2 个元素。复制neededCountries
,返回它countriesCpy
。现在countries
数组可以被垃圾回收,因为neededCountries
不再被引用。
[USA Singapore Germany]
这就是数组和切片的情况。谢谢阅读。请留下您宝贵的反馈和意见。