欢迎来到Golang的世界！在当今快节奏的软件开发领域，选择一种高效、简洁的编程语言至关重要。而在这方面，Golang（又称Go）无疑是一个备受瞩目的选择。在本文中，带领您探索Golang的世界，一步步地了解这门语言的基础知识和实用技巧。

目录

初识数组

二维数组

slice切片

map映射

---

初识数组

        在Go语言中，数组是一种固定长度的、包含相同类型元素的序列。数组的长度是类型的一部分，因此[5]int和[10]int是两种不同的类型。数组在Go中是值类型，这意味着当你传递一个数组到函数或将其赋值给另一个变量时，实际上是在复制整个数组的内容。

在Go语言中数组的内存分配是静态的，并且是在编译时确定的。由于数组的长度是类型的一部分，所以不同长度的数组在内存中的表示和占用是不同的。以下是关于Go语言中数组内存分析的代码示例：

package main
import "fmt"
func main() {// 声明数组var arr [3]int16// 获取数组长度fmt.Println(len(arr)) // 3// 打印数组fmt.Println(arr) // [0 0 0]// 证明arr中存储的是地址值fmt.Printf("arr的地址为：%p \n", &arr) // arr的地址为：0xc0000100b0// 第一个空间地址fmt.Printf("arr[0]的地址为：%p \n", &arr[0]) // arr[0]的地址为：0xc0000100b0// 第二个空间地址fmt.Printf("arr[1]的地址为：%p \n", &arr[1]) // arr[1]的地址为：0xc0000100b2// 第三个空间地址fmt.Printf("arr[2]的地址为：%p \n", &arr[2]) // arr[2]的地址为：0xc0000100b4
}

因为int占两个字节，所以地址值之间间隔为2，如下是图例解释：

接下来我们通过用户终端输入的方式，将数据存入数组当中，然后遍历数组，将数据打印出来：

package main
import "fmt"
func main() {// 定义数组var scores [5]int// 将成绩存入数组for i := 0; i < len(scores); i++ {fmt.Printf("请录入第%d个学生的成绩", i+1)fmt.Scanln(&scores[i])}// 展示一下录入学生的成绩：(对数组进行遍历)for i := 0; i < len(scores); i++ {fmt.Printf("第%d个学生的成绩为：%d \n", i, scores[i])}// 求和sum := 0for i := 0; i < len(scores); i++ {sum += scores[i]}// 平均数avg := sum / len(scores)// 输出fmt.Printf("成绩的总和为：%v, 成绩的平均数为：%v", sum, avg)
}

最终呈现的效果如下所示：

当然这里也可以采用for range的方式，for range结构是go语言中特有的一种迭代结构，在许多情况下都非常有用，for range可以遍历数组、切片、字符串、map及通道，示例代码如下，最终也能得到上面图片的结果：

func main() {// 定义数组var scores [5]int// 将成绩存入数组for i := 0; i < len(scores); i++ {fmt.Printf("请录入第%d个学生的成绩", i+1)fmt.Scanln(&scores[i])}// 展示一下录入学生的成绩：(对数组进行遍历) for range方式for key, value := range scores {fmt.Printf("第%d个学生的成绩为：%d \n", key+1, value)}
}

数组可以有多种书写方式，如下可以看到我们数组的书写方式：

package main
import "fmt"
func main() {// 数组的几种书写方式// var scores [5]int = [5]int{94, 98, 89, 80, 90} // 基本写法// var scores = [5]int{94, 98, 89, 80, 90} // 省略类型和长度//var scores = [...]int{2: 66, 0: 33, 1: 99, 3: 88} // 确定数组下标对应的数值scores := []int{94, 98, 89, 80, 90} // 使用切片（slice）语法（这在Go中更为常见）sum := 0for i := 0; i < len(scores); i++ {// 求得成绩的总值sum += scores[i]}// 平均数avg := sum / len(scores)// 输出fmt.Printf("成绩的总和：%v, 成绩的平均数为：%v\n", sum, avg)
}

在go语言中，关于数组还有以下注意事项，这里做一个简单的概述：

长度属于类型的一部分：

func main() {// 定义一个数组var arr1 = [3]int{1, 2, 3}fmt.Printf("数组的类型为：%T", arr1) // [3]intvar arr2 = [6]int{3, 4, 5, 6, 7, 8}fmt.Printf("数组的类型为：%T", arr2) // [6]int
}

数组属于值类型，在默认情况下是值传递，因此会进行值拷贝，如下图所示我对数组的值进行修改是修改了arr的值，并不是arr3的：

如想在其它函数中去修改原来的数组，可以使用引用传递（指针方式）：

package main
import "fmt"
func test(arr *[3]int) {(*arr)[0] = 7
}func main() {var arr3 = [3]int{3, 6, 9}test(&arr3)       // 传入arr3数组的地址fmt.Println(arr3) // [7 6 9]
}

二维数组

