go 学习笔记之数组还是切片都没什么不一样
上篇文章中详细介绍了 Go
的基础语言,指出了 Go
和其他主流的编程语言的差异性,比较侧重于语法细节,相信只要稍加记忆就能轻松从已有的编程语言切换到 Go
语言的编程习惯中,尽管这种切换可能并不是特别顺畅,但多加练习尤其是多多试错,总是可以慢慢感受 Go
语言之美!
在学习 Go
的内建容器前,同样的,我们先简单回顾一下 Go
的基本语言,温度而知新可以为师矣!
上节知识回顾
如需了解详情,请于微信公众号[雪之梦技术驿站]内查看 go 学习笔记之值得特别关注的基础语法有哪些 文章,觉得有用的话,顺手转发一下呗!
内建类型种类
bool
布尔类型,可选
true|false
,默认初始化零值false
.
(u)int
,(u)int8
,(u)int16
,(u)int32
,(u)int64
,uintptr
2^0=1
,2^1=2
,2^2=4
个字节长度的整型,包括有符号整型和无符号整型以及uintptr
类型的指针类型,默认初始化零值0
.
byte(uint8)
,rune(int32)
,string
byte
是最基础字节类型,是uint8
类型的别名,而rune
是Go
中的字符类型,是int32
的别名.最常用的字符串类型string
应该不用介绍了吧?
float32
,float64
,complex64
,complex128
只有
float
类型的浮点型,没有double
类型,同样是以字节长度来区分,complex64
是复数类型,实部和虚部由float32
类型复合而成,因此写作complex64
这种形式.
内建类型特点
- 类型转换只有显示转换,不存在任何形式的隐式类型转换
不同变量类型之间不会自动进行隐式类型转换,
Go
语言的类型转换只有强制的,只能显示转换.
- 虽然提供指针类型,但指针本身不能进行任何形式的计算.
指针类型的变量不能进行计算,但是可以重新改变内存地址的指向.
- 变量声明后有默认初始化零值,变量零值视具体类型而定
int
类型的变量的初始化零值是0
,string
类型的初始化零值是空字符串,并不是nil
基本运算符
- 算术运算符没有
++i
和--i
只有
i++
和i--
这种自增操作,再也不用担心两种方式的差异性了!
- 比较运算符
==
可以比较数组是否相等
当两个数组的维度和数组长度相等时,两个数组可以进行比较,顺序完全一致时,结果为
true
,其他情况则是false
.
- 位运算符新增按位清零运算符
&^
其他主流的编程语言虽然没有这种操作符,通过组合命令也可以实现类似功能,但既然提供了按位清零运算符,再也不用自己进行组合使用了!
流程控制语句
if
条件表达式不需要小括号并支持变量赋值操作
先定义临时变量并根据该变量进行逻辑判断,然后按照不同情况进行分类处理,
Go
处理这种临时变量的情况,直接对条件表达式进行增强,这种情况以后会很常见!
if
条件表达式内定义的变量作用域仅限于当前语句块
条件表达式内定义的变量是为了方便处理不同分支的逻辑,既然是临时变量,出了当前的
if
语句块就无法使用,也变得可以理解.
switch
语句可以没有break
,除非使用了fallthrough
switch
语句的多个case
结尾处可以没有break
,系统会自动进行break
处理.
switch
条件表达式不限制为常数或整数
和其他主流的编程语言相比,
Go
语言的switch
条件表达式更加强大,类型也较为宽松.
switch
条件表达式可以省略,分支逻辑转向case
语言实现.
省略
switch
条件表达式,多个case
语言进行分支流程控制,功能效果和多重if else
一样.
- 省略
switch
条件表达式后,每个case
条件可以有多个条件,用逗号分隔.
swicth
语句本质上是根据不同条件进行相应的流程控制,每个case
的条件表达式支持多个,更是增强了流程控制的能力.
for
循环的条件表达式也不需要小括号,且没有其他形式的循环.
Go
语言只有for
循环,没有while
等其他形式的循环.
for
循环的初始条件,终止条件和自增表达式都可以省略或者同时省略
条件表达式进行省略后可以实现
while
循环的效果,全部省略则是死循环.
函数和参数传递
- 函数声明按照函数名,入参,出参顺序定义,并支持多返回值
不论是变量定义还是函数定义,
Go
总是和其他主流的编程语言反着来,如果按照输入输出的顺序思考就会发现,这种定义方式其实挺有道理的.
- 函数有多个返回值时可以给返回值命名,但对调用者而言没有差别
函数返回多个值时可以有变量名,见名知意方便调用者快速熟悉函数声明,但调用者并非一定要按照返回值名称接收调用结果.
- 函数的入参没有必填参数,可选参数等复杂概念,只支持可变参数列表
可变参数列表和其他主流的编程语言一样,必须是入参的最后一个.
- 函数参数传递只有值传递,没有引用传递,即全部需要重新拷贝变量
参数传递只有值传递,逻辑上更加简单,但是处理复杂情况时可以传递指针实现引用传递的效果.
内建容器有哪些
复习了 Go
语言的基础语法后,开始继续学习变量类型的承载者也就是容器的相关知识.
承载一类变量最基础的底层容器就是数组了,大多数高级的容器底层都可以依靠数组进行封装,所以先来了解一下 Go
的数组有何不同?
数组和切片
- 数组的声明和初始化
数组的明显特点就是一组特定长度的连续存储空间,声明数组时必须指定数组的长度,声明的同时可以进行初始化,当然不指定数组长度时也可以使用 ...
语法让编译器帮我们确定数组的长度.
func TestArray(t *testing.T) {
var arr1 [3]int
arr2 := [5]int{1, 2, 3, 4, 5}
arr3 := [...]int{2, 4, 6, 8, 10}
// [0 0 0] [1 2 3 4 5] [2 4 6 8 10]
t.Log(arr1, arr2, arr3)
var grid [3][4]int
// [[0 0 0 0] [0 0 0 0] [0 0 0 0]]
t.Log(grid)
}
[3]int
指定数组长度为3
,元素类型为int
,当然也可以声明时直接赋值[5]int{1, 2, 3, 4, 5}
,如果懒得指定数组长度,可以用[...]int{2, 4, 6, 8, 10}
表示.
- 数组的遍历和元素访问
最常见的 for
循环进行遍历就是根据数组的索引进行访问,range arr
方式提供了简化遍历的便捷方法.
func TestArrayTraverse(t *testing.T) {
arr := [...]int{2, 4, 6, 8, 10}
for i := 0; i < len(arr); i++ {
t.Log(arr[i])
}
for i := range arr {
t.Log(arr[i])
}
for i, v := range arr {
t.Log(i, v)
}
for _, v := range arr {
t.Log(v)
}
}
range arr
可以返回索引值和索引项,如果仅仅关心索引项而不在乎索引值的话,可以使用_
占位符表示忽略索引值,如果只关心索引值,那么可以不写索引项.这种处理逻辑也就是函数的多返回值顺序接收,不可以出现未使用的变量.
- 数组是值类型可以进行比较
数组是值类型,这一点和其他主流的编程语言有所不同,因此相同纬度且相同元素个数的数组可以比较,关于这方面的内容前面也已经强调过,这里再次简单回顾一下.
func printArray(arr [5]int) {
arr[0] = 666
for i, v := range arr {
fmt.Println(i, v)
}
}
func TestPrintArray(t *testing.T) {
var arr1 [3]int
arr2 := [5]int{1, 2, 3, 4, 5}
arr3 := [...]int{2, 4, 6, 8, 10}
// [0 0 0] [1 2 3 4 5] [2 4 6 8 10]
t.Log(arr1, arr2, arr3)
// cannot use arr1 (type [3]int) as type [5]int in argument to printArray
//printArray(arr1)
fmt.Println("printArray(arr2)")
printArray(arr2)
fmt.Println("printArray(arr3)")
printArray(arr3)
// [1 2 3 4 5] [2 4 6 8 10]
t.Log(arr2, arr3)
}
因为参数传递是值传递,所以
printArray
函数无法更改调用者传递的外部函数值,如果想要在函数printArray
内部更改传递过来的数组内容,可以通过指针来实现,但是有没有更简单的做法?
想要在 printArrayByPointer
函数内部修改参数数组,可以通过数组指针的方式,如果有不熟悉的地方,可以翻看上一篇文章回顾查看.
func printArrayByPointer(arr *[5]int) {
arr[0] = 666
for i, v := range arr {
fmt.Println(i, v)
}
}
func TestPrintArrayByPointer(t *testing.T) {
var arr1 [3]int
arr2 := [5]int{1, 2, 3, 4, 5}
arr3 := [...]int{2, 4, 6, 8, 10}
// [0 0 0] [1 2 3 4 5] [2 4 6 8 10]
t.Log(arr1, arr2, arr3)
fmt.Println("printArrayByPointer(arr2)")
printArrayByPointer(&arr2)
fmt.Println("printArrayByPointer(arr3)")
printArrayByPointer(&arr3)
// [666 2 3 4 5] [666 4 6 8 10]
t.Log(arr2, arr3)
}
修改数组的元素可以通过传递数组指针来实现,除此之外,
Go
语言中数组还有一个近亲slice
,也就是切片,它可以实现类似的效果.
- 切片的声明和初始化
切片和数组非常类似,创建数组时如果没有指定数组的长度,那么最终创建的其实是切片并不是数组.
func TestSliceInit(t *testing.T) {
var s1 [5]int
// [0 0 0 0 0]
t.Log(s1)
var s2 []int
// []
t.Log(s2,len(s2))
}
[]int
没有指定长度,此时创建的是切片,默认初始化零值是nil
,并不是空数组!
同理,数组可以声明并初始化,切片也可以,并且语法也很类似,稍不注意还以为是数组呢!
func TestSliceInitValue(t *testing.T) {
var s1 = [5]int{1, 3, 5, 7, 9}
// [1 3 5 7 9]
t.Log(s1)
var s2 = []int{1, 3, 5, 7, 9}
// [1 3 5 7 9]
t.Log(s2)
}
仅仅是没有指定
[]
中的长度,最终创建的结果就变成了切片,真的让人眼花缭乱!
数组和切片如此相像,让人不得不怀疑两者之间有什么见不得人的勾当?其实可以从数组中得到切片,下面举例说明:
func TestSliceFromArray(t *testing.T) {
arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
// arr = [0 1 2 3 4 5 6 7 8 9]
t.Log("arr = ", arr)
// arr[2:6] = [2 3 4 5]
t.Log("arr[2:6] = ", arr[2:6])
// arr[:6] = [0 1 2 3 4 5]
t.Log("arr[:6] = ", arr[:6])
// arr[2:] = [2 3 4 5 6 7 8 9]
t.Log("arr[2:] = ", arr[2:])
// arr[:] = [0 1 2 3 4 5 6 7 8 9]
t.Log("arr[:] = ", arr[:])
}
arr[start:end]
截取数组的一部分得到的结果就是切片,切片的概念也是很形象啊!
和其他主流的编程语言一样,[start:end]
是一个左闭右开区间,切片的含义也非常明确:
忽略起始索引 start
时,arr[:end]
表示原数组从头开始直到终止索引 end
的前一位;
忽略终止索引 end
时,arr[ start:]
表示原数组从起始索引 start
开始直到最后一位;
既忽略起始索引又忽略终止索引的情况,虽然不常见但是含义上将应该就是原数组,但是记得类型是切片不是数组哟!
目前为止,我们知道切片和数组很相似,切片相对于数组只是没有大小,那么切片和数组的操作上是否一样呢?
func updateSlice(s []int) {
s[0] = 666
}
func TestUpdateSlice(t *testing.T) {
arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
// arr = [0 1 2 3 4 5 6 7 8 9]
t.Log("arr = ", arr)
s1 := arr[2:6]
// s1 = [2 3 4 5]
t.Log("s1 = ", s1)
s2 := arr[:6]
// s2 = [0 1 2 3 4 5]
t.Log("s2 = ", s2)
updateSlice(s1)
// s1 = [666 3 4 5]
t.Log("s1 = ", s1)
// arr = [0 1 666 3 4 5 6 7 8 9]
t.Log("arr = ", arr)
updateSlice(s2)
// s2 = [666 1 666 3 4 5]
t.Log("s2 = ", s2)
// arr = [666 1 666 3 4 5 6 7 8 9]
t.Log("arr = ", arr)
}
切片竟然可以更改传递参数,这一点可是数组没有做到的事情啊!除非使用数组的指针类型,切片竟然可以轻易做到?除非切片内部是指针,因为参数传递只有值传递,根本没有引用传递方式!
切片和数组在参数传递的表现不同,具体表现为数组进行参数传递时无法修改数组,想要想改数组只有传递数组指针才行,而切片却实现了数组的改变!
由于参数传递只有值传递一种方式,因此推测切片内部肯定存在指针,参数传递时传递的是指针,所以函数内部的修改才能影响到到函数外部的变量.
slice
的内部实现中有三个变量,指针ptr
,个数len
和容量cap
,其中ptr
指向真正的数据存储地址.
正是由于切片这种内部实现,需要特性也好表现形式也罢才使得切换和数组有着千丝万缕的联系,其实这种数据结果就是对静态数组的扩展,本质上是一种动态数组而已,只不过 Go
语言叫做切片!
切片是动态数组,上述问题就很容易解释了,参数传递时传递的是内部指针,因而虽然是值传递拷贝了指针,但是指针指向的真正元素毕竟是一样的,所以切片可以修改外部参数的值.
数组可以在一定程度上进行比较,切片是动态数组,能不能进行比较呢?让接下来的测试方法来验证你的猜想吧!
不知道你有没有猜对呢?切片并不能进行比较,只能与
nil
进行判断.
- 切片的添加和删除
数组是静态结构,数组的大小不能扩容或缩容,这种数据结构并不能满足元素个数不确定场景,因而才出现动态数组这种切片,接下来重点看下切片怎么添加或删除元素.
func printSlice(s []int) {
fmt.Printf("s = %v, len(s) = %d, cap(s) = %d\n", s, len(s), cap(s))
}
func TestSliceAutoLonger(t *testing.T) {
var s []int
// []
t.Log(s)
for i := 0; i < 10; i++ {
s = append(s, i)
printSlice(s)
}
// [0 1 2 3 ...,98,99]
t.Log(s)
for i := 0; i < 10; i++ {
s = s[1:]
printSlice(s)
}
// [0 1 2 3 ...,98,99]
t.Log(s)
}
添加元素
s = append(s, i)
需要扩容时,每次以2
倍进行扩容,删除元素s[1:]
时,递减缩容.
s = append(s, i)
向切片中添加元素并返回新切片,由于切片是动态数组,当切片内部的数组长度不够时会自动扩容以容纳新数组,扩容前后的内部数组会进行元素拷贝过程,所以 append
会返回新的地址,扩容后的地址并不是原来地址,所以需要用变量接收添加后的切片.
当不断进行切片重新截取时 s[1:]
,切片存储的元素开始缩减,个数递减,容量也递减.
其实除了基于数组创建切片和直接创建切片的方式外,还存在第三种创建切片的方式,也是使用比较多的方式,那就是 make
函数.
func TestMakeSlice(t *testing.T) {
s1 := make([]int,10)
// s1 = [0 0 0 0 0 0 0 0 0 0], len(s1) = 10, cap(s1) = 10
t.Logf("s1 = %v, len(s1) = %d, cap(s1) = %d", s1, len(s1), cap(s1))
s2 := make([]int, 10, 32)
// s2 = [0 0 0 0 0 0 0 0 0 0], len(s2) = 10, cap(s2) = 32
t.Logf("s2 = %v, len(s2) = %d, cap(s2) = %d", s2, len(s2), cap(s2))
}
通过 make
方式可以设置初始化长度和容量,这是字面量创建切片所不具备的能力,并且这种方式创建的切片还支持批量拷贝功能!
func TestCopySlice(t *testing.T) {
var s1 = []int{1, 3, 5, 7, 9}
var s2 = make([]int, 10, 32)
copy(s2, s1)
// s2 = [1 3 5 7 9 0 0 0 0 0], len(s2) = 10, cap(s2) = 32
t.Logf("s2 = %v, len(s2) = %d, cap(s2) = %d", s2, len(s2), cap(s2))
var s3 []int
copy(s3, s1)
// s3 = [], len(s3) = 0, cap(s3) = 0
t.Logf("s3 = %v, len(s3) = %d, cap(s3) = %d", s3, len(s3), cap(s3))
}
func copy(dst, src []Type) int
是切片之间拷贝的函数,神奇的是,只有目标切片是make
方式创建的切片才能进行拷贝,不明所以,有了解的小伙伴还请指点一二!
切片的底层结构是动态数组,如果切片是基于数组截取而成,那么此时的切片从效果上来看,切片就是原数组的一个视图,对切片的任何操作都会反映到原数组上,这也是很好理解的.
那如果对切片再次切片呢,或者说切片会不会越界,其实都比较简单了,还是稍微演示一下,重点就是动态数组的底层结构.
func TestSliceOutOfBound(t *testing.T) {
arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
s1 := arr[2:6]
// s1 = [2 3 4 5], len(s1) = 4, cap(s1) = 6
t.Logf("s1 = %v, len(s1) = %d, cap(s1) = %d", s1, len(s1), cap(s1))
s2 := s1[3:5]
// s2 = [5 6], len(s2) = 2, cap(s2) = 3
t.Logf("s2 = %v, len(s2) = %d, cap(s2) = %d", s2, len(s2), cap(s2))
}
[]
只能访问len(arr)
范围内的元素,[:]
只能访问cap(arr)
范围内的元素,一般而言cap >= len
所以某些情况看起来越界,其实并不没有越界,只是二者的标准不同!
我们知道切片 slice
的内部数据结构是基于动态数组,存在三个重要的变量,分别是指针 ptr
,个数 len
和容量 cap
,理解了这三个变量如何实现动态数组就不会掉进切片的坑了!
个数 len
是通过下标访问时的有效范围,超过 len
后会报越界错误,而容量 cap
是往后能看到的最大范围,动态数组的本质也是控制这两个变量实现有效数组的访问.
因为
s1 = [2 3 4 5], len(s1) = 4, cap(s1) = 6
,所以[]
访问切片s1
元素的范围是[0,4)
,因此最大可访问到s1[3]
,而s1[4]
已经越界了!
因为
s1 = [2 3 4 5], len(s1) = 4, cap(s1) = 6
,所以[:]
根据切片s1
创建新切片的范围是[0,6]
,因此最大可访问范围是s1[0:6]
,而s1[3:7]
已经越界!
集合 map
集合是一种键值对组成的数据结构,其他的主流编程语言也有类似概念,相比之下,Go
语言的 map
能装载的数据类型更加多样化.
- 字面量创建
map
换行需保留逗号,
func TestMap(t *testing.T) {
m1 := map[string]string{
"author": "snowdreams1006",
"website": "snowdreams1006",
"language": "golang",
}
// map[name:snowdreams1006 site:https://snowdreams1006.github.io]
t.Log(m1)
}
一对键值对的结尾处加上逗号
,
可以理解,但是最后一个也要有逗号这就让我无法理解了,Why
?
make
创建的map
和字面量创建的map
默认初始化零值不同
func TestMapByMake(t *testing.T) {
// empty map
m1 := make(map[string]int)
// map[] false
t.Log(m1, m1 == nil)
// nil
var m2 map[string]int
// map[] true
t.Log(m2, m2 == nil)
}
make
函数创建的map
是空map
,而通过字面量形式创建的map
是nil
,同样的规律也适合于切片slice
.
range
遍历map
是无序的
func TestMapTraverse(t *testing.T) {
m := map[string]string{
"name": "snowdreams1006",
"site": "https://snowdreams1006.github.io",
}
// map[name:snowdreams1006 site:https://snowdreams1006.github.io]
t.Log(m)
for k, v := range m {
t.Log(k, v)
}
t.Log()
for k := range m {
t.Log(k)
}
t.Log()
for _, v := range m {
t.Log(v)
}
}
这里再一次遇到
range
形式的遍历,忽略键或值时用_
占位,也是和数组,切片的把遍历方式一样,唯一的差别就是map
没有索引,遍历结果也是无序的!
- 获取元素时需判断元素是否存在
func TestMapGetItem(t *testing.T) {
m := map[string]string{
"name": "snowdreams1006",
"site": "https://snowdreams1006.github.io",
}
// snowdreams1006
t.Log(m["name"])
// zero value is empty string
t.Log(m["author"])
// https://snowdreams1006.github.io
if site, ok := m["site"]; ok {
t.Log(site)
} else {
t.Log("key does not exist ")
}
}
Go
语言的map
获取不存在的键时,返回的是值对应类型的零值,map[string]string
返回的默认零值就是空字符串,由于不会报错进行强提醒,这也就要求我们调用时多做一步检查.当键值对存在时,第二个返回值返回true
,不存在时返回false
.
- 删除键值对时用
delete
函数
func TestMapDeleteItem(t *testing.T) {
m := map[string]string{
"name": "snowdreams1006",
"site": "https://snowdreams1006.github.io",
}
// map[name:snowdreams1006 site:https://snowdreams1006.github.io]
t.Log(m)
delete(m, "name")
// map[site:https://snowdreams1006.github.io]
t.Log(m)
delete(m, "id")
// map[site:https://snowdreams1006.github.io]
t.Log(m)
}
delete(map,key)
用于删除map
的键值对,如果想要验证是否删除成功,别忘了使用value,ok := m[k]
确定是否存在指定键值对
- 除
slice
,map
,func
外,其余类型均可键
因为
map
是基于哈希表实现,所以遍历是无序的,另一方面因为slice
,map
,func
不可比较,因为也不能作为键.当然若自定义类型struc
不包含上述类型,也可以作为键,并不要求实现hashcode
和equal
之类的.
value
可以承载函数func
类型
func TestMapWithFunValue(t *testing.T) {
m := map[int]func(op int) int{}
m[1] = func(op int) int {
return op
}
m[2] = func(op int) int {
return op * op
}
m[3] = func(op int) int {
return op * op * op
}
// 1 4 27
t.Log(m[1](1), m[2](2), m[3](3))
}
再一次说明函数是一等公民,这部分会在以后的函数式编程中进行详细介绍.
没有 set
Go
的默认类型竟然没有 set
这种数据结构,这在主流的编程语言中算是特别的存在了!
正如 Go
的循环仅支持 for
循环一样,没有 while
循环一样可以玩出 while
循环的效果,靠的就是增强的 for
能力.
所以,即使没有 set
类型,基于现有的数据结构一样能实现 set
效果,当然直接用 map
就可以封装成 set
.
func TestMapForSet(t *testing.T) {
mySet := map[int]bool{}
mySet[1] = true
n := 3
if mySet[n] {
t.Log("update", mySet[n])
} else {
t.Log("add", mySet[n])
}
delete(mySet, 1)
}
使用
map[type]bool
封装实现set
禁止重复性元素的特性,等到讲解到面向对象部分再好好封装,这里仅仅列出核心结构.
知识点总结梳理
Go
语言是十分简洁的,不论是基础语法还是这一节的内建容器都很好的体现了这一点.
数组作为各个编程语言的基础数据结构,Go
语言和其他主流的编程语言相比没有什么不同,都是一片连续的存储空间,不同之处是数组是值类型,所以也是可以进行比较的.
这并不是新鲜知识,毕竟上一节内容已经详细阐述过该内容,这一节的重点是数组的衍生版切片 slice
.
因为数组本身是特定长度的连续空间,因为是不可变的,其他主流的编程语言中有相应的解决方案,其中就有不少数据结构的底层是基于数组实现的,Go
语言的 slice
也是如此,因此个人心底里更愿意称其为动态数组!
切片 slice
的设计思路非常简单,内部包括三个重要变量,包括数组指针 ptr
,可访问元素长度 len
以及已分配容量 cap
.
当新元素不断添加进切片时,总会达到已最大分配容量,此时切片就会自动扩容,反之则会缩容,从而实现了动态控制的能力!
- 指定元素个数的是数组,未指定个数的是切片
func TestArrayAndSlice(t *testing.T) {
// array
var arr1 [3]int
// slice
var arr2 []int
// [0 0 0] []
t.Log(arr1,arr2)
}
- 基于数组创建的切片是原始数组的视图
func TestArrayAndSliceByUpdate(t *testing.T) {
arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
// arr = [0 1 2 3 4 5 6 7 8 9]
t.Log("arr = ", arr)
s := arr[2:6]
// before update s = [2 3 4 5], arr = [0 1 2 3 4 5 6 7 8 9]
t.Logf("before update s = %v, arr = %v", s, arr)
s[0] = 666
// after update s = [666 3 4 5], arr = [0 1 666 3 4 5 6 7 8 9]
t.Logf("after update s = %v, arr = %v", s, arr)
}
- 添加或删除切片元素都返回新切片
func TestArrayAndSliceIncreasing(t *testing.T) {
var s []int
fmt.Println("add new item to slice")
for i := 0; i < 10; i++ {
s = append(s, i)
fmt.Printf("s = %v, len(s) = %d, cap(s) = %d\n", s, len(s), cap(s))
}
fmt.Println("remove item from slice")
for i := 0; i < 10; i++ {
s = s[1:]
fmt.Printf("s = %v, len(s) = %d, cap(s) = %d\n", s, len(s), cap(s))
}
}
[index]
访问切片元素仅仅和切片的len
有关,[start:end]
创建新切片仅仅和原切片的cap
有关
func TestArrayAndSliceBound(t *testing.T) {
arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s1 := arr[5:8]
// s1[0] = 5, s1[2] = 7
t.Logf("s1[0] = %d, s1[%d] = %d", s1[0], len(s1)-1, s1[len(s1)-1])
// s1 = [5 6 7], len(s1) = 3, cap(s1) = 5
t.Logf("s1 = %v, len(s1) = %d, cap(s1) = %d", s1, len(s1), cap(s1))
s2 := s1[3:5]
// s2[0] = 8, s2[1] = 9
t.Logf("s2[0] = %d, s2[%d] = %d", s2[0], len(s2)-1, s2[len(s2)-1])
// s2 = [8 9], len(s2) = 2, cap(s2) = 2
t.Logf("s2 = %v, len(s2) = %d, cap(s2) = %d", s2, len(s2), cap(s2))
}
- 只有
map
没有set
func TestMapAndSet(t *testing.T) {
m := map[string]string{
"name": "snowdreams1006",
"site": "https://snowdreams1006.github.io",
"lang": "go",
}
// https://snowdreams1006.github.io
if site, ok := m["site"]; ok {
t.Log(site)
} else {
t.Log("site does not exist ")
}
s := map[string]bool{
"name": true,
"site": true,
"lang": true,
}
// Pay attention to snowdreams1006
if _, ok := m["isFollower"]; ok {
t.Log("Have an eye on snowdreams1006")
} else {
s["isFollower"] = true
t.Log("Pay attention to snowdreams1006")
}
}
delete
函数删除集合map
键值对
func TestMapAndSetByDelete(t *testing.T) {
m := map[string]string{
"name": "snowdreams1006",
"site": "https://snowdreams1006.github.io",
"lang": "go",
}
delete(m, "lang")
// delete lang successfully
if _,ok := m["lang"];!ok{
t.Log("delete lang successfully")
}
}
关于 Go
语言中内建容器是不是都已经 Get
了呢?如果有表述不对的地方,还请指正哈,欢迎一起来公众号[雪之梦技术驿站]学习交流,每天进步一点点!
go 学习笔记之数组还是切片都没什么不一样的更多相关文章
- [Golang学习笔记] 07 数组和切片
01-06回顾: Go语言开发环境配置, 常用源码文件写法, 程序实体(尤其是变量)及其相关各种概念和编程技巧: 类型推断,变量重声明,可重名变量,类型推断,类型转换,别名类型和潜在类型 数组: 数组 ...
- Go语言学习笔记(4)——数组和切片
1 数组的特点: 长度固定.元素数据类型相同.下标从0开始 1.1 声明和初始化: var array_name [size] type var arr1 [10] float32 ...
- PHP学习笔记之数组篇
摘要:其实PHP中的数组和JavaScript中的数组很相似,就是一系列键值对的集合.... 转载请注明来源:PHP学习笔记之数组篇 一.如何定义数组:在PHP中创建数组主要有两种方式,下面就让我 ...
- JavaScript学习笔记之数组(二)
JavaScript学习笔记之数组(二) 1.['1','2','3'].map(parseInt) 输出什么,为什么? ['1','2','3'].map(parseInt)//[1,NaN,NaN ...
- Scala入门学习笔记三--数组使用
前言 本篇主要讲Scala的Array.BufferArray.List,更多教程请参考:Scala教程 本篇知识点概括 若长度固定则使用Array,若长度可能有 变化则使用ArrayBuffer 提 ...
- JavaScript学习笔记:数组reduce()和reduceRight()方法
很多时候需要累加数组项的得到一个值(比如说求和).如果你碰到一个类似的问题,你想到的方法是什么呢?会不会和我一样,想到的就是使用for或while循环,对数组进行迭代,依次将他们的值加起来.比如: v ...
- JavaScript学习笔记之 数组方法一 堆栈 和队列
数组的方法 以及 堆栈的操作的方法 JavaScript是一种弱类型语言,不像其它程序语言需要严格定义数据类型.在JavaScript中数组可以任意修改变动,这样也就出现了一个问题,如果边遍历数组边操 ...
- 小甲鱼:Python学习笔记002_数组_元组_字符串
创建普通数组 >>> member=["山东黄金","九阳股份"] >>> member ['山东黄金', '九阳股份'] ...
- [学习笔记]JS 数组Array push相关问题
前言: 今天用写了一个二维数组,都赋值为零,然后更新其中一个值,结果和预期是不一样,会整列的相同位置都是同一个值. 1.用Chrome的控制台样例如下: arrs[2][2] =1的赋值,竟然是三个数 ...
随机推荐
- Greenplum高可用真的高吗?
目录 1. 问题描述 2. 解决方案 @ 1. 问题描述 在项目中使用了Greenplum做分析型数据库,Greenplum自身已经提供了高可用方案,Master节点提供Sdanby备用节点,Segm ...
- Java操作文件
import java.io.File; import java.io.IOException; import java.nio.file.*; import java.nio.file.attrib ...
- SpringBoot Jpa入门案例
版权声明:署名,允许他人基于本文进行创作,且必须基于与原先许可协议相同的许可协议分发本文 (Creative Commons) 我们先来了解一下是什么是springboot jpa,springboo ...
- 使用docker搭建gitlab服务器
简单记录Docker的使用和GitLab的搭建 Docker基础篇 没有sudo权限 安装docker 基础命令 docker安装mysql和配置 Dockerfile常用命令 制作镜像 发布镜像 容 ...
- 渐进式web应用开发---promise式数据库(五)
在前面的一篇文章中,我们已经实现了使用indexedDB实现ajax本地数据存储的功能,详情,请看这篇文章.现在我们需要把上面的一篇文章中的代码使用promise结构来重构下.我们为什么需要使用pro ...
- html+css-->background-img(背景图的设置)
背景图:(相关验证代码请查看代码,在验证时需将当前不需要验证的代码注释掉) 1.inherit:从父元素继承属性设置 2.background-repeat:平铺(在图片大小小于元素尺寸时 ...
- Spark-windows安装
Spark 目的:达到能在pycharm中测试 1.安装必要的文件: JDK AnaConda spark hadoop jdk测试:java -version Anaconda测试: 打开Anaco ...
- jmter快速安装
一.简介 Apache JMeter是Apache组织开发的基于Java的压力测试工具,用于接口和压力测试,所以前提是一定更要安装jdk. 二.下载安装 下载:官网下载 下载完成后运行包里的jmete ...
- 实战SpringCloud响应式微服务系列教程(第一章)
前言 在当今互联网飞速发展的时代,业务需求不断的更新和产品的迭代给系统开发过程和编程模式也带来巨大挑战,Spring Cloud微服务也随之应用而生,从springboot1.x到springboot ...
- java 第五章
java 第五章 while 循环语句 语法:while(循环条件){ //循环操作 循环条件自加: } while循环结构的特点:先判断,在执行. while 的执行步骤 (1) 声明 ...