Go数据类型
Go语言 复杂数据类型之切片slice
1. 切片:切片是数组的一个引用,因此切片是引用类型。但自身是结构体,值拷贝传递。 2. 切片的长度可以改变,因此,切片是一个可变的数组。 3. 切片遍历方式和数组一样,可以用len()求长度。表示可用元素数量,读写操作不能超过该限制。 4. cap可以求出slice最大扩张容量,不能超出数组限制。0 <= len(slice) <= len(array),其中array是slice引用的数组。 5. 切片的定义:var 变量名 []类型,比如 var str []string var arr []int。 6. 如果 slice == nil,那么 len、cap 结果都等于 0。 7. slice 并不是数组或数组指针。它通过内部指针和相关属性引用数组片段,以实现变长方案。 ## 创建切片的各种方式 ```go func main() { //1.声明切片 var s1 []int if s1 == nil { fmt.Println("是空") } else { fmt.Println("不是空") } // 2.:= s2 := []int{} // 3.make() var s3 []int = make([]int, 0) fmt.Println(s1, s2, s3) // 4.初始化赋值 var s4 []int = make([]int, 0, 0) fmt.Println(s4) s5 := []int{1, 2, 3} fmt.Println(s5) // 5.从数组切片 arr := [5]int{1, 2, 3, 4, 5} var s6 []int // 前包后不包 s6 = arr[1:4] fmt.Println(s6) } ``` ## 切片初始化  ```go var arr = [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} var slice0 []int = arr[2:8] var slice1 []int = arr[0:6] //可以简写为 var slice []int = arr[:end] var slice2 []int = arr[5:10] //可以简写为 var slice[]int = arr[start:] var slice3 []int = arr[0:len(arr)] //var slice []int = arr[:] var slice4 = arr[:len(arr)-1] //去掉切片的最后一个元素 func main() { fmt.Printf("全局变量:arr %v\n", arr) fmt.Printf("全局变量:slice0 %v\n", slice0) fmt.Printf("全局变量:slice1 %v\n", slice1) fmt.Printf("全局变量:slice2 %v\n", slice2) fmt.Printf("全局变量:slice3 %v\n", slice3) fmt.Printf("全局变量:slice4 %v\n", slice4) fmt.Printf("-----------------------------------\n") arr2 := [...]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0} slice5 := arr[2:8] slice6 := arr[0:6] //可以简写为 slice := arr[:end] slice7 := arr[5:10] //可以简写为 slice := arr[start:] slice8 := arr[0:len(arr)] //slice := arr[:] slice9 := arr[:len(arr)-1] //去掉切片的最后一个元素 fmt.Printf("局部变量: arr2 %v\n", arr2) fmt.Printf("局部变量: slice5 %v\n", slice5) fmt.Printf("局部变量: slice6 %v\n", slice6) fmt.Printf("局部变量: slice7 %v\n", slice7) fmt.Printf("局部变量: slice8 %v\n", slice8) fmt.Printf("局部变量: slice9 %v\n", slice9) } ``` ## 通过make来创建切片 ```go var slice0 []int = make([]int, 10) var slice1 = make([]int, 10) // 省略 cap,相当于 cap = len var slice2 = make([]int, 10, 10) // 使用 make 创建,指定 len 和 cap 值 func main() { fmt.Printf("make全局slice0 :%v\n", slice0) fmt.Printf("make全局slice1 :%v\n", slice1) fmt.Printf("make全局slice2 :%v\n", slice2) fmt.Println("--------------------------------------") slice3 := make([]int, 10) slice4 := make([]int, 10) slice5 := make([]int, 10, 10) fmt.Printf("make局部slice3 :%v\n", slice3) fmt.Printf("make局部slice4 :%v\n", slice4) fmt.Printf("make局部slice5 :%v\n", slice5) } ``` - 使用 make 动态创建slice,避免了数组必须用常量做长度的麻烦。还可用指针直接访问底层数组,退化成普通数组操作。 ```go func main() { s := []int{0, 1, 2, 3} p := &s[2] // *int, 获取底层数组元素指针。 *p += 100 fmt.Println(s) //[0 1 102 3] } ``` ## 用append内置函数操作切片(切片追加) ```go func main() { var a = []int{1, 2, 3} fmt.Printf("slice a : %v\n", a) // [1 2 3] var b = []int{4, 5, 6} fmt.Printf("slice b : %v\n", b) //[4 5 6] c := append(a, b...) fmt.Printf("slice c : %v\n", c) //[1 2 3 4 5 6] d := append(c, 7) fmt.Printf("slice d : %v\n", d) //[1 2 3 4 5 6 7] e := append(d, 8, 9, 10) fmt.Printf("slice e : %v\n", e) //[1 2 3 4 5 6 7 8 9 10] } ``` ## 超出原 slice.cap 限制,就会重新分配底层数组,即便原数组并未填满。 ```go func main() { data := [...]int{0, 1, 2, 3, 4, 10: 0} s := data[:2:3] s = append(s, 100, 200) // 一次 append 两个值,超出 s.cap 限制。 fmt.Println(s, data) // 重新分配底层数组,与原数组无关。 fmt.Println(&s[0], &data[0]) // 比对底层数组起始指针。 } ///// [0 1 100 200] [0 1 2 3 4 0 0 0 0 0 0] 0xc4200160f0 0xc420070060 ``` 从输出结果可以看出,append 后的 s 重新分配了底层数组,并复制数据。如果只追加一个值,则不会超过 s.cap 限制,也就不会重新分配。 通常以 2 倍容量重新分配底层数组。在大批量添加数据时,建议一次性分配足够大的空间,以减少内存分配和数据复制开销。或初始化足够长的 len 属性,改用索引号进行操作。及时释放不再使用的 slice 对象,避免持有过期数组,造成 GC 无法回收。 ## slice中cap重新分配规律: ```go func main() { s := make([]int, 0, 1) c := cap(s) for i := 0; i < 50; i++ { s = append(s, i) if n := cap(s); n > c { fmt.Printf("cap: %d -> %d\n", c, n) c = n } } } cap: 1 -> 2 cap: 2 -> 4 cap: 4 -> 8 cap: 8 -> 16 cap: 16 -> 32 cap: 32 -> 64 ``` ## 切片拷贝 - copy :函数 copy 在两个 slice 间复制数据,复制长度以 len 小的为准。两个 slice 可指向同一底层数组,允许元素区间重叠。 - 应及时将所需数据 copy 到较小的 slice,以便释放超大号底层数组内存。 ```go func main() { data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} s1 := data[8:] s2 := data[:5] fmt.Printf("slice s1 : %v\n", s1) //[8 9] fmt.Printf("slice s2 : %v\n", s2) //[0 1 2 3 4] copy(s2, s1) fmt.Printf("copied slice s1 : %v\n", s1) //[8 9] fmt.Printf("copied slice s2 : %v\n", s2) //[8 9 2 3 4] fmt.Println("last array data : ", data) // [8 9 2 3 4 5 6 7 8 9] } ``` ## slice遍历 ```go func main() { data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} slice := data[:] for index, value := range slice { fmt.Printf("inde : %v , value : %v\n", index, value) } } ``` ## 字符串和切片(string and slice) - string底层就是一个byte的数组,因此,也可以进行切片操作。 ```go func main() { str := "hello world" s1 := str[0:5] fmt.Println(s1) //hello s2 := str[6:] fmt.Println(s2) //world } ``` - string本身是不可变的,因此要改变string中字符。需要如下操作: 英文字符串: ```go func main() { str := "Hello world" s := []byte(str) //中文字符需要用[]rune(str) s[6] = 'G' s = s[:8] s = append(s, '!') str = string(s) fmt.Println(str) // Hello Go! } ``` - 含有中文字符串: ```go func main() { str := "你好,世界!hello world!" s := []rune(str) s[3] = '够' s[4] = '浪' s[12] = 'g' s = s[:14] str = string(s) fmt.Println(str) //你好,够浪!hello go } ``` ## slice 两个冒号的理解 ```go func main() { slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} //从第6位到第8位(返回6, 7),长度len为2, 最大可扩充长度cap为4(6-9) d1 := slice[6:8] //每个数字前都有个冒号, slice内容为data从0到第6位,长度len为6,最大扩充项cap设置为8 d2 := slice[:6:8] } ``` ## 数组or切片转字符串 ```go strings.Replace(strings.Trim(fmt.Sprint(array_or_slice), "[]"), " ", ",", -1) ``` ##切片比较 和数组不同的是,slice之间不能比较,因此我们不能使用==操作符来判断两个slice是否含有全部相等元素。这方面有两个原因。第一个原因,一个slice的元素是间接引用的,一个slice甚至可以包含自身(译注:当slice声明为[]interface{}时,slice的元素可以是自身)。虽然有很多办法处理这种情形,但是没有一个是简单有效的。 第二个原因,因为slice的元素是间接引用的,一个固定的slice值(译注:指slice本身的值,不是元素的值)在不同的时刻可能包含不同的元素,因为底层数组的元素可能会被修改。而例如Go语言中map的key只做简单的浅拷贝,它要求key在整个生命周期内保持不变性(译注:例如slice扩容,就会导致其本身的值/地址变化)。而用深度相等判断的话,显然在map的key这种场合不合适。对于像指针或chan之类的引用类型,==相等测试可以判断两个是否是引用相同的对象。一个针对slice的浅相等测试的==操作符可能是有一定用处的,也能临时解决map类型的key问题,但是slice和数组不同的相等测试行为会让人困惑。因此,安全的做法是直接禁止slice之间的比较操作。 slice唯一合法的比较操作是和nil比较,例如: ```go if summer == nil { /* ... */ } ``` 一个零值的slice等于nil。一个nil值的slice并没有底层数组。一个nil值的slice的长度和容量都是0,但是也有非nil值的slice的长度和容量也是0的,例如[]int{}或make([]int, 3)[3:]。与任意类型的nil值一样,我们可以用[]int(nil)类型转换表达式来生成一个对应类型slice的nil值。 ```go var s []int // len(s) == 0, s == nil s = nil // len(s) == 0, s == nil s = []int(nil) // len(s) == 0, s == nil s = []int{} // len(s) == 0, s != nil ``` 如果你需要测试一个slice是否是空的,使用len(s) == 0来判断,而不应该用s == nil来判断。除了和nil相等比较外,一个nil值的slice的行为和其它任意0长度的slice一样;例如reverse(nil)也是安全的。除了文档已经明确说明的地方,所有的Go语言函数应该以相同的方式对待nil值的slice和0长度的slice。
顶部
收展
底部
[TOC]
目录
Go语言 数据类型
Go语言 基本数据类型
Go语言 复杂数据类型之数组
Go语言 复杂数据类型之切片slice
Go语言 复杂数据类型之指针
Go语言 复杂数据类型之map
Go语言 复杂数据类型之结构体
相关推荐
Go基础
Go函数
Go面向对象
Go并发编程
Go数据操作