关于golang:T-T-T-傻傻分不清楚

作为一个 Go 语言老手，看到所有”诡异“的代码都会感到好奇；比方我最近看到的几个办法；伪代码如下：

func FindA() ([]*T,error) {
}

func FindB() ([]T,error) {
}

func SaveA(data *[]T) error {
}

func SaveB(data *[]*T) error {}

置信大部分刚入门 Go 的老手看到这样的代码也是一脸懵逼，其中最让人纳闷的就是：

[]*T
*[]T
*[]*T

这样对切片的申明，先不看前面两种写法；独自看 []*T 还是很好了解的：
该切片中寄存的是所有 T 的内存地址，会比寄存 T 自身来说要更省空间，同时 []*T 在办法外部是能够批改 T 的值，而[]T 是批改不了。

func TestSaveSlice(t *testing.T) {a := []T{{Name: "1"}, {Name: "2"}}
    for _, t2 := range a {fmt.Println(t2)
    }
    _ = SaveB(a)
    for _, t2 := range a {fmt.Println(t2)
    }

}
func SaveB(data []T) error {t := data[0]
    t.Name = "1233"
    return nil
}

type T struct {Name string}

比方以上例子打印的是

{1}
{2}
{1}
{2}

只有将办法批改为

func SaveB(data []*T) error {t := data[0]
    t.Name = "1233"
    return nil
}

能力批改 T 的值:

&{1}
&{2}
&{1233}
&{2}

上面重点来看看 []*T 与 *[]T 的区别，这里写了两个 append 函数：

func TestAppendA(t *testing.T) {x:=[]int{1,2,3}
    appendA(x)
    fmt.Printf("main %v\n", x)
}
func appendA(x []int) {x[0]= 100
    fmt.Printf("appendA %v\n", x)
}

先看第一种，输入是后果是：

appendA [1000 2 3]
main [1000 2 3]

阐明在函数传递过程中，函数外部的批改可能影响到内部。

上面咱们再看一个例子：

func appendB(x []int) {x = append(x, 4)
    fmt.Printf("appendA %v\n", x)
}

最终后果却是：

appendA [1 2 3 4]
main [1 2 3]

没有影响到内部。

而当咱们再调整一下会发现又有所不同：

func TestAppendC(t *testing.T) {x:=[]int{1,2,3}
    appendC(&x)
    fmt.Printf("main %v\n", x)
}
func appendC(x *[]int) {*x = append(*x, 4)
    fmt.Printf("appendA %v\n", x)
}

最终的后果：

appendA &[1 2 3 4]
main [1 2 3 4]

能够发现如果传递切片的指针时，应用 append 函数追加数据时会影响到内部。

在剖析下面三种状况之前，咱们先来理解下 slice 的数据结构。

间接查看源码会发现 slice 其实就是一个构造体，只是不能间接对外拜访。

源码地址 runtime/slice.go

其中有三个重要的属性：

属性	含意
array	底层存放数据的数组，是一个指针。
len	切片长度
cap	切片容量 `cap>=len`

提到切片就不得不想到数组，能够这么了解：

切片是对数组的形象，而数组则是切片的底层实现。

其实通过切片这个名字也不难看出，它就是从数组中切了一部分；绝对于数组的固定大小，切片能够依据理论应用状况进行扩容。

所以切片也能够通过对数组 ” 切一刀 ” 取得：

x1:=[6]int{0,1,2,3,4,5}
x2 := x[1:4]
fmt.Println(len(x2), cap(x2))

其中 x1 的长度与容量都是 6。

x2 的长度与容量则为 3 和 5。

x2 的长度很容易了解。
容量等于 5 能够了解为，以后这个切片最多能够应用的长度。

因为切片 x2 是对数组 x1 的援用，所以底层数组排除掉右边一个没有被援用的地位则是该切片最大的容量，也就是 5。

以方才的代码为例：

func TestAppendA(t *testing.T) {x:=[]int{1,2,3}
    appendA(x)
    fmt.Printf("main %v\n", x)
}
func appendA(x []int) {x[0]= 100
    fmt.Printf("appendA %v\n", x)
}

在函数传递过程中，main 中的 x 与 appendA 函数中的 x 切片所援用的是同个数组。

所以在函数中对 x[0]=100，main函数中也能获取到。

实质上批改的就是同一块内存数据。

在上述例子中，在 appendB 中调用 append 函数追加数据后会发现 main 函数中并没有受到影响，这里我略微调整了一下示例代码：

func TestAppendB(t *testing.T) {//x:=[]int{1,2,3}
    x := make([]int, 3,5)
    x[0] = 1
    x[1] = 2
    x[2] = 3
    appendB(x)
    fmt.Printf("main %v len=%v,cap=%v\n", x,len(x),cap(x))
}
func appendB(x []int) {x = append(x, 444)
    fmt.Printf("appendB %v len=%v,cap=%v\n", x,len(x),cap(x))
}

次要是批改了切片初始化形式，使得容量大于了长度，具体起因后续会阐明。

输入后果如下：

appendB [1 2 3 444] len=4,cap=5
main [1 2 3] len=3,cap=5

