切片截取，有没有很迷？

目录

典型截取（两参数、三参数）及分析

迷之append参与截取及细节分析

关于截取时的初始索引是否从第一个位置开始的影响

修改原切片细节分析

---

典型截取（两参数、三参数）及分析

先看一个例子来表示一下切片的基础截取操作（仅截取，无append）：

    a := []int{1, 2}a0 := a[0:1]fmt.Printf("a0=%v, a0=%p, cap=%v\n", a0, a0, cap(a0)) // a0=[1], a0=0xc00009e070, cap=2fmt.Printf("a=%v, a=%p, cap=%v\n", a, a, cap(a))      // a=[1 2], a=0xc00009e070, cap=2b := a[0:1:1]fmt.Printf("a=%v, a=%p, cap=%v\n", a, a, cap(a))fmt.Printf("b=%v, b=%p, cap=%v\n", b, b, cap(b))    // b=[1], b=0xc00009e070, cap=1c := a[1:1]fmt.Printf("a=%v, a=%p, cap=%v\n", a, a, cap(a))fmt.Printf("c=%v, c=%p, cap=%v\n", c, c, cap(c))    // c=[], c=0xc00009e078, cap=1d := a[0:2:2]fmt.Printf("d=%v, d=%p, cap=%v\n", d, d, cap(d))e := a[1:2:2]fmt.Printf("e=%v, e=%p, cap=%v\n", e, e, cap(e))f := a[0:1]fmt.Printf("f=%v, f=%p, cap=%v\n", f, f, cap(f))fmt.Println(reflect.DeepEqual(f, b))     // trueg := a[0:2]fmt.Printf("g=%v, g=%p, cap=%v\n", g, g, cap(g))    // g=[1 2], g=0xc00009e070, cap=2fmt.Println(reflect.DeepEqual(d, g))     // true fmt.Println(reflect.DeepEqual(a, b))     // falsefmt.Println(reflect.DeepEqual(a, d))     // true

结果：

a0=[1], a0=0xc00009e070, cap=2
a=[1 2], a=0xc00009e070, cap=2
a=[1 2], a=0xc00009e070, cap=2
b=[1], b=0xc00009e070, cap=1
a=[1 2], a=0xc00009e070, cap=2
c=[], c=0xc00009e078, cap=1
d=[1 2], d=0xc00009e070, cap=2
e=[2], e=0xc00009e078, cap=1
f=[1], f=0xc00009e070, cap=2
true
g=[1 2], g=0xc00009e070, cap=2
true
false
true

以上分析中包含了海量信息，能总结出方便理解的规律、能看透才是王道。 

从上面结果可以得到以下信息：
1，c和e的地址和其它的不同；
2，b虽然是一个新搞出来的切片，但b和a都是相同的地址，a底层的数组b也在用，同时b是从a切片第一个位置开始(首地址)；
3，c截取的也是a的元素组成的切片，但c是从第2个位置开始的，c和a的地址不同；
4，d截取的也是a的元素组成的切片，且d是从数组第1个位置开始的，d和a的地址相同；
5，e截取的也是a的元素组成的切片，是从数组第二个位置开始的，e和a的地址不同，e和c的地址相同；
6，d的容量之所以为2，是因为截取时指定了截取的第三个参数为2，起始索引为0，则2-0=2，以此类推e的容量必然是1，因为2-1=1；
7，d := a[0:2:2]这个操作包含了a的所有元素，是从首地址开始，同时长度和容量都和a相同，因此DeepEqual的结果为true；
8，f和b容量不同，f和b的区别是截取的第三个参数一个指定了另一个是默认，b是1，f是2，那么容量不同为啥还能深度相等？
因为对于切片，类型相同、相同索引处元素相等，则深度相等；
9，对于a0 := a[0:1]这样的仅截取操作，根本不会影响a切片，但截取操作在append中就可能有影响了。

这个代码例子虽然看起来简单没什么复杂操作，但却包罗万象不乏细节，下面是结论：

