周口市住房和城乡建设局门户网站网站文案框架

2. slice 切片

2.1 初始化

var初始化一个nil切片，不分配内存，（并不是空切片）;make 可以指定长度和容量;字面量可以根据长度自动设定长度

若未指定容量，则容量默认等于长度

func main() { // len cap 值已标注在后面var v1 []int				    // 0 0v2 := make([]int, 0)		    // 0 0v3 := make([]int, 5)		    // 5 5v4 := make([]int, 5, 10)	    // 5 10v5 := []int{}				// 0 0v6 := []int{1, 2, 3, 4, 5}	// 5 5v7 := *new([]int)            // 0 0 nil切片，不是空切片
}

还可以从数组，切片截取来进行初始化。

• 切片长度根据截取长度定。
• 若从切片截取，容量保持跟原切片一致；从数组截取，容量为数组长度 - 起始截取位置；
• 切片截取时，只考虑容量，不考虑长度；即不超过原数组/切片容量就可以截取

func main() {a := [10]int{1, 2, 3, 4, 5}s1 := a[1:6]s2 := s1[0:9]s3 := s1[0:10] //panic: runtime error: slice bounds out of range [:10] with capacity 9fmt.Println(len(a), cap(a))fmt.Println(len(s1), cap(s1))fmt.Println(len(s2), cap(s2))/*10 105 99 9*/
}

2.2 源代码

切片依托于底层数组实现

type slice struct {array unsafe.Pointer // 指向底层数组len   int            // 切片长度cap   int            // 容量
}

由于指向的是底层数组，所以在使用数组/切片创建切片的时候，切片会与原数组/切片共用一部分内存，在对切片进行修改的时候，有可能会将原数据一起修改

但扩容之后，数据会被复制到新切片中，此时底层数组就不一样了，不会发生上述情况

//未发生扩容
func main() {a := [10]int{1, 2, 3, 4, 5, 6, 7}s1 := a[1:5]s2 := s1[0:6]s1 = append(s1, 10)s2[2] = 100fmt.Println(a) fmt.Println(s1)fmt.Println(s2)/*[1 2 3 100 5 10 7 0 0 0][2 3 100 5 10][2 3 100 5 10 7]*/
}

//发生扩容
func main() {a := [10]int{1, 2, 3, 4, 5, 6, 7}s1 := a[1:5]s2 := s1[0:9]s1 = append(s1, 10)s2 = append(s2, 10)s2[2] = 100fmt.Println(a)fmt.Println(s1)fmt.Println(s2)
}
/*  可以看到修改 100 没有改变原数据
[1 2 3 4 5 10 7 0 0 0]
[2 3 4 5 10]
[2 3 100 5 10 7 0 0 0 10]*/

2.3 拷贝

• 使用copy(new,old)可以拷贝切片，并且此时两个切片底层数组地址不同。
• 拷贝时，去两个切片长度的最小值进行拷贝，拷贝过程中不会发生扩容操作。

func main() {a := []int{1, 2, 3, 4, 5}b := make([]int, 3)c := make([]int, 10)copy(b, a)copy(c, a)b[0] = 100fmt.Println(a)fmt.Println(b)fmt.Println(c)/*[1 2 3 4 5][100 2 3]           //修改不会影响原切片，并且复制不会发生扩容操作[1 2 3 4 5 0 0 0 0 0]*/
}

2.4 扩容

• slice扩容时，会先创建一个大数组，再将原数组数据复制进去，最后再执行append操作。
• 1.18前，大于等于1024,每次扩容25%; 小于1024，每次扩容一倍
• 1.18后，大于256，扩容后的容量计算公式如下：newcap = oldcap+(oldcap+threshold*3)/4; 小于256，每次扩容一倍
• 过渡更加平滑，避免了2-1.25的突变
• 实际扩容后的容量不严格等于计算结果，还要考虑到内存对齐等问题

//扩容后地址改变
func main() {a := make([]int, 1, 2)fmt.Println(&a[0])a = append(a, 1)        //未发生扩容fmt.Println(&a[0])a = append(a, 2)        //发生扩容fmt.Println(&a[0])/*0xc00000a0d00xc00000a0d00xc0000101c0        //扩容后的地址发生了改变*/
}

// 扩容示例
func main() {a := make([]int, 256) //第一档b := make([]int, 257) //第二档 c := make([]int, 512)d := make([]int, 1024)a = append(a, 1)b = append(b, 2)c = append(c, 3)d = append(d, 4)fmt.Println(len(a), cap(a))fmt.Println(len(b), cap(b))fmt.Println(len(c), cap(c))fmt.Println(len(d), cap(d))
}
/*          b扩容后计算结果应为 513.25，向上取整 514 ， 但实际结果为 608 这其中就经历了内存对齐
257 512
258 608
513 848
1025 1536*/

2.5 切片表达式

• 简单表达式[low:high] 表示截取[low,high);low,high均可省略
• 扩展表达式[low:high:capmax] 只可省略low;capmax用来限制新切片容量，避免对high后底层数组的元素进行修改
• 作用于字符串时，生成的结果仍为字符串;扩展表达式不能用于字符串

//扩展表达式
func main() {a := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}b := a[:5]b = append(b, 5555)c := a[:5:5]        //限制切片容量为5 添加元素就会触发扩容操作，改变底层数组指向c = append(c, 6666)fmt.Println(a) // [1 2 3 4 5 5555 7 8 9 10]
}

//用于字符串
func main() {a := "lonelysnow"b := a[6:]//c := a[0:6:6] // invalid operation: 3-index slice of stringfmt.Println(b)fmt.Println(reflect.TypeOf(b)) // 查看截取的类型
}
/*snowstring*/