在Go语言中，二维数组(也称为矩阵)是一个数组，其中每个元素都是另一个数组。这意味着你可以有两个维度来索引数据：第一个维度表示行，第二个维度表示列。示例代码如下：

func main() {var arr1 [2][3]int = [2][3]int{{1, 2, 3}, {4, 5, 6}}fmt.Println(arr1) // [[1 2 3] [4 5 6]]
}

在下面的例子中，array2D 是一个5行3列的二维整型数组，这里可以通过array2D[row][column]的方式来访问或修改数组中的元素：

func main() {// 声明一个5行3列的二维整型数组var array2D [5][3]int// 初始化时直接赋值array2D = [5][3]int{{1, 2, 3},{4, 5, 6},{7, 8, 9},{10, 11, 12},{13, 14, 15},}// 访问二维数组中的元素fmt.Println(array2D[2][1]) // 输出: 8
}

如果想对二维数组进行遍历的话，需要用到双层for循环，这里进行一个简单的示例：

package main
import "fmt"
func main() {// 定义二维数组var arr = [3][3]int{{1, 4, 7}, {2, 5, 8}, {3, 6, 9}}fmt.Println(arr)fmt.Println("---------------")// 方式1：普通for循环for i := 0; i < len(arr); i++ {for j := 0; j < len(arr[i]); j++ {fmt.Print(arr[i][j], "\t")}fmt.Println()}// 方式2：for range循环for key, value := range arr {for k, v := range value {fmt.Printf("arr[%v][%v] = %v \t", key, k, v)}fmt.Println()}
}

最终达到的效果如下所示：

slice切片

在Go语言中，切片（slice）是对数组的一个连续片段的引用，它本身并不包含数组的数据，而是包含了对底层数组的引用、长度以及容量。切片提供了一种灵活、方便且高效的方式来操作数组的一个子集，是一种建立在数组类型之上的抽象，它构建在数组之上并且提供更强大的能力和便捷，如下代码给出切片的示例：

package main
import "fmt"
func main() {// 定义数组var intarr [6]int = [6]int{3, 6, 7, 1, 2, 3}// 定义切片 slice [1:3]表示切出的一段片段，索引从1开始，到3结束slice := intarr[1:3]// 输出数组fmt.Println("intarr: ", intarr) // intarr:  [3 6 7 1 2 3]// 输出切片fmt.Println("slice: ", slice) // slice:  [6 7]// 切片元素个数fmt.Println("slice的元素个数: ", len(slice)) // slice的元素个数:  2// 获取切片的容量，容量可以动态变化fmt.Println("slice的容量: ", cap(slice)) // slice的容量:  5
}

切片由3个字段的数据结构组成：指向底层数组的指针、切片的长度、切片的容量

切片的创建：在Go语言中，make 是一个内置函数，用于动态地分配并初始化对象，这些对象包括切片（slices）、映射（maps）和通道（channels）。特别是当我们谈论切片时，make 是创建它们的主要方式，使用 make 创建切片的基本语法如下所示：

slice := make([]T, length, capacity)

这里通过如下代码进行简单示例，在下面的示例中，我们创建了一个整数类型的切片 slice，其长度为 3，容量为 5。这意味着切片当前可以存储 3 个整数，但底层数组的大小为 5，因此将来可以在不重新分配内存的情况下向切片添加最多 2 个额外的整数。

func main() {// 定义切片：make函数的三个参数：1、切片类型 2、切片长度 3、切片容量slice := make([]int, 3, 5)fmt.Println(slice)               // [0 0 0]fmt.Println("切片的长度", len(slice)) // 切片的长度 3fmt.Println("切片的容量", cap(slice)) // 切片的容量 5
}

make底层创建一个数组，对外不可见，所以不可以直接操作这个数组，要通过slice去间接的访问各个元素，不可以直接对数组进行维护/操作。

切片的遍历：对切片的遍历可以采用如下的方式进行：

func main() {// 定义切片：make函数的三个参数：1、切片类型 2、切片长度 3、切片容量slice := make([]int, 4, 20)slice[0] = 66slice[1] = 77slice[2] = 88slice[3] = 99// 方式1：普通for循环，遍历切片for i := 0; i < len(slice); i++ {fmt.Printf("slice[%v] = %v \t", i, slice[i])}fmt.Println("\n------------------------")// 方式2：for range循环，遍历切片for index, value := range slice {fmt.Printf("slice[%v] = %v \t", index, value)}
}

最终呈现的效果如下所示：

切片的注意事项：

1）切片定义后不可以直接使用，需要让其引用到一个数组，或者make一个空间供切片来使用

2）切片使用不能越界

3）切片的简写方式

var slice = arr[0:end] ----》 var slice = arr[:end]

var slice = arr[start:len(arr)] ----》 var slice = arr[start:]

var slice = arr[0:len(arr)] ----》 var slice = arr[:]

4）切片可以继续切片

5）切片可以动态增长

func main() {// 定义数组var intarr [6]int = [6]int{1, 4, 7, 3, 6, 9}// 定义切片var slice []int = intarr[1:4] // 4 7 3fmt.Println(len(slice))       // 3slice2 := append(slice, 88, 50)fmt.Println(slice2) // [4 7 3 88 50]fmt.Println(slice)  // [4 7 3]/* 底层原理1.底层追加元素的时候对底层数组扩容，老数组扩容为新数组2.创建一个新数组，将老数组中的 4，7，3 拷贝到新数组中，在新数组中追加 88，503.slice2底层数组的指向 指向的是新数组4.往往我们在使用追加的时候其实想要做的效果是给slice追加元素，而不是给底层数组追加元素*/slice = append(slice, 10)fmt.Println(slice) // [4 7 3 10]// 底层的新数组不能直接维护，因为slice2底层数组的地址已经变了，所以我们需要重新创建一个新的切片，通过切片间接操作slice3 := []int{99, 44}slice = append(slice, slice3...)fmt.Println(slice) // [4 7 3 10 99 44]
}

6）切片的拷贝

func main() {// 定义数组var a []int = []int{1, 4, 7, 3, 6, 9}// 再定义一个切片var b []int = make([]int, 10)// 拷贝copy(b, a)     // 将a中的值拷贝到b中fmt.Println(b) // [1 4 7 3 6 9 0 0 0 0]
}

map映射

在Go语言中，map 是一种内置的数据结构，用于存储键值对（key-value pairs）的集合。map 提供了根据键来存储、检索和删除值的能力，使得在Go中处理关联数据变得非常方便，接下来通过如下代码示例进行演示：

func main() {// 定义map变量/*map: 这表示我们正在声明一个 map 类型的变量[int]string: 这部分定义了 map 的键和值的类型具体来说，int 是键的类型，而 string 是值的类型这意味着你可以将整数用作键，并将字符串作为与这些键相关联的值存储在 map 中*/var a map[int]string// 只声明map内存是没有分配空间的，需要使用make函数初始化分配空间a = make(map[int]string, 10) // map可以存放10个键值对，10可以不传，默认会分配一个起始大小// 初始化mapa[3] = "one"a[1] = "two"a[2] = "three"// 输出集合fmt.Println(a) // map[1:one 2:two 3:three]
}

注意：map集合在使用前一定要make；map的key是按照从小到大排序；key值不能重复，如果重复后一个value会对前一个进行覆盖，value是可以重复的；make函数的第二个参数size可以省略，默认就分配一个内存

map的创建方式可以通过如下的操作进行：

func main() {// map的创建方式// 方式1a := make(map[int]string)a[2020] = "张三"a[2019] = "李四"fmt.Println(a) // map[2019:李四 2020:张三]// 方式2b := map[int]string{2019: "张三",2020: "李四",}b[2018] = "王五"fmt.Println(b) // map[2018:王五 2019:张三 2020:李四]
}

当然我们也可以通过map对数值进行增删改查的操作，具体如下：

增加和更新操作：map["key"]= value 一》如果key还没有，就是增加，如果key存在就是修改。

func main() {a := make(map[int]string)// 增加操作a[2020] = "张三"a[2019] = "李四"// 修改操作a[2020] = "张三！！！"fmt.Println(a) // map[2019:李四 2020:张三！！！]
}

删除操作：delete(map，“key")，delete是一个内置函数，如果key存在，就删除该key-value，如果k的y不存在，不操作，但是也不会报错。

func main() {a := make(map[int]string)// 增加操作a[2020] = "张三"a[2019] = "李四"// 删除操作delete(a, 2019)fmt.Println(a) // map[2020:张三]
}

清空操作：如果我们要删除map的所有key，没有一个专门的方法一次删除，可以遍历一下key,逐个删除；或者map=make()，make一个新的，让原来的成为垃圾，被gc回收。

查找操作：value ,bool = map[key]；value为返回的value，bool为是否返回，要么true要么false。

func main() {a := make(map[int]string)// 增加操作a[2020] = "张三"a[2019] = "李四"// 查找操作value, flag := a[2019]if flag {fmt.Println(value) // 李四} else {fmt.Println("查找不到")}fmt.Println(a) // map[2020:张三]
}

当然map还有一些其他的操作，这里进行一个简单的演示：

package main
import "fmt"
func main() {a := make(map[int]string)a[2020] = "张三"a[2019] = "李四"a[2018] = "王五"// 获取长度fmt.Println(len(a))// 遍历for k, v := range a {fmt.Printf("key为：%v value为 %v \n", k, v)}// 上操作b := make(map[string]map[int]string) // 嵌套map// 赋值b["班级1"] = make(map[int]string)b["班级1"][2020] = "张三"b["班级1"][2019] = "李四"b["班级1"][2018] = "王五"b["班级2"] = make(map[int]string)b["班级2"][2019] = "张三1"b["班级2"][2018] = "李四1"b["班级2"][2017] = "王五1"// 遍历for k, v := range b {fmt.Println(k)for k1, v1 := range v {fmt.Printf("key为：%v value为 %v \n", k1, v1)}}
}

最终呈现的效果如下：