Go（Golang） 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。

Go是从2007年末由Robert Griesemer, Rob Pike, Ken Thompson主持开发，后来还加入了Ian Lance Taylor, Russ Cox等人，并最终于2009年11月开源，在2012年早些时候发布了Go 1稳定版本。

现在Go的开发已经是完全开放的，并且拥有一个活跃的社区。

在国内外，已经有很多大厂开始大规模使用Golang开发其云计算相关产品，比如Google、AWS、Cloudflare、阿里巴巴等。

而Go开发人员的全球平均薪资也是相当高。在美国，使用Go语言的开发者平均年薪为$ 136K。

在2019年Stack Overflow开发者调查中，Go是全球收入第三的语言。

因此，还没有开始学习Go的朋友，不妨来看看我今天推荐的教程《Go 语言实现常见数据结构》。

通过使用 Golang 实现常见的数据结构，加深大家对 Golang 的理解，并且可以强化大家的数据结构基本功。

先让我们一起来看看《Go 语言实现常见数据结构》节选吧，本节教程主要教大家学习Golang的数组与切片。

大家也可以点击链接，在实验楼搭载好的线上环境，跟着教程学习，效率更高。

教程节选：

实验1 数组与切片

实验介绍

从本实现开始我们将进入到 Golang 的学习之旅，Golang 的许多初学者都会对数组 (Array) 与切片 (Slice) 感到困惑。

他们虽然同属于集合类的类型，但是用起来却十分不同。在本节实验中，你将学习到数组与切片到底是哪里不同，这里也是 Golang 面试中的一个常考知识点。

知识点

• 数组的数据类型
• 数组的创建
• 数组的遍历
• Golang 数组与切片的区别
• 切片的扩容规律

Golang 数组基本操作

这一节开始，我们将学习 Golang 数组与切片的常用方法以及他们在具体面试中的常考知识点。

数组的声明

Golang 中一个数组的声明方式主要有以下几种。

package main

func main() {
    // 第一种，在初始化时只声明数组长度，不声明数组内容
    var arr1 [5]int
    // 第二种，知道数据很多，不想自己写长度的时候可以用这种方式
    // 声明之后由编译器自己推算数组长度
    arr2 :=  [...]int{1,3,5,7,9}
    // 第三种，声明的时候长度和初值一起声明
    arr3 := [3]int{2,4,6}
    // 二维数组的声明，其意义是三行五列
    var Block [3][5]int
}

这里值得一提的是 Golang 中的数组的初始值如果你不做声明的话默认是全部有初值的。 比如 arr1 这个数组虽然只声明了长度为 5，但是 Go 的编译器也会把这 5 个元素全都初始化为 0。而对于 bool 值类型的数组，如果不做赋值操作，则初始值全为 false。在接下来的数组遍历中我们会实际的验证它。

数组的遍历

我们先在实验楼在线实验环境中新建新建一个名叫 array 的文件夹。如下图所示，先点击 File，然后点击 New Folder 创建名为 array 的文件夹。

image

然后我们右键点击 array 文件夹，选择 New File，创建一个叫 main.go 的文件，如下图所示。

image

Go 的数组遍历主要有以下两种方式。首先键入以下代码：

package main

import "fmt"

func main() {
    // 第一种，在初始化时只声明数组长度，不声明数组内容
    var arr1 [5]int
    // 第二种，知道数据很多，不想自己写长度的时候可以用这种方式
    // 声明之后由编译器自己推算数组长度
    //arr2 :=  [...]int{1,3,5,7,9}
    //// 第三种，声明的时候长度和初值一起声明
    //arr3 := [3]int{2,4,6}
    //// 二维数组的声明，其意义是三行五列
    var Block [3][5]bool
    // 第一种
    for i := 0 ; i<len(arr1); i++{
        fmt.Printf("%d\n",arr1[i])
    }
    // 第二种
    for index, value := range arr1 {
        fmt.Printf("索引：%d, 值： %d\n",index,value)
    }
    // 以第二种方式遍历二维数组,只取值，也就是取出一个数组
    for _,v := range Block {
        // 再对这个数组取值
        for _,value := range v {
            fmt.Printf("%v ",value)
        }
        fmt.Printf("\n")
    }

}

接下来，在终端执行：

cd array
go run main.go

结果如下：

image

其中 Go 语言官方更加提倡的是第二种以 range 的方式进行遍历，这样写会让代码更加优雅，而且绝对不会越界。

那么，如果我只想要数组里的 index 不想要 value 时怎么 range 呢？

答案其实很简单，i := range arr 就可以了。如果你只想要 value 不想要索引的时候就可以这样写 _, value := range arr, 注意这里的下划线不能省略。

封装一个数组打印函数

现在咱们封装一个用来打印数组的函数并对其进行测试，代码如下:

func PrintArr(arr [5]int) {
    // 第二种
    for index, value := range arr {
        fmt.Printf("索引：%d, 值： %d\n",index,value)
    }
}

我们分别将 arr1,2,3 传入打印，先猜测一下会发生什么结果呢？

package main

import "fmt"