1，截取之后得到的切片是不是和原切片指向的地址相同，主要是看截取的首地址是否是从原切片的第一个元素开始，因为都是基于a来截取，底层数组一直在那放着，就看不同的人要截取多少（即东西是同一份东西，不同的人看到的视图不一样而已）；
2，以a[d:e]为例，是指基于a切片，从其索引为d的位置开始、索引为e的位置（不包括）结束所获得的切片，所得切片的容量是a切片的原有容量；
3，以a[d:e:f]为例，是指基于a切片，从其索引为d的位置开始、索引为e的位置（不包括）结束所获得的切片，所得切片的容量是f-d。

基于纯截取而没有其它操作的情形下，原切片不会被修改，基于以上案例和分析，我们可以得到切片截取时的地址、容量等变化。

迷之append参与截取及细节分析

下面是四个典型案例，需要仔细观察。

函数1：

func cut95() {fmt.Println("cut95 start")a := []int{1, 2}b := append(a[0:1], 3)//fmt.Println(a[1:2]) // [3]fmt.Printf("a= %v, %v, %p\n", a, cap(a), a) // a= [1 3], 2, 0xc00001a140fmt.Printf("b= %v, %v, %p\n", b, cap(b), b) // b= [1 3], 2, 0xc00001a140c := append(a[1:2], 4)fmt.Printf("a= %v, %v, %p\n", a, cap(a), a) // a= [1 3], 2, 0xc00001a140fmt.Printf("b= %v, %v, %p\n", b, cap(b), b) // b= [1 3], 2, 0xc00001a140fmt.Printf("c= %v, %v, %p\n", c, cap(c), c) // c= [3 4], 2, 0xc00001a170d := append(a[1:2], 4, 5, 6)                // 有人说扩容了就会怎么怎么样，来让它扩容一下fmt.Printf("a= %v, %v, %p\n", a, cap(a), a) // [1 3], 2, 0xc00001a140fmt.Printf("b= %v, %v, %p\n", b, cap(b), b) // [1 3], 2, 0xc00001a140fmt.Printf("c= %v, %v, %p\n", c, cap(c), c) // [3 4], 2, 0xc00001a170fmt.Printf("d= %v, %v, %p\n", d, cap(d), d) // [3 4 5 6], 4, 0xc0000121c0/*第1处截取操作：会导致a被修改第2处截取操作：a没有被修改第3处截取操作：a没有被修改注意除过第三次截取外其余截取之后的新切片均未发生扩容，和扩容无关；第三次截取扩容后地址发生了变化这是肯定了，因为容量需要扩充，原数组已不能满足要求、数组定长不能扩容，此时需要申请新数组（指针已变），再将数据拷贝到新切片；发生了扩容，但依旧原切片a没有变化。*/
}

函数2：

func cut96() {fmt.Println("cut96 start")a := []int{1, 2}b := append(a[1:2], 3)//fmt.Println(a[1:2]) // [3]fmt.Println("a= ", a) // [1 2]fmt.Println("b= ", b) // [2 3]c := append(a[1:2], 4)fmt.Println("a= ", a) // [1 2]fmt.Println("b= ", b) // [2 3]fmt.Println("c= ", c) // [2 4]d := append(a[0:1], 5)fmt.Println("a= ", a) // [1 5]fmt.Println("b= ", b) // [2 3]fmt.Println("c= ", c) // [2 4]fmt.Println("d= ", d) // [1 5]/*第1处截取操作：a没有被修改第2处截取操作：a没有被修改第3处截取操作：会导致a被修改，并且a原本是1，2 其中2也没有了，截取的1和拼接的5组成了新的a*/
}

 函数3：

  fmt.Println("cut97 start")a := []int{1, 2}b := append(a[0:1:1], 3)//fmt.Println(a[1:2]) // [2]fmt.Println("a= ", a) // [1 2]fmt.Println("b= ", b) // [1 3]c := append(a[1:2:2], 4)fmt.Println("a= ", a) // [1 2]fmt.Println("b= ", b) // [1 3]fmt.Println("c= ", c) // [2 4]/*第1处截取操作：a没有被修改第2处截取操作：a没有被修改*/

函数4：

func cut98() {fmt.Println("cut98 start")a := []int{1, 2}b := append(a[0:1:2], 3) // 这里如果改为a[0:1:1] a不会被修改//fmt.Println(a[1:2]) // [2]fmt.Println("a= ", a) // [1 3]fmt.Println("b= ", b) // [1 3]c := append(a[1:2], 4)fmt.Println("a= ", a) // [1 3]fmt.Println("b= ", b) // [1 3]fmt.Println("c= ", c) // [3 4]d := append(a[0:2], 5)fmt.Println("a= ", a) // [1 3]fmt.Println("b= ", b) // [1 3]fmt.Println("c= ", c) // [3 4]fmt.Println("d= ", d) // [1 3 5]/*第1处截取操作：a被修改第2处截取操作：a没有被修改第3处截取操作：a没有被修改*/
}

现象不细说了，一看代码便知，这里汇总一下结论：

给原切片做截取操作同时套append时，原切片会不会被跟着被修改（注意这里讨论的是还有append的情况下，并不是单纯截取），按下面步骤。

一

首先看截取后的切片是否和原切片相等（如长度为2容量也为2），如果相等则当然不变，如：
a := []int{1, 2}
d := append(a[0:2], 5)
上面换成  d := append(a[0:2:2], 5) 或  d := append(a[0:], 5) 或  d := append(a[:], 5) 效果都和a本身一样
这样的情况原切片a必然不变。

二

如果不满足1的情况，则此时看截取时所得的切片长度和容量：

【下述的“所得切片”指的是截取后但未套append时的代称】

如果 所得切片的容量=原切片容量（注意没有套append时不牵扯扩容）
    a) 如果 数据长度<原切片数据长度（即仅截取了部分数据），则原切片会被修改； 
    如cut98()中的第一处截取append(a[0:1:2]、cut95()中的第一处截取append(a[0:1]
    但要注意的是，此时如果套了append并发生扩容时，即使满足此情况也不会修改原切片a，因为发生了扩容，原切片不能再满足，不会再做什么修改，cut95()中已说明。
    
    b) 如果 数据长度=原切片数据长度（即截取了所有数据，此时视图是原切片全部），则原切片不会被修改； 和上面第一个情况相同；
    
如果 所得切片的容量<原切片容量
    a) 数据长度<原切片数据长度（即仅截取了部分数据），则原切片不会被修改； 
    如cut97()中的第2处截取append(a[1:2:2]，或cut96()中的第1、2处截取append(a[1:2]
    
    b) 数据长度=原切片数据长度（即截取了所有数据），这种情况不存在，编译都不能通过：Invalid index values, must be low <= high <= max

关于截取时的初始索引是否从第一个位置开始的影响

如cut98()中的第一处截取append(a[0:1:2]会修改原切片a；（和append(a[0:1]一样），但如果改为a[0:1:1] a则不会被修改。
这两者都是从第一个位置开始截取，但结果显然不同，因此不能单以“截取时的初始索引是否从第一个位置开始”来定结果。

原切片会不会被修改，和截取时写成a[low:high]还是a[low:high:max]并无直接关系，和截取的初始索引是否从第一个位置开始也无直接关系。

修改原切片细节分析

那为什么所得切片的容量=原切片容量、且数据长度<原切片数据长度时，原切片就会被修改呢？

拿cut95的第一处来说：

    a := []int{1, 2}b := append(a[0:1], 3)

首先创建a切片，长度容量都是2，对应的底层数组是两个元素；

第二步分解，上面已经说明a[0:1]操作时不会修改a，a[0:1]相当于a[0:1:2]，a[0:1]取得的值是1，对应的正是底层数组的第一个元素，a[0:1]这个切片本身地址和a一致，只是仅截取第一个元素；

清楚了上面后接着做append操作，在第一个元素位置的基础上，拼接了元素3，相当于3这个元素覆盖掉了第二个位置上的2这个元素，因此底层数组变成了1、3

那你有没有这样想过：1后面拼接了3，为什么不变为1,3,2（即2被挤压了）   而是1，3呢？ 为什么把2没有挤到后面去而是覆盖操作？

如果2被挤压、下标变化，意味着切片a的容量发生变化，但实际上拼接没有发生在a上，拼接是给b做了拼接，既然没给a拼接，a本身数据长度就不应该发生变化。

相反如果做了b := append(a[0:1], 3, 4, 5, 6)操作后，情形是a原本的容量已不足支撑新数据，系统经过计算申请了新数组，新数组适配b，然后才会塞数据，而且一样拼接不是发生在a上，a切片就不会再动了，不会再影响原切片。