main 函数中的数据看样子的确没有受到影响；但仔细的敌人应该会留神到 appendB 函数中的 x 在 append() 之后长度 +1 变为了 4。

而在 main 函数中长度又变回了 3.

这个细节区别就是为什么 append() “ 看似 ” 没有失效的起因；至于为什么要说“看似”，再次调整了代码：

func TestAppendB(t *testing.T) {//x:=[]int{1,2,3}
    x := make([]int, 3,5)
    x[0] = 1
    x[1] = 2
    x[2] = 3
    appendB(x)
    fmt.Printf("main %v len=%v,cap=%v\n", x,len(x),cap(x))

    y:=x[0:cap(x)]
    fmt.Printf("y %v len=%v,cap=%v\n", y,len(y),cap(y))
}

在方才的根底之上，以 append 之后的 x 为根底再做了一个切片；该切片的范畴为 x 所援用数组的全副数据。

再来看看执行后果如何：

appendB [1 2 3 444] len=4,cap=5
main [1 2 3] len=3,cap=5
y [1 2 3 444 0] len=5,cap=5

会神奇的发现 y 将所有数据都打印进去，在 appendB 函数中追加的数据其实曾经写入了数组中，但为什么 x 自身没有获取到呢？

看图就很容易了解了：

在 appendB 中的确是对原始数组追加了数据，同时长度也减少了。
但因为是值传递，所以 slice 这个构造体即使是批改了长度为 4，也只是对复制的那个对象批改了长度，main 中的长度仍然为 3.
因为底层数组是同一个，所以基于这个底层数组从新生成了一个残缺长度的切片便能看到追加的数据了。

所以这里实质的起因是因为 slice 是一个构造体，传递的是值，不论办法里如何批改长度也不会影响到原有的数据（这里指的是长度和容量这两个属性）。

还有一个须要留神：

方才特意提到这里的例子稍有扭转，次要是将切片的容量设置超过了数组的长度；

如果不做这个非凡设置会怎么样呢？

func TestAppendB(t *testing.T) {x:=[]int{1,2,3}
    //x := make([]int, 3,5)
    x[0] = 1
    x[1] = 2
    x[2] = 3
    appendB(x)
    fmt.Printf("main %v len=%v,cap=%v\n", x,len(x),cap(x))

    y:=x[0:cap(x)]
    fmt.Printf("y %v len=%v,cap=%v\n", y,len(y),cap(y))
}
func appendB(x []int) {x = append(x, 444)
    fmt.Printf("appendB %v len=%v,cap=%v\n", x,len(x),cap(x))
}

输入后果：

appendB [1 2 3 444] len=4,cap=6
main [1 2 3] len=3,cap=3
y [1 2 3] len=3,cap=3

这时会发现 main 函数中的 y 切片数据也没有发生变化，这是为什么呢？

这是因为初始化 x 切片时长度和容量都为 3，当在 appendB 函数中追加数据时，会发现没有地位了。

这时便会进行扩容：

将老数据复制一份到新的数组中。
追加数据。
将新的数据内存地址返回给 appendB 中的 x .

同样的因为是值传递，所以 appendB 中的切片换了底层数组对 main 函数中的切片没有任何影响，也就导致最终 main 函数的数据没有任何变动了。

有没有什么方法即使是在扩容时也能对外部产生影响呢？

func TestAppendC(t *testing.T) {x:=[]int{1,2,3}
    appendC(&x)
    fmt.Printf("main %v len=%v,cap=%v\n", x,len(x),cap(x))
}
func appendC(x *[]int) {*x = append(*x, 4)
    fmt.Printf("appendC %v\n", x)
}

输入后果为：

appendC &[1 2 3 4]
main [1 2 3 4] len=4,cap=6

这时内部的切片就能受到影响了，其实起因也很简略；

方才也说了，因为 slice 自身是一个构造体，所以当咱们传递指针时，就和平时自定义的 struct 在函数外部通过指针批改数据原理雷同。

最终在 appendC 中的 x 的指针指向了扩容后的构造体，因为传递的是 main 函数中 x 的指针，所以同样的 main 函数中的 x 也指向了该构造体。

所以总结一下：

切片是对数组的形象，同时切片自身也是一个构造体。
参数传递时函数外部与内部援用的是同一个数组，所以对切片的批改会影响到函数内部。
如果产生扩容，状况会发生变化，同时扩容会导致数据拷贝；所以要尽量预估切片大小，防止数据拷贝。
对切片或数组从新生成切片时，因为共享的是同一个底层数组，所以数据会相互影响，这点须要留神。
切片也能够传递指针，但场景很少，还会带来不必要的误会；倡议值传值就好，长度和容量占用不了多少内存。

置信应用过切片会发现十分相似于 Java 中的 ArrayList，同样是基于数组实现，也会扩容产生数据拷贝；这样看来语言只是下层应用的抉择，一些通用的底层实现大家都差不多。

这时咱们再看题目中的 []*T *[]T *[]*T 就会发现这几个并没有什么分割，只是看起来很像容易唬人。

关于golang:T-T-T-傻傻分不清楚

前言

示例

slice 原理

同一个底层数组

值传递带来的误会

切片扩容

传递切片指针

总结