带你学够浪：Go语言基础系列 - 8分钟学复合类型

★

文章每周持续更新，原创不易，「三连」让更多人看到是对我最大的确定。能够微信搜索公众号「 后端技术学堂 」第一时间阅读（通常比博客早更新一到两篇）

”

对于通常的语言使用者来讲 ，20% 的语言特性就可以知足 80% 的使用需求，剩下在使用中掌握。基于这一理论，Go 基础系列的文章不会刻意追求面面俱到，但该有知识点都会覆盖，目的是带你快跑遇上 Golang 这趟新车。

Hurry up , Let's go !

前面咱们学习过 Golang 中基础数据类型，好比内置类型 int string bool 等，其实还有一些复杂一点点，但很好用的复合类型，相似 C 中的数组和 struct、C++ 中的 map ，今天咱们就来学习 Go 中的复合类型。

经过本文的学习你将掌握如下知识：

• 结构体
• 指针类型
• 数组和切片
• 映射类型

指针

指针不保存实际数据的内容，而是保存了指向值的内存地址 。用 & 对变量取内存地址，用 * 来访问指向的内存。这点和 C 中的指针是同样，惟一不一样的是 Go 中的指针不能运算。

a := 3
 pa := &a // 用 `&` 对变量取内存地址  fmt.Println("point", a, *pa) // 用 `*` 来访问指向的内存 复制代码

只声明没赋值的指针值是 nil ，表明空指针。

var a0 *int // 只声明没赋值的指针是nil
 if a0 == nil {  fmt.Println("point", "it is nil point")  } 复制代码

结构体

与C中的结构体相似， 结构体是一种聚合的数据类型，是由零个或多个任意类型的值聚合成的实体。每一个值称为结构体的成员，看例子：

type Test struct {
 a int  b int  } 复制代码

语法上的不一样看到了吗？ 每一个结构体字段以后没有分号，没有分号写起来仍是很舒服的。

初始化

能够在定义的时候初始化

test := Test{1, 2}  // 定义结构体变量并初始化
复制代码

初始化部分结构体字段

t2  = Test{a: 3}   //指定赋值Test.a为3 Test.b隐式赋值0
复制代码

隐式初始化

t3  = Test{}       // .a .b都隐式赋值0
复制代码

多个变量能够分组一块儿赋值

