Go语言数组和切片

数组

数组是属于同一类型的元素的集合。例如，整数 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 range迭代数组

循环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  

使用 make 创建切片

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]

这就是数组和切片的情况。谢谢阅读。请留下您宝贵的反馈和意见。