func main() {
    // 第一种，在初始化时只声明数组长度，不声明数组内容
    var arr1 [5]int
    // 第二种，知道数据很多，不想自己写长度的时候可以用这种方式
    // 声明之后由编译器自己推算数组长度
    arr2 :=  [...]int{1,3,5,7,9}
    //// 第三种，声明的时候长度和初值一起声明
    arr3 := [3]int{2,4,6}
    PrintArr(arr1)
    PrintArr(arr2)
    PrintArr(arr3)
}

func PrintArr(arr [5]int) {
    // 第二种
    for index, value := range arr {
        fmt.Printf("索引：%d, 值： %d\n",index,value)
    }
}

结果是程序在打印 arr3 时抛出了如下异常。

image

这个就要牵扯出一个概念了，Go 语言中数组是值类型。也就是说[3]int，和[5]int 在 go 中会认为是两个不同的数据类型。

同样地，你在 PrintArr 中改变数组中的值也不会改变原数组的值。

到了这里你肯定觉得 go 的数组太难用了，又要数据类型统一又要长度统一才能传递。确实是这样的，在 go 中我们一般不直接使用数组。而是使用我们今天的主角，切片。

Golang 切片的基本操作

一般而言，Go 语言的切片比数组更加灵活，强大而且方便。数组是按值传递的（即是传递的副本），而切片是引用类型，传递切片的成本非常小，而且是不定长的。

而且数组是定长的，而切片可以调整长度。创建切片的语法如下：

• make([ ]Type, length, capacity)
• make([ ]Type, length)
• [ ]Type{}
• [ ]Type{value1, value2, ..., valueN}

内置函数 make() 用于创建切片、映射和通道。当用于创建一个切片时，它会创建一个隐藏的初始化为零值的数组，然后返回一个引用该隐藏数组的切片。

该隐藏的数组与 Go 语言中的所有数组一样，都是固定长度，如果使用第一种语法创建，那么其长度为切片的容量 capacity ；如果是第二种语法，那么其长度记为切片的长度 length 。一个切片的容量即为隐藏数组的长度，而其长度则为不超过该容量的任意值。另外可以通过内置的函数 append() 来增加切片的容量。

我们来执行一下下面的程序：

package main

import "fmt"

func main() {
    slice := make([]int,0)
    for i := 0 ;i < 10; i++ {
        // 动态的对切片进行扩容
        slice = append(slice, i)
    }
    fmt.Println(slice)

    // 调用PrintArr
    PrintArr(slice)
    // 看看是否切片的第一个元素改变了?
    fmt.Println(slice)
}

func PrintArr(arr []int) {
    arr[0] = 100
    for index, value := range arr {
        fmt.Printf("索引：%d, 值： %d\n",index,value)
    }
}

执行结果:

image

执行之后我们会发现 slice[0] 的值确实被改变了。因为切片是引用传递，也就是直接把切片在内存中的地址传递过去。

这样我们在其他函数中对其进行修改也会影响原来的切片的数据。这样做的好处是传引用因为不用把原数据拷贝一份，所以对系统的开销比较小。

切片的切割

切片最大的特色就是可以灵活的进行切分，比如下面的例子。

package main

import "fmt"

func main() {
    slice := make([]int,0)
    for i := 0 ;i < 10; i++ {
        slice = append(slice, i)
    }
    fmt.Println(slice)
    s2 := slice[2:4]
    fmt.Println(s2)
}

执行结果:

image

这里的 2 可被称为起始索引，4 可被称为结束索引。那么 s2 的长度就是 4 减去 2，即 2。因此可以说，s2 中的索引从 0 到 1 指向的元素对应的是 slice 及其底层数组中索引从 2 到 3 的那 2 个元素。

到这里我们就可以推出 [n:m] 的意思是取区间 [n,m) 的数据赋值给新的切片。

关于数组与切片两道常见面试题

• Golang 切片的扩容规则。

一旦一个切片无法容纳更多的元素，Go 语言就会想办法扩容。但它并不会改变原来的切片，而是会生成一个容量更大的切片，然后将把原有的元素和新元素一并拷贝到新切片中。在一般的情况下，你可以简单地认为新切片的容量将会是原切片容量的 2 倍。 但是，当原切片的长度大于或等于 1024 时，Go 语言将会以原容量的 1.25 倍作为新容量的基准。因为继续再乘以 2 的话切片容量增加的太快，很容易产生大量的浪费无意义的空间。 不过，如果我们一次追加的元素过多，以至于使新长度比原容量的 2 倍还要大，那么新容量就会以新长度为基准。比如你现在的切片长度为 10，现在一下往里面添加了 30 个元素，那么 Golang 会直接创建一个新的长度为 40 的底层数组，然后把所有的数据拷贝进去。

• Golang 切片的底层数组在什么情况下会改变？

其实这里的典型回答应该是永远不会改变。因为当切片需要扩容时，新的切片诞生的同时也会创建出新的底层数组，它只是把原数组的数据拷贝了进来，并未对其做任何的修改。

一道思考题

现在我们已经学习了如何对数组进行“扩容”，那么你能否使用“扩容”的方式，把原切片进行缩容呢？请尝试写出代码，或查阅相关资料。

......

篇幅有限，暂时发布以上内容。

之后还有“栈与栈的应用”“队列与循环队列”等内容可以学习，感兴趣的朋友可以点击链接，学习之后的内容。