[]*T*[]T*[]*T傻傻分不清楚

本文转载自微信公众号「crossoverJie」，作者crossoverJie。转载本文请联系crossoverJie公众号。

创新互联公司服务项目包括阜阳网站建设、阜阳网站制作、阜阳网页制作以及阜阳网络营销策划等。多年来，我们专注于互联网行业，利用自身积累的技术优势、行业经验、深度合作伙伴关系等，向广大中小型企业、政府机构等提供互联网行业的解决方案，阜阳网站推广取得了明显的社会效益与经济效益。目前，我们服务的客户以成都为中心已经辐射到阜阳省份的部分城市，未来相信会继续扩大服务区域并继续获得客户的支持与信任！

前言

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

 
 
 
 
    
  
  
  
  
  1. func FindA() ([]*T,error) { 
    2. 
  
  
  
  
  2. } 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4. func FindB() ([]T,error) { 
    5. 
  
  
  
  
  5. } 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. func SaveA(data *[]T) error { 
    8. 
  
  
  
  
  8. } 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10. func SaveB(data *[]*T) error { 
    11. 
  
  
  
  
  11. } 
    12.

相信大部分刚入门 Go 的新手看到这样的代码也是一脸懵逼，其中最让人疑惑的就是：

 
 
 
 
    
  
  
  
  
  1. []*T 
    2. 
  
  
  
  
  2. *[]T 
    3. 
  
  
  
  
  3. *[]*T 
    4.

这样对切片的声明，先不看后面两种写法;单独看 []*T 还是很好理解的：该切片中存放的是所有 T 的内存地址，会比存放 T 本身来说要更省空间，同时 []*T 在方法内部是可以修改 T 的值，而[]T 是修改不了。

 
 
 
 
    
  
  
  
  
  1. func TestSaveSlice(t *testing.T) { 
    2. 
  
  
  
  
  2.  a := []T{{Name: "1"}, {Name: "2"}} 
    3. 
  
  
  
  
  3.  for _, t2 := range a { 
    4. 
  
  
  
  
  4.   fmt.Println(t2) 
    5. 
  
  
  
  
  5.  } 
    6. 
  
  
  
  
  6.  _ = SaveB(a) 
    7. 
  
  
  
  
  7.  for _, t2 := range a { 
    8. 
  
  
  
  
  8.   fmt.Println(t2) 
    9. 
  
  
  
  
  9.  } 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11. } 
    12. 
  
  
  
  
  12. func SaveB(data []T) error { 
    13. 
  
  
  
  
  13.  t := data[0] 
    14. 
  
  
  
  
  14.  t.Name = "1233" 
    15. 
  
  
  
  
  15.  return nil 
    16. 
  
  
  
  
  16. } 
    17. 
  
  
  
  
  17.  
    18. 
  
  
  
  
  18. type T struct { 
    19. 
  
  
  
  
  19.  Name string 
    20. 
  
  
  
  
  20. } 
    21.

比如以上例子打印的是

 
 
 
 
    
  
  
  
  
  1. {1} 
    2. 
  
  
  
  
  2. {2} 
    3. 
  
  
  
  
  3. {1} 
    4. 
  
  
  
  
  4. {2} 
    5.

只有将方法修改为

 
 
 
 
    
  
  
  
  
  1. func SaveB(data []*T) error { 
    2. 
  
  
  
  
  2.  t := data[0] 
    3. 
  
  
  
  
  3.  t.Name = "1233" 
    4. 
  
  
  
  
  4.  return nil 
    5. 
  
  
  
  
  5. } 
    6.

才能修改 T 的值:

 
 
 
 
    
  
  
  
  
  1. &{1} 
    2. 
  
  
  
  
  2. &{2} 
    3. 
  
  
  
  
  3. &{1233} 
    4. 
  
  
  
  
  4. &{2} 
    5.

示例

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

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

先看第一种，输出是结果是：

 
 
 
 
    
  
  
  
  
  1. appendA [1000 2 3] 
    2. 
  
  
  
  
  2. main [1000 2 3] 
    3.

说明在函数传递过程中，函数内部的修改能够影响到外部。

下面我们再看一个例子：

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

最终结果却是：

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

没有影响到外部。

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

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

最终的结果：

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

可以发现如果传递切片的指针时，使用 append 函数追加数据时会影响到外部。

slice 原理

在分析上面三种情况之前，我们先来了解下 slice 的数据结构。

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

源码地址 runtime/slice.go

其中有三个重要的属性：

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

提到切片就不得不想到数组，可以这么理解：

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

其实通过切片这个名字也不难看出，它就是从数组中切了一部分;相对于数组的固定大小，切片可以根据实际使用情况进行扩容。

所以切片也可以通过对数组"切一刀"获得：

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

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

  • x2 的长度与容量则为3和5。
  • x2 的长度很容易理解。

容量等于5可以理解为，当前这个切片最多可以使用的长度。

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

同一个底层数组

以刚才的代码为例：

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

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

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

本质上修改的就是同一块内存数据。

值传递带来的误会

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

 
 
 
 
    
  
  
  
  
  1. func TestAppendB(t *testing.T) { 
    2. 
  
  
  
  
  2.  //x:=[]int{1,2,3} 
    3. 
  
  
  
  
  3.  x := make([]int, 3,5) 
    4. 
  
  
  
  
  4.  x[0] = 1 
    5. 
  
  
  
  
  5.  x[1] = 2 
    6. 
  
  
  
  
  6.  x[2] = 3 
    7. 
  
  
  
  
  7.  appendB(x) 
    8. 
  
  
  
  
  8.  fmt.Printf("main %v len=%v,cap=%v\n", x,len(x),cap(x)) 
    9. 
  
  
  
  
  9. } 
    10. 
  
  
  
  
  10. func appendB(x []int) { 
    11. 
  
  
  
  
  11.  x = append(x, 444) 
    12. 
  
  
  
  
  12.  fmt.Printf("appendB %v len=%v,cap=%v\n", x,len(x),cap(x)) 
    13. 
  
  
  
  
  13. } 
    14.

