Golang 切片【防备忘】

• 切片是引用（也就是个指针），所以它们不需要使用额外的内存并且比使用数组更有效率，所以在 Go 代码中 切片比数组更常用。

1. 最简单、基本定义形式

obj := [...]int{1,2,3,4,5,6,7,8,9,0}
var slice []int    //切片的[]中不需要写长度
slice = obj[2:7]  //包括2，不包括7，自行体会
//这样silce就是包含{3，4，5，6，7}的切片

2. 简化形式（这垃圾名字）

obj := [...]int{1,2,3,4,5,6,7,8,9,0}
var slice []int
silce = obj[:]  //silce是含有全部obj数据的切片
slice = obj[:5] //相当于slice = obj[0:5]
slice = obj[5:] //slice = obj[5:len(obj)]

3. 不用数组名，直接创建切片

slice = [3]int{1,2,3}[:]
//or
slice = []int{1,2,3}
//即slice是含有元素1，2，3的切片
//这tm给我的感觉，好像数组和切片合体了，无非就是另起了一个别名，淦！

4. 切片长度的扩充与缩减

slice=slice[:len(slice)+1]  //扩充长度，当然不能超出最大容量
slice=slice[:len(slice)-1]  //缩减长度，当然不能低于切片下限，但是可以等于，虽然这样就是什么都不包括
可通过这种方式直接扩充到切片上限：s = s[:cap(s)]    省的去找原数组了
需要注意的是，切片的下限是不能更改的，这你也就能理解下面的cap的意思了

6. 切片长度：cap（）与len（）

cap(slice)啥意思？
cap() 可以测量切片最长可以达到多少：它等于切片从第一个元素开始，到相关数组末尾的元素个数
cap(slice) 就是从 s[0] 到数组末尾的数组长度
例如：
var obj [10]int
slice := obj[2:7]
cap(slice)就等于8
为什么呢？s[0]就是obj[2],从这里开始算，直到obj[len(obj)]结束，为silce切片的最大容量

len(slice)就好说了，它就是sicle切片的现有长度

7. 将切片传递给数组（以后数组传入参数也就用这种方法）

func sum(a []int) int {
    s := 0
    for i := 0; i < len(a); i++ {
        s += a[i]
    }
    return s
}

func main() {
    var arr = [5]int{0, 1, 2, 3, 4}
    sum(arr[:])
}

8. 使用make或者new创建切片

//使用make
make([]type, len, cap) //第三个参数可省，这样的话，cap=len
var slice []int = make([]int, 10)
var slice = make([]int, 10)  //cap是等于len的
var slice = make([]int, 10, 100)  //cap为100，len为10，切片还是可扩充的
//使用new
var slice = new([100]int)[0:10]  //cap为100，len为10.

9. for-range结构

//没什么好说的(多维切片，之后用到了在学)
for i,val := range slice
i为索引(下标)，val为索引值
//只应用索引
for i := range slice
//只应用索引值
for _,val := range slice

10. 切片的复制与追加

//切片的复制
slice := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
upSlice := make([]int, 10, 50)
n := copy(upSlice, slice)  //后者复制到前者
slice=upSlice  //**这一步注意下，是可以这样操作的，仍用原来的切片名称

• 关于go的append扩充机制，有些复杂，不同类型、不同的扩充数目都是不相同的扩充机制
• 特别需要注意的是，假如将切片B追加到切片A中，若A的cap（A），足以装下B，则A仍旧指向的是原来的相关函数；若A的cap（A），已经不足以装下B了，那么此时append返回的那个新的切片已经不再指向原来的相关数组了

//切片的扩展
slice := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
upSlice := make([]int, 10, 50)
n := copy(upSlice, slice)
upSlice = append(upSlice, 44, 55, 66, 77) //这个直接在upSlice切片后边扩充或扩容
upSlice = append(upSlice, slice...)  //这个是将slice扩充到upSlice后面，但是后边的切片的用列表的形式

11. 字符串生成切片

var str string = "Queue Hello world"
str := "Queue Hello world"
str :=[]string{"Queue Hello world"} //这个不叫字符串，这个他妈是字符串数组，垃圾，淦
cbyte := []byte(str) //实现切片
/*成了切片，也就能  
截取字符串
使用copy、append等函数
*/
更改字符串中的某一个字符，因为go的中的字符串是常量，不能直接改变，只能通过切片的形式
cbyte[4]='L'  这个时候的str中的[4]仍旧是原来的值
str=srting(cbyte)   得这样之后，才能实现对原来字符串的更改，这有点坑，更我想的不一样

12. 使用sort包，可以实现排序查找等功能，只能先排序，在查找，应为查找算法是二分法查找

var obj = [...]int{123, 35, 47, 798, 5, 673, 4576, 354, 2, 76, 98}
sort.Ints(obj[:])
fmt.Println(obj)
fmt.Printf("This is %d is 354", sort.SearchInts(obj[:], 354))

13. append函数的使用

将切片 b 的元素追加到切片 a 之后：a = append(a, b...)

复制切片 a 的元素到新的切片 b 上：b = make([]T, len(a)) copy(b, a)

删除位于索引 i 的元素：a = append(a[:i], a[i+1:]...)

切除切片 a 中从索引 i 至 j 位置的元素：a = append(a[:i], a[j:]...)

为切片 a 扩展 j 个元素长度：a = append(a, make([]T, j)...)

在索引 i 的位置插入元素 x：a = append(a[:i], append([]T{x}, a[i:]...)...)

在索引 i 的位置插入长度为 j 的新切片：a = append(a[:i], append(make([]T, j), a[i:]...)...)

在索引 i 的位置插入切片 b 的所有元素：a = append(a[:i], append(b, a[i:]...)...)

取出位于切片 a 最末尾的元素 x：x, a = a[len(a)-1:], a[:len(a)-1]

将元素 x 追加到切片 a：a = append(a, x)