第十一部分：数组和切片

浏览 76 扫码分享 2022-07-19 08:56:52

数组
切片
原文链接

数组

数组是同一类型的元素的集合。比如整数 5， 8， 9， 79， 76 的集合构成一个数组。但是不允许混合不同类型的值，例如同时包含字符串和整数的数组是不被允许的。

声明

数组属于 n[T] 类型。n 表示数组中元素的数量，T 表示每个元素的类型。元素 n 的数量也是类型的一部分(稍后我们将对此进行更详细的讨论)。

声明数组有不同的方法。

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

Run in playground

var a[3]int 声明一个长度为 3 的整数数组。数组中的所有元素都自动分配数组类型的零值。在这种情况下，a 是一个整数数组，因此 a 的所有元素都赋值为 0，即 int 的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)
}

Run in playground

a[0] 为数组的第一个元素赋值。程序将输出 [12 78 50]

让我们用简短的声明方式来创建同一个数组

package main 
import (  
    "fmt"
)
func main() {  
    a := [3]int{12, 78, 50} // short hand declaration to create array
    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

上面的程序第 8 行 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)
}

Run in playground

数组的大小是类型的一部分。因此 [5]int 和 [25]int 是不同的类型。因此，数组无法调整大小。不要担心这个限制，因为 slices 的存在就是为了克服这个限制。

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
}

Run in playground

上面的程序中第 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) 
}

Run in playground

在上面的程序中第 7 行 a 赋值给 b，第 8 行中，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

在上面的程序中第 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

使用 range 来迭代数组

for 循环可用于迭代数组的元素。

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])
    }
}

Run in playground

上面的程序使用 for 循环来迭代数组的元素，从索引 0 到 length of the array - 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 使用 for 循环的 range 形式提供了一种更好更简洁的遍历数组的方法。range 返回索引和该索引处的值。让我们使用 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

程序第 8 行 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

上面程序第 17 行二维数组 a 用了简单声明，第 20 行末尾的逗号是必须要写的。这是因为词法分析器会根据规则自动插入分号。如果你对这个感兴趣可以阅读这篇文章 https://golang.org/doc/effective_go.html#semicolons

另外一个二维数组 b 在 23 行被声明，成员为 string 类型。这是初始化二维数组的另外一种方式。

第 7 行 printarray 函数使用两次循环来输出二维数组的内容。

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。所以在第 9 行中。上面程序 a[1:4] 创建从索引 1 开始到 3 的数组 a 的切片。因此切片 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)
}

在上面的程序第 9 行中，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

在上面程序的第 9 行中，我们对数组的索引 2,3,4 创建了dslice 。 for 循环将这些索引中的值递增 1。当我们在 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

在第 9 行，在 numa[:] 中，start 和 end 都没有，因为 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 is 2 and capacity is 6
}

Run in playground

在上面的程序中，fruitslice 是从 fruitarray 索引 1 和 2 切出来的切片。所以fruitslice 长度为 2。

fruitarray 的长度是 7。fruiteslice 是从fruitarray 的索引 1 开始切的。因此，fruiteslice 的容量是指从索引 1 orange 开始的。因此，fruiteslice 的容量为 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

在第 11 行代码中，fruitslice 被重新切成其容量的长度，上面程序输出

length of slice 2 capacity 6  
After re-slicing length is 6 and capacity is 6

使用 make 创建切片

func make([]T, len, cap) []T 可以通过传递类型，长度和容量来创建切片。 capacity参数是可选的，默认为 length。 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 函数将新元素添加到切片中。append 函数的定义是func append(s []T, x ...T) []T。

x …T 函数定义中的 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。我们在第 10 行中为汽车添加了一个新元素。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。可以使用 append 函数添加 nil 切片。

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 为 nil，我们在 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

上面的程序第 10 行中，food 初始化并且添加了 fruits 和 veggies 这两个切片。上面的程序输出 food: [potatoes tomatoes brinjal oranges apples]

将切片传递给函数

切片的实现可以被认为是一个结构类型。如下所示。

type slice struct {  
    Length        int
    Capacity      int
    ZerothElement *byte
}

切片包含长度、容量和指向数组第 0 个元素的指针。当一个切片被传递给一个函数时，即使它是通过值传递的，指针变量也会指向相同的底层数组。因此，当一个切片作为参数传递给一个函数时，函数内部所做的更改在函数外部也是可见的。让我们编写一个程序来验证。

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

上面程序第 17 行中的函数调用将切片的每个元素减 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

内存优化

切片有对底层数组的引用。只要切片在内存中，就不能对数组进行垃圾回收。在内存管理方面，这值得让人注意。让我们假设有一个非常大的数组，我们只处理它的一小部分。然后我们从该数组创建一个切片并开始处理切片。这里需要注意的一点是，由于切片引用了数组，因此数组仍将在内存中。

解决此问题的一种方法是使用 copy 函数 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

在上面程序的第 9 行, neededCountries := countries[:len(countries)-2] 创建了一个 countries 不包含最后两个元素的切片. 第 11 行把 neededCountries 复制到变量 countriesCpy ，并且在函数的下一行中返回它。现在 countries 数组能够被垃圾回收了，因为 neededCountries 没有对该数组进行引用了。

原文链接

https://golangbot.com/arrays-and-slices/

若有收获，就点个赞吧

上一篇:

下一篇:

让时间为你证明

展开/收起文章目录