主要是修改了切片初始化方式，使得容量大于了长度，具体原因后续会说明。

输出结果如下：

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

main 函数中的数据看样子确实没有受到影响;但细心的朋友应该会注意到 appendB 函数中的 x 在 append() 之后长度 +1 变为了4。

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

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

 
 
 
 
    
  
  
  
  
  1. func TestAppendB(t *testing.T) { 
    2. 
  
  
  
  
  2.  //x:=[]int{1,2,3} 
    3. 
  
  
  
  
  3.  x := make([]int, 3,5) 
    4. 
  
  
  
  
  4.  x[0] = 1 
    5. 
  
  
  
  
  5.  x[1] = 2 
    6. 
  
  
  
  
  6.  x[2] = 3 
    7. 
  
  
  
  
  7.  appendB(x) 
    8. 
  
  
  
  
  8.  fmt.Printf("main %v len=%v,cap=%v\n", x,len(x),cap(x)) 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10.  y:=x[0:cap(x)] 
    11. 
  
  
  
  
  11.  fmt.Printf("y %v len=%v,cap=%v\n", y,len(y),cap(y)) 
    12. 
  
  
  
  
  12. } 
    13.

在刚才的基础之上，以 append 之后的 x 为基础再做了一个切片;该切片的范围为 x 所引用数组的全部数据。

再来看看执行结果如何：

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

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

看图就很容易理解了：

  • 在appendB中确实是对原始数组追加了数据，同时长度也增加了。
  • 但由于是值传递，所以 slice 这个结构体即便是修改了长度为4，也只是对复制的那个对象修改了长度，main 中的长度依然为3.
  • 由于底层数组是同一个，所以基于这个底层数组重新生成了一个完整长度的切片便能看到追加的数据了。

所以这里本质的原因是因为 slice 是一个结构体，传递的是值，不管方法里如何修改长度也不会影响到原有的数据(这里指的是长度和容量这两个属性)。

切片扩容

还有一个需要注意：

刚才特意提到这里的例子稍有改变，主要是将切片的容量设置超过了数组的长度;

如果不做这个特殊设置会怎么样呢?

 
 
 
 
    
  
  
  
  
  1. func TestAppendB(t *testing.T) { 
    2. 
  
  
  
  
  2.  x:=[]int{1,2,3} 
    3. 
  
  
  
  
  3.  //x := make([]int, 3,5) 
    4. 
  
  
  
  
  4.  x[0] = 1 
    5. 
  
  
  
  
  5.  x[1] = 2 
    6. 
  
  
  
  
  6.  x[2] = 3 
    7. 
  
  
  
  
  7.  appendB(x) 
    8. 
  
  
  
  
  8.  fmt.Printf("main %v len=%v,cap=%v\n", x,len(x),cap(x)) 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10.  y:=x[0:cap(x)] 
    11. 
  
  
  
  
  11.  fmt.Printf("y %v len=%v,cap=%v\n", y,len(y),cap(y)) 
    12. 
  
  
  
  
  12. } 
    13. 
  
  
  
  
  13. func appendB(x []int) { 
    14. 
  
  
  
  
  14.  x = append(x, 444) 
    15. 
  
  
  
  
  15.  fmt.Printf("appendB %v len=%v,cap=%v\n", x,len(x),cap(x)) 
    16. 
  
  
  
  
  16. } 
    17.

输出结果：

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

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

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

  • 这时便会进行扩容：
  • 将老数据复制一份到新的数组中。
  • 追加数据。

将新的数据内存地址返回给 appendB 中的 x .

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

传递切片指针

有没有什么办法即便是在扩容时也能对外部产生影响呢?

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

输出结果为：

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

这时外部的切片就能受到影响了，其实原因也很简单;

刚才也说了，因为 slice 本身是一个结构体，所以当我们传递指针时，就和平时自定义的 struct 在函数内部通过指针修改数据原理相同。

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

总结

所以总结一下：

  • 切片是对数组的抽象，同时切片本身也是一个结构体。
  • 参数传递时函数内部与外部引用的是同一个数组，所以对切片的修改会影响到函数外部。
  • 如果发生扩容，情况会发生变化，同时扩容会导致数据拷贝;所以要尽量预估切片大小，避免数据拷贝。
  • 对切片或数组重新生成切片时，由于共享的是同一个底层数组，所以数据会互相影响，这点需要注意。
  • 切片也可以传递指针，但场景很少，还会带来不必要的误解;建议值传值就好，长度和容量占用不了多少内存。

相信使用过切片会发现非常类似于 Java 中的 ArrayList，同样是基于数组实现，也会扩容发生数据拷贝;这样看来语言只是上层使用的选择，一些通用的底层实现大家都差不多。

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

名称栏目：[]*T*[]T*[]*T傻傻分不清楚
网页URL：http://www.csdahua.cn/qtweb/news8/401508.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

网站排名知识

分类信息网

成都免费建站　　 　帝美豪门窗　　 　合江网站建设　　 　传美奇电气　　 　成都app软件开发　　 　崇州威斯达宇　　 　成都全网营销推广　　 　成都网页设计　　 　簇桥薇薇新娘　　 　整合营销　　 　成都h5网站建设　　 　响应式网站设计　　 　小谭网创广告　　 　成都电信服务器托管　　 　绵阳梓潼网站建设　　 　app软件定制开发　　 　手机网站建设　　 　成都网站建设　　 　做网站　　 　东电技服