郑州网站建设公司qq,做海报一般都去什么网站看,小众写作网站,在线网站源码提取切片#xff1a; 切片的长度是不固定的#xff0c;可以追加数据#xff0c;可以理解是一个动态数组#xff0c;切片的底层是一个结构体切片类型#xff08;slice#xff09;本身并不是动态数组或数组指针。它内部通过指针引用底层数组#xff0c;设定相关属性将操作限定…切片 切片的长度是不固定的可以追加数据可以理解是一个动态数组切片的底层是一个结构体切片类型slice本身并不是动态数组或数组指针。它内部通过指针引用底层数组设定相关属性将操作限定在指定范围内。当需要时会申请更大的内存将当前数据复制过去, 以实现类似动态数组的功能。 type slice struct { array unsafe.Pointer // 指针指向底层数组len int // 切片的长度cap int // 切片的容量
}怎么区分数组和切片 数组是必须要有长度不管是显式还是推导都要有长度但是切片不是一定要显式长度 切片的创建 可直接创建切片对象无需预先准备数组。因为是引用类型必须使用make函数或显式初始化语句它会自动完成底层数组内存分配 注意切片定义完后还不能使用因为本身是一个空的需要让其引用到一个数组或者make一个空间供切片来使用。 普通格式
var slice [] type自动推导类型创建切片
slice : [] type{}make函数创建切片
// len切片的长度 cap切片的容量 cap不能大于len且可省略默认和len相同
// len和cap长度是已经初始化的空间容量是已经开辟的空间包括已经初始化的空间和空闲的空间
// cap是一个内置函数用于统计切片的容量也就是最大可以存放多少个元素
// 仅定义没有写make就相当于创建了切片里面是空的var slice []type make([]type, lencap)
var slice make([]type, len, cap) // 简写演示
func main() {var slice []int // 普通格式创建的slice空切片slice2 : []int{} // 自动推导类型创建的slice空切片slice3 : make([]int, 2) // make函数创建的slice省略capcaplenslice4 : make([]int, 2, 3) // make函数创建的slice自定义capfmt.Println(slice, slice)fmt.Println(slice2, slice2)fmt.Println(slice3, slice3, len, len(slice3), cap, cap(slice3))fmt.Println(slice4, slice4, len, len(slice4), cap, cap(slice4))
}输出
slice []
slice2 []
slice3 [0 0] len 2 cap 2
slice4 [0 0] len 2 cap 3引用数组创建
func main() {// 1. 创建数组arr : [...]int{1, 2, 3, 4, 5}// 2.创建切片并引用数组// slice切片名// arr[1:3]引用了数组arr的数据从索引1到索引3-1包含索引1但是不包含索引3也就是arr[2,3]// slice : arr// 相当于引用数组全部数据slice : arr[1:3]fmt.Println(arr, arr)// 现在切片中只有 [2 3]也就是索引0和1如果用取slice[2]就会越界fmt.Println(slice, slice)//fmt.Println(slice, slice[2]) // 报错fmt.Println(slice中元素的个数, len(slice))fmt.Println(slice的容量, cap(slice))
}输出
arr [1 2 3 4 5]
slice [2 3]
slice中元素的个数 2
slice的容量 4引用数组或切片会同步数据
func main() {slice : make([]int, 2, 3)slice[0] 1slice[1] 2slice2 : slice[0:]slice2[0] 100fmt.Println(slice)fmt.Println(slice2)
}输出
[100 2]
[100 2]引用数组简写格式
slice : arr[0:indexEnd] 简写为 slice : arr[:indexEnd]
slice : arr[indexStart:len(arr)] 简写为 slice : arr[indexStart:]
slice : arr[0:len(arr)] 简写为 slice : arr[:] 或 slice : arr初始化 三种创建格式都是可以通过append向切片添加数据的 初始化格式
/// 普通格式创建的切片
var slice []type// 自动推导类型创建的切片这种情况会根据添加的数据推断切片的长度容量长度
slice : [] type{数据1,数据2,数据3}// make函数方式创建的切片可以通过append和循环初始化
slice append(slice, 数据1,数据2...)演示
func main() {// var slice []typevar slice []intslice append(slice, 1, 2, 3, 4) // 通过append添加slice[1] 111 // 通过索引添加fmt.Println(切片中的数据, slice)fmt.Println(可以通过索引取部分数据, slice[0])fmt.Println(切片长度, len(slice), 切片的容量, cap(slice))fmt.Println()// slice : [] type{数据1,数据2,数据3}slice2 : []int{1, 2, 3, 4, 5}slice2 append(slice2, 6, 7, 8, 9, 10)slice2[1] 111fmt.Println(切片中的数据, slice2)fmt.Println(可以通过索引取部分数据, slice2[0])fmt.Println(切片长度, len(slice2), 切片的容量, cap(slice2))fmt.Println()// slice append(slice, 数据1,数据2...)slice3 : make([]int, 3, 4)for i : 0; i len(slice3); i {slice3[i] i 1}slice3 append(slice3, 1)fmt.Println(切片中的数据, slice3)fmt.Println(可以通过索引取部分数据, slice3[0])fmt.Println(切片长度, len(slice3), 切片容量, cap(slice3))
}输出
切片中的数据 [1 111 3 4]
可以通过索引取部分数据 1
切片长度 4 切片的容量 4切片中的数据 [1 111 3 4 5 6 7 8 9 10]
可以通过索引取部分数据 1
切片长度 10 切片的容量 10切片中的数据 [1 2 3 1]
可以通过索引取部分数据 1
切片长度 4 切片容量 4注意下面两种定义方式的区别。前者仅定义了一个[ ]int类型变量并未执行初始化操作而后者则用初始化表达式完成了全部创建过程
func main() {var a []intb : []int{}fmt.Println(a nil, b nil) // true false
}可获取元素地址但不能向数组那样直接通过指针(*slice)访问元素内容
func main() {s : []int{0, 1, 2, 3, 4}p : s // 取切片地址p0 : s[0] // 取第一个元素地址p1 : s[1]println(p, p0, p1)// 取p中[1]的数据且加100(*p)[1] 100 // *[]int不支持indexing操作须先用指针操作符获取[]int对象fmt.Println(s)fmt.Println((*p)[1]) //这里加括号是优先级问题
}如果元素类型也是切片那么就能实现类似交错数组的功能
func main() {x : [][]int{{1, 2},{10, 20, 30},{100},}fmt.Println(x[1])x[2] append(x[2], 200, 300)fmt.Println(x[2])
}输出
[1 2] [10 20 30]
[100 200 300]切片遍历
遍历和数组一样可以使用普通的for循环和range遍历得到
func main() {slice : []int{1, 2, 3, 4, 5}for i : 0; i len(slice); i {fmt.Print(slice[i])}for _, v : range slice {fmt.Println(v)}
}append函数 append函数是向切片的末尾添加数据 如果添加的内容超出了切片初始定义的容量切片会自动扩容 扩容机制是上一次的容量 * 2如果超过1024字节每次扩容上一次的1/4 append每次扩容都是一个新的内存和原来的无关联所以如果是通过参数传递的方式使用append添加数据但是不会影响到原切片的数据原因就是append每次拓展都是一个新的空间指向的内存不再是原切片。 切片append底层原理
创建新的数组并扩容将原数组的数据拷贝到新数组将新添加的数据添加到新数组slice引用到新数组原数组被程序销毁
格式
slice append(slice,数据) 演示
func main() {slice : make([]int, 3, 4)// 这里定义了切片的长度是3初始容量是4系统会对长度赋上默认值int类型就是0所以打印3个0fmt.Println(初始切片的数据, slice, 长度, len(slice))slice append(slice, 1)// 添加数据此时容量是4数据已经有4个了如果继续多加点数据会不会报错fmt.Println(第一次添加数据, slice, 长度, len(slice))slice append(slice, 2, 3, 4)fmt.Println(第二次添加数据, slice, 长度, len(slice))// 这里是相当于把自己的数据再添加一遍slice append(slice, slice...)fmt.Println(第三次添加数据, slice, 长度, len(slice))// 再创建一个切片初始化后把slice的数据添加过来注意这个不是复制是在结尾继续添加slice2 : make([]int, 3, 4)slice2 append(slice2, slice...)fmt.Println(slice2, slice2, 长度, len(slice2))
}输出
初始切片的数据 [0 0 0] 长度 3
第一次添加数据 [0 0 0 1] 长度 4
第二次添加数据 [0 0 0 1 2 3 4] 长度 7
第三次添加数据 [0 0 0 1 2 3 4 0 0 0 1 2 3 4] 长度 14
slice2 [0 0 0 0 0 0 1 2 3 4 0 0 0 1 2 3 4] 长度 17copy函数 切片是引用类型新切片复制后修改数据是不会影响原切片的 注意如果切片1的容量不够则不赋值剩余的数据。如果切片1的数据比切片2的多从切片2复制的数据是有多少复制多少。 总结copy只是复制索引相对应的数据如果长度不够不会覆盖原来的数据 格式
copy(切片1,切片2) // 把切片2的数据复制到切片1中从切片2复制到切片1但是切片2的数据比切片1的多所以最终只是复制了一部分也就是索引相对应的数据
func main() {slice : []int{1, 2, 3}slice2 : []int{4, 5, 6, 7, 8, 9}copy(slice, slice2) // 把切片2复制到切片1fmt.Println(slice) // [4 5 6]// 修改数据slice append(slice, 97, 98)slice2 append(slice2, 100)fmt.Println(slice) // [4 5 6 97 98]fmt.Println(slice2) // [4 5 6 7 8 9 100]
}string底层是一个byte数组因此string也可以进行切片处理
func main() {b : make([]byte, 3)s : copy(b, abcde) // 字符串复制数据到[]bytefmt.Println(s) // 3fmt.Println(b) // [97 98 99]
}切片截取 切片截取就是从切片中获取指定的数据返回给新切片 如果初始化切片时没有指定切片的容量切片容量是跟随原切片的 切片截取的操作
操作含义s[n]从切片s的n索引到len(s)-1s[:]从切片s的索引位置0到len(s)-1处所获得的切片s[low:]从切片s的索引位置low到len(s)-1处所获得的切片s[:high]从切片s的索引位置0到high处所获得的切片lenhighs[low:high]从切片s的索引位置low到high处所获得的切片lenhigh-lows[low:high:max]从切片s的索引位置low到high处所获得的切片lenhigh-lowcapmax-lowlen(s)切片s的长度总是cap(s)cap(s)切片s的容量总是len(s)func main() {slice : []int{1, 2, 3, 4, 5}/**第一个值截取的起始索引第二个值截取的终止索引不包括该值第三个值用来计算切片的容量可以省略默认和长度一样容量 第三个值 - 第一个值长度 第二个值 - 第一个值*/newSlice : slice[0:3:3]fmt.Println(newSlice, newSlice, 长度, len(newSlice), 容量, cap(newSlice))// 和复制一样了newSlice2 : slice[:]fmt.Println(newSlice2, newSlice2, 长度, len(newSlice2), 容量, cap(newSlice2))
}输出
newSlice [1 2 3] 长度 3 容量 3
newSlice2 [1 2 3 4 5] 长度 5 容量 5切片值的修改 切片截取后返回新切片对新切片的值进行修改会影响原来的切片 原因 切片截取后新的切片是指向了原来的切片没有给新的切片开辟新的空间所以对于新的切片操作会影响到原来的切片 演示
func main() {slice : []int{1, 2, 3, 4, 5}newSlice2 : slice[0:3]fmt.Println(切片修改前slice的数据, slice)newSlice2[0] 1111fmt.Println(切片修改后slice的数据, slice)
}输出
切片修改前slice的数据 [1 2 3 4 5]
切片修改后slice的数据 [1111 2 3 4 5]切片作为函数参数 切片可以做为函数的参数但是在函数中修改切片的值会影响到原切片 因为切片的底层是结构体结构体里有个参数PointerPointer会指向切片的内存地址使用的是浅拷贝方式所以会影响到原切片值 演示
func main() {slice : make([]int, 10)SliceDemo(slice)fmt.Println(slice) // [0 1 2 3 4 5 6 7 8 9]}func SliceDemo(slice []int) {for i : 0; i len(slice); i {slice[i] i}
}使用append就不会影响而且内存地址都不一样怎么会影响呢因为append会变成一个新的切片
func main() {slice : []int{1, 2, 3, 4, 5}SliceDemo(slice)fmt.Println(main:, slice)fmt.Printf(main%p, slice)
}func SliceDemo(slice []int) {slice append(slice, 6, 7)fmt.Println(SliceDemo:, slice)fmt.Printf(SliceDemo%p\n, slice)
}输出
SliceDemo: [1 2 3 4 5 6 7]
SliceDemo0x1400001c0a0
main: [1 2 3 4 5]
main0x14000014180去掉append内存地址就一样了
func main() {slice : []int{1, 2, 3, 4, 5}SliceDemo(slice)fmt.Println(main:, slice)fmt.Printf(main%p, slice)
}func SliceDemo(slice []int) {fmt.Println(SliceDemo:, slice)fmt.Printf(SliceDemo%p\n, slice)
}输出
SliceDemo: [1 2 3 4 5]
SliceDemo0x14000014180
main: [1 2 3 4 5]
main0x14000014180切片求和
func main() {// 定义变量并收集用户输入的个数var count intfmt.Println(请输入要求和的个数)fmt.Scan(count)// 定义切片将输入的个数保存到切片slice : make([]int, count)statisticalData(slice)// 求和summation(slice)
}func statisticalData(slice []int) {for i : 0; i len(slice); i {fmt.Printf(请输入第%d个数\n, i1)fmt.Scan(slice[i])}
}
func summation(slice []int) {var sum intfor i : 0; i len(slice); i {sum slice[i]}fmt.Println(和为, sum)
}切片求最大值
func main() {// 定义变量并收集用户输入的个数var count intfmt.Println(请输入要比较的数)fmt.Scan(count)// 定义切片将输入的个数保存到切片slice : make([]int, count)statisticalData(slice)// 比较最大值maximum(slice)
}func statisticalData(slice []int) {for i : 0; i len(slice); i {fmt.Printf(请输入第%d个数\n, i1)fmt.Scan(slice[i])}
}func maximum(slice []int) {max : slice[0]for i : 0; i len(slice); i {if max slice[i] {max slice[i]}}fmt.Println(最大值是, max)
}
