如何做好品牌网站建设策划,wordpress 菜单 数据库,南宁网站建设建站系统,无锡百度正规推广概述
数组的长度是固定的并且数组长度属于类型的一部分#xff0c;所以数组有很多的局限性
func arraySum(x [3]int) int{sum : 0for _, v : range x{sum sum v}return sum
}
这个求和函数只能接受
[3]int
类型#xff0c;其他的都不支持。 切片 切片#xff08;Slic…概述
数组的长度是固定的并且数组长度属于类型的一部分所以数组有很多的局限性
func arraySum(x [3]int) int{sum : 0for _, v : range x{sum sum v}return sum
}
这个求和函数只能接受
[3]int
类型其他的都不支持。 切片 切片Slice是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。它非常灵活支持自动扩容。
切片是一个引用类型它的内部结构包含地址、长度和容量。切片一般用于快速地操作一块数据集合。
切片的定义
声明切片类型的基本语法如下
var name []T 其中
name:表示变量名T:表示切片中的元素类型
举个例子
func main() {// 声明切片类型var a []string //声明一个字符串切片var b []int{} //声明一个整型切片并初始化var c []bool{false, true} //声明一个布尔切片并初始化var d []bool{false, true} //声明一个布尔切片并初始化fmt.Println(a) //[]fmt.Println(b) //[]fmt.Println(c) //[false true]fmt.Println(a nil) //truefmt.Println(b nil) //falsefmt.Println(c nil) //false// fmt.Println(c d) //切片是引用类型不支持直接比较只能和nil比较
}
切片的长度和容量
切片拥有自己的长度和容量我们可以通过使用内置的len()函数求长度使用内置的cap()函数求切片的容量。
基于数组定义切片
由于切片的底层就是一个数组所以我们可以基于数组定义切片。
func main() {// 基于数组定义切片a : [5]int{55, 56, 57, 58, 59}b : a[1:4] //基于数组a创建切片包括元素a[1],a[2],a[3]fmt.Println(b) //[56 57 58]fmt.Printf(type of b:%T\n, b) //type of b:[]int
}
还支持如下方式 c : a[1:] //[56 57 58 59]
d : a[:4] //[55 56 57]
e : a[:] //[55 56 57 58 59]
切片再切片
除了基于数组得到切片我们还可以通过切片来得到切片。
func processSlice2() {a : [...]string{北京, 上海, 广州, 深圳, 成都, 重启}fmt.Printf(a:%v type:%T len:%d cap:%d\n, a, a, len(a), cap(a))b : a[1:3]fmt.Printf(b:%v type:%T len:%d cap:%d\n, b, b, len(b), cap(b))c : b[2:5]fmt.Printf(c:%v type:%T len:%d cap:%d\n, c, c, len(c), cap(c))
}
输出 a:[北京 上海 广州 深圳 成都 重启] type:[6]string len:6 cap:6
b:[上海 广州] type:[]string len:2 cap:5
c:[深圳 成都 重启] type:[]string len:3 cap:3
理解:从b再进行切片 实际也是从a切片 只不过b切片后b : a[1:3]
中的1不存在了 而在c : b[2:5]
中的5是存在的
注意 对切片进行再切片时索引不能超过原数组的长度否则会出现索引越界的错误。
使用make()函数构造切片
我们上面都是基于数组来创建的切片如果需要动态的创建一个切片我们就需要使用内置的
make()
函数格式如下
make([]T, size, cap) 其中
T:切片的元素类型size:切片中元素的数量cap:切片的容量 举个例子
func main() {a : make([]int, 2, 10)fmt.Println(a) //[0 0]fmt.Println(len(a)) //2fmt.Println(cap(a)) //10
}
上面代码中
a
的内部存储空间已经分配了10个但实际上只用了2个。
容量并不会影响当前元素的个数所以
len(a)
返回2
cap(a)
则返回该切片的容量。 切片的本质 切片的本质就是对底层数组的封装它包含了三个信息底层数组的指针、切片的长度len和切片的容量cap。
举个例子现在有一个数组a : [8]int{0, 1, 2, 3, 4, 5, 6, 7}切片s1 : a[:5]相应示意图如下。 切片s2 : a[3:6]相应示意图如下 切片不能直接比较
切片之间是不能比较的我们不能使用 操作符来判断两个切片是否含有全部相等元素。
切片唯一合法的比较操作是和
nil
比较。
一个
nil
值的切片并没有底层数组一个
nil
值的切片的长度和容量都是0。但是我们不能说一个长度和容量都是0的切片一定是
nil
例如下面的示例
var s1 []int //len(s1)0;cap(s1)0;s1nil
s2 : []int{} //len(s2)0;cap(s2)0;s2!nil
s3 : make([]int, 0) //len(s3)0;cap(s3)0;s3!nil
所以要判断一个切片是否是空的要是用
len(s) 0
来判断不应该使用
s nil
来判断。 切片的赋值拷贝
下面的代码中演示了拷贝前后两个变量共享底层数组对一个切片的修改会影响另一个切片的内容这点需要特别注意。
func main() {s1 : make([]int, 3) //[0 0 0]s2 : s1 //将s1直接赋值给s2s1和s2共用一个底层数组s2[0] 100fmt.Println(s1) //[100 0 0]fmt.Println(s2) //[100 0 0]
}
切片遍历
切片的遍历方式和数组是一致的支持索引遍历和
for range
遍历。
func processSliceRange() {s : []int{1, 2, 3, 4, 5}for i : 0; i len(s); i {fmt.Println(s[i])}for index, value : range s {fmt.Printf(key:%d\tvalue:%d\n, index, value)}
}
append()方法为切片添加元素
Go语言的内建函数
append()
可以为切片动态添加元素。
每个切片会指向一个底层数组这个数组能容纳一定数量的元素。当底层数组不能容纳新增的元素时切片就会自动按照一定的策略进行“扩容”此时该切片指向的底层数组就会更换。“扩容”操作往往发生在
append()
函数调用时。
举个例子
func processSliceAppend() {//append()添加元素和切片扩容var numSlice []intfor i : 0; i 10; i {numSlice append(numSlice, i)fmt.Printf(%v len:%d cap:%d ptr:%p\n, numSlice, len(numSlice), cap(numSlice), numSlice)}
} 输出:
[0] len:1 cap:1 ptr:0xc00001c0a8
[0 1] len:2 cap:2 ptr:0xc00001c0f0
[0 1 2] len:3 cap:4 ptr:0xc0000121c0
[0 1 2 3] len:4 cap:4 ptr:0xc0000121c0
[0 1 2 3 4] len:5 cap:8 ptr:0xc00001a2c0
[0 1 2 3 4 5] len:6 cap:8 ptr:0xc00001a2c0
[0 1 2 3 4 5 6] len:7 cap:8 ptr:0xc00001a2c0
[0 1 2 3 4 5 6 7] len:8 cap:8 ptr:0xc00001a2c0
[0 1 2 3 4 5 6 7 8] len:9 cap:16 ptr:0xc000014280
[0 1 2 3 4 5 6 7 8 9] len:10 cap:16 ptr:0xc000014280从上面的结果可以看出
append()函数将元素追加到切片的最后并返回该切片。切片numSlice的容量按照124816这样的规则自动进行扩容每次扩容后都是扩容前的2倍。 append()函数还支持一次性追加多个元素。
例如
func processSliceAppendAll() {var citySlice []string//追加一个元素citySlice append(citySlice, 北京)//追加多个元素citySlice append(citySlice, 广州, 深圳)//追加切片a : []string{切片元素1,切片元素2}citySlice append(citySlice, a...)fmt.Println(citySlice)
}
删除切片里的元素
Go中没有现成可用的函数来删除切片里的元素我们必须自己“发明”函数来删除切片元素。这里介绍一种方法
func main() {slice : []int{0, 1, 2, 3, 4, 5}fmt.Println(slice)//索引从0开始slice RemoveIndex(slice, 3)fmt.Println(slice)
}// RemoveIndex 删除索引 func RemoveIndex(s []int, index int) []int { //s[:index] 包含我们想要删除的元素前面的所有元素但不包含想要删除的元素其本身 //s[index1:] 包含我们想要删除的元素后面的所有元素但不包含想要删除的元素其本身 //… 将两个切片通过append()函数合并 return append(s[:index], s[index1:]…) } 输出 切片元素排序 示例
func main() {ints : []int{2, 3, -1, 4, 7, 5}fmt.Println(排序前:, ints)//正序排sort.Ints(ints)fmt.Println(排序后(正序):, ints)sort.Sort(sort.Reverse(sort.IntSlice(ints)))fmt.Println(排序后(倒序):, ints)
floats : []float64{1.1, 2.3, 0.4, -9.5, 10}
fmt.Println(排序前:, floats)
sort.Float64s(floats)
fmt.Println(排序后(正序):, floats)
sort.Sort(sort.Reverse(sort.Float64Slice(floats)))
fmt.Println(排序后(倒序):, floats)strings : []string{aa, a, A, Aa, aab}
fmt.Println(\n排序前:, strings)
sort.Strings(strings)
fmt.Println(排序后(正序):, strings)
sort.Sort(sort.Reverse(sort.StringSlice(strings)))
fmt.Println(倒序后(倒序):, strings)} 使用了Go语言的排序包sort来对一个整数切片进行排序。 sort.Ints(ints) 这一行使用
sort.Ints函数对整数切片
ints进行升序排序。该函数修改原始切片而不返回新的切片。所以
ints切片现在是按照升序排列的。 fmt.Println(排序后(正序):, ints) 这一行输出了排序后的整数切片
ints此时它是升序排列的。 sort.Sort(sort.Reverse(sort.IntSlice(ints))) 这一行对整数切片
ints进行了降序排序。首先
sort.IntSlice(ints)将整数切片转换为
sort.Interface类型以便在通用的
sort.Sort函数中使用。然后
sort.Reverse对
sort.Interface类型进行逆序操作最后
sort.Sort函数对整个切片进行排序。 fmt.Println(排序后(倒序):, ints) 最后一行输出了排序后的整数切片
ints此时它是降序排列的。
思考题 package mainimport ( “fmt” )
func main() { var numbers4 […]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} myslice : numbers4[4:6:8] fmt.Printf(“myslice为 %d, 其长度为: %d\n”, myslice, len(myslice))
span classnxmyslice/span span classp/span span classnxmyslice/spanspan classp[:/spanspan classnbcap/spanspan classp(/spanspan classnxmyslice/spanspan classp)]/span
span classnxfmt/spanspan classp./spanspan classnxPrintf/spanspan classp(/spanspan classsmyslice的第四个元素为: %d/spanspan classp,/span span classnxmyslice/spanspan classp[/spanspan classmi3/spanspan classp])/span} 为什么 myslice 的长度为2却能访问到第四个元素
输出
myslice为 [5 6], 其长度为: 2
myslice的第四个元素为: 8解释
func main() {var number4 [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}//4 是切片的起始索引包含//6 是切片的结束索引不包含//8 是切片的容量myslice : number4[4:6:8]fmt.Printf(type:%T,value:%v,len:%d,cap:%d\n, myslice, myslice, len(myslice), cap(myslice))//cap 的容量是4 所以对应的索引和值分别是//05 16 27 38myslice myslice[:cap(myslice)]fmt.Println(myslice[1])
}
由于切片里面是指针、长度、容量
slice类型是数组的一个引用数组arr的地址0x83029,那么slice的数据结构是[ ptr | len| cap],ptr就是指向数组arr的就是一个指针即存放了地址0x83029,len存放了slice的长度cap存放了slice的容量但是这个容量是不可能超过arr的len的所以这样看来slice是一个引用存放的数据是在arr中修改slice的数据对应修改了数组的内容所以 len是2cap是4那么它就可以通过ptr指针访问到arr后面的第四个元素。