var (
 t1 = Test{8, 6}  t2 = Test{a: 3} //指定赋值Test.a Test.b隐式赋值0  t3 = Test{} // .a .b都隐式赋值0  pt4 = &Test{8, 6} // 指针 ) 复制代码

访问成员

经过 . 运算来访问结构体成员，不区分结构体类型或是结构体指针类型。

fmt.Println("struct", st0.a, st0.b) // 经过 . 运算来访问结构体成员
复制代码

对于只声明没赋值的结构体，其内部变量被赋予零值，下面咱们声明了 st0 但没有对其赋值。

var st0 Test  
fmt.Println("struct", st0.a, st0.b) //输出：struct 0 0 复制代码

数组

数组是一个由固定长度的特定类型元素组成的序列，一个数组能够由零个或多个元素组成。 数组能够用下标访问元素，下标从 0 开始。

数组声明后赋值

var strarr [2]string // 数组声明语法
 strarr[0] = "ready"  strarr[1] = "go" 复制代码

声明赋值同时完成

intarr := [5]int{6, 8, 9, 10, 7} // 声明赋值同时完成
复制代码

对于肯定初始值个数的数组，能够省略数组长度

intarr := [...]int{6, 8, 9, 10, 7} // 声明赋值同时完成
复制代码

Slice 切片

切片是变长的序列，序列中每一个元素都有相同的类型。slice 语法和数组很像，只是没有固定长度而已，切片底层引用一个数组对象，修改切片会修改原数组。

经过切片能够访问数组的部分或所有元素，正由于切片长度不是固定的，所以切片比数组更加的经常使用。

声明与初始化

常规初始化

简短声明并初始化切片

s0 := []int{1, 2, 3, 4, 5, 6} // 简短声明加赋值
复制代码

声明后再初始化

var s []int        // 声明切片s
s = s0 // 用切片s0初始化切片s 复制代码

声明并初始化切片

var s00 []int = s0 // 用切片s0初始化切片s
复制代码

切片的零值是 nil

// 切片的零值是nil 空切片长度和容量都是0
var nilslice []int if nilslice == nil {  fmt.Println("slice", "nilslice is nil ", len(nilslice), cap(nilslice)) }  复制代码

make初始化

除了上述的常规初始化方法，还能够用 make 内置函数来建立切片

// 内建函数make建立切片，指定切片长度和容量
// make 函数会分配一个元素为零值的数组并返回一个引用了它的切片 s2 := make([]int, 4, 6) //建立元素都是0的切片s2, 长度为4，容量为6 第三个参数能够省略 fmt.Println("slice", len(s2), cap(s2), s2) 复制代码

切片长度

长度表示切片中元素的数目，可用内置函数 len 函数获得。

切片容量

容量表示切片中第一个元素到引用的底层数组结尾所包含元素个数，可用内置函数 cap 求得。

切片区间

切片区间遵循「左闭右开」原则，

s0 := [5]int{6, 8, 9, 10, 7} // 数组定义
var slice []int = intarr[1:4] // 建立切片slice 包含数组子序列 复制代码

默认上下界。切片下界的默认值为 0，上界默认是该切片的长度。

fmt.Println("slice", s0[:], s0[0:], s0[:5], s0[0:5]) // 这四个切片相同
复制代码

切片append操做

append 函数用于在切片末尾追加新元素。

添加元素也分两种状况。

添加以后长度还在原切片容量范围内

s2 := make([]int, 4, 6) //建立元素都是0的切片s2, 长度为4，容量为6 第三个参数能够省略
s22 := append(s2, 2) // append每次都是在最后添加，因此此时，s21 s22指向同一个底层数组 fmt.Println(s21, s22) // [0 0 0 0 2] [0 0 0 0 2] 复制代码

添加元素以后长度超出原切片容量

此时会分配新的数组空间，并返回指向这个新分配的数组的切片。

下面例子中 s24 切片已经指向新分配的数组，s22 依然指向的是原来的数组空间，而 s24 已经指向了新的底层数组。

s24 := append(s2, 1, 2, 3)
 fmt.Println(s24, s22) // s24 [0 0 0 0 1 2 3] [0 0 0 0 2] 复制代码

二维切片

能够定义切片的切片，相似其余语言中的二维数组用法。参考代码：

s3 := [][]int{
 {1, 1, 1},  {2, 2, 2},  }  fmt.Println(s3, s3[0], len(s3), cap(s3)) // 输出： [[1 1 1] [2 2 2]] [1 1 1] 2 2 复制代码

map 映射类型

在 Go 中 map 是键值对类型，表明 key 和value 的映射关系，一个map就是一个哈希表的引用 。

定义和初始化

下面这样定义并初始化一个 map 变量

m0 := map[int]string{
 0: "0",  1: "1",  } 复制代码

也能够用内置 make 函数来初始化一个 map 变量，后续再向其中添加键值对。像下面这样：

m1 := make(map[int]string) // make 函数会返回给定类型的映射，并将其初始化备用
 if m1 != nil {  fmt.Println("map", "m1 is not nil", m1) // m1 不是nil  }  m1[0] = "1"  m1[1] = "2" 复制代码

注意：只声明不初始化的map变量是 nil 映射，不能直接拿来用！

var m map[int]string // 未初始化的m零值是nil映射
 if m == nil {  fmt.Println("map", "m is nil", m)  }  //m[0] = "1" // 这句引起panic异常， 映射的零值为 nil 。nil映射既没有键，也不能添加键。 复制代码

元素读取

使用语法：vaule= m[key] 获取键 key 对应的元素 vaule 。

上面咱们只用了一个变量来获取元素，其实这个操做会返回两个值，第一个返回值表明读书的元素，第二个返回值是表明键是否存在的 bool 类型，举例说明：

v, st := m1[0]  // v是元素值，下标对应的元素存在st=true 不然st=false
 _, st1 := m1[0] // _ 符号表示忽略第一个元素  v1, _ := m1[0] // _ 符号表示忽略第二个元素   fmt.Println(v, st, v1, st1, m1[2]) // m1[2]不存在，返回元素string的零值「空字符」 复制代码

删除元素

内置函数 delete 能够删除 map 元素，举例：

delete(m1, 1)  // 删除键是 1 的元素
复制代码

range 遍历

range 用于遍历 切片 或 映射。

数组或切片遍历

当使用for 循环和 range 遍历数组或切片时，每次迭代都会返回两个值。第一个值为当前元素的下标，第二个值为该下标所对应元素的一份副本。

s1 := []int{1, 2, 3, 4, 5, 6}  
for key, vaule := range s1 {  fmt.Println("range", key, vaule) }  for key := range s1 { // 只须要索引，忽略第二个变量便可  fmt.Println("range", key) }  for _, vaule := range s1 { // 只须要元素值，用'_'忽略索引  fmt.Println("range", vaule) } 复制代码

map 遍历

当使用for 循环和 range 遍历map 时，每次迭代都会返回两个值。第一个值为当前元素 key ， 第二个值是 value。

m0 := map[int]string{
 0: "0",  1: "1", } fmt.Println("map", m0)  for k, v := range m0 { // range遍历映射，返回key 和 vaule  fmt.Println("map", "m0 key:", k, "vaule:", v) } 复制代码

总结

经过本文的学习，咱们掌握了 Golang 中基本的控制流语句，利用这些控制语句加上一节介绍的变量等基础知识，能够构成丰富的程序逻辑，你就能用 Golang 来作一些有意思的事情了。

感谢各位的阅读，文章的目的是分享对知识的理解，技术类文章我都会反复求证以求最大程度保证准确性，若文中出现明显纰漏也欢迎指出，咱们一块儿在探讨中学习.

今天的技术分享就到这里，咱们下期再见。

---

创做不易，白票不是好习惯，若是在我这有收获，动动手指「点赞」「关注」是对我持续创做的最大支持。

★

能够微信搜索公众号「 后端技术学堂 」回复「资料」「1024」有我给你准备的各类编程学习资料。文章每周持续更新，咱们下期见！