一个问题让你搞清Golang数组和切片的变量复制

最新推荐文章于 2025-03-02 16:13:03 发布
最新推荐文章于 2025-03-02 16:13:03 发布
阅读量960 收藏 8
点赞数 20
CC 4.0 BY-SA版权
文章标签： golang 爬虫 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sc35262/article/details/144428286

切片slice和数组array是golang中常见且重要的数据类型。一言以蔽之，从使用角度看来，数组是有固定长度的特殊切片；而切片是一个可以自动扩容的不定长数组。

但是两种数据类型在底层实现上又有着本质的区别。我们知道在golang中变量分为值类型变量和引用类型变量。其中 string、int、float、bool和 array等基础类型属于值类型变量，而 slice、map、chan 等则属于引用类变量。

在对象拷贝时，golang默认采用值拷贝的策略，即深度拷贝策略；但是对slice、map、chan 等类型，由于其本身属于引用类型，变量本身存储的就是指针数据，所以实际为浅拷贝。因此数组和分片在拷贝后的修改对于原来变量的影响会有所区别。下面我们用三个例子来说明这种区别

1、数组拷贝

 

golang
 

代码解读
 

复制代码
 

func main() { a := [3]int{1, 2, 3} b := a c := &a b[0] = 10 c[0] = 5 fmt.Printf("a = %v,ptr = %p\n", a, &a) fmt.Printf("b = %v,ptr = %p\n", b, &b) fmt.Printf("c = %v,ptr = %p\n", c, c) } 
 

测试输出为：
 

 

text
 

代码解读
 

复制代码
 

a = [5 2 3],ptr = 0x1400011a018 b = [10 2 3],ptr = 0x1400011a030 c = &[5 2 3],ptr = 0x1400011a018 
 

通过上面的例子，我们可以发现, 数组对象拷贝后会生成两个不相关的数组变量，分别指向不同的地址空间，修改某一个变量，另一个变量不会受到影响，但是当我们通过变量c来拷贝a变量的指针时，通过修改变量c，是可以影响变量a的，因为两个对象指向同一块地址空间。
 

2、切片拷贝1
 

 

golang
 

代码解读
 

复制代码
 

func main() { a := []int{1, 2, 3} b := a[:2] fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b[0] = 10 fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b = append(b, 4) fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b = append(b, 5) fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b[0] = 20 fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) } 
 

测试输出为：
 

 

text
 

代码解读
 

复制代码
 

a = [1 2 3],cap = 3,len= 3, 底层数组地址 = 0x1400001a120, 变量地址 = 0x1400000c0c0 b = [1 2],cap = 3,len= 2, 底层数组地址 = 0x1400001a120, 变量地址 = 0x1400000c0d8 a = [10 2 3],cap = 3,len= 3, 底层数组地址 = 0x1400001a120, 变量地址 = 0x1400000c0c0 b = [10 2],cap = 3,len= 2, 底层数组地址 = 0x1400001a120, 变量地址 = 0x1400000c0d8 a = [10 2 4],cap = 3,len= 3, 底层数组地址 = 0x1400001a120, 变量地址 = 0x1400000c0c0 b = [10 2 4],cap = 3,len= 3, 底层数组地址 = 0x1400001a120, 变量地址 = 0x1400000c0d8 a = [10 2 4],cap = 3,len= 3, 底层数组地址 = 0x1400001a120, 变量地址 = 0x1400000c0c0 b = [10 2 4 5],cap = 6,len= 4, 底层数组地址 = 0x14000016210, 变量地址 = 0x1400000c0d8 a = [10 2 4],cap = 3,len= 3, 底层数组地址 = 0x1400001a120, 变量地址 = 0x1400000c0c0 b = [20 2 4 5],cap = 6,len= 4, 底层数组地址 = 0x14000016210, 变量地址 = 0x1400000c0d8 
 

通过上面的例子可以发现，切片对象拷贝后，会生成两个变量，变量地址指向不同的地址空间，从a和b 分别具有不同的 len 值，也可以确认a和b对象本身是两个完全独立的对象。但是两个变量指向的底层数组地址一致，说明切片对象内容的拷贝是浅拷贝。因此当我们操作b[0]的数值时，a 切片的值也会受到影响。
 

当我们第一次针对b执行append(b, 4)操作时，由于其b变量的cap空间足够，因此不会重现生成新的底层数组对象，此时与a仍然共用同一个底层数据，只不过会将4覆盖原来b[2]的值，因此a[2]的值也会受到影响。
 

当我们第二次针对b执行append(b, 5)操作时，由于其b变量的cap空间已经被全部占用，因此触发切片扩容，需要重现申请底层数组空间，此时我们可以看到，b变量本身的地址不变，但是其指向的底层数组地址发生了变化。因此此时我们在修改b[0]时，a[0]的值不会受到影响。
 

切片扩容的原理及源码实现可以参考上一篇文章golang数组和切片的区别
 

3、切片拷贝2
 

 

golang
 

代码解读
 

复制代码
 

func main() { a := []int{1, 2, 3} b := a[1:] fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b[0] = 10 fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b = append(b, 4) fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b[0] = 20 fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) } 
 

测试输出为：
 

 

text
 

代码解读
 

复制代码
 

a = [1 2 3],cap = 3,len= 3, 底层数组地址 = 0x1400011a018, 变量地址 = 0x1400012c0a8 b = [2 3],cap = 2,len= 2, 底层数组地址 = 0x1400011a020, 变量地址 = 0x1400012c0c0 a = [1 10 3],cap = 3,len= 3, 底层数组地址 = 0x1400011a018, 变量地址 = 0x1400012c0a8 b = [10 3],cap = 2,len= 2, 底层数组地址 = 0x1400011a020, 变量地址 = 0x1400012c0c0 a = [1 10 3],cap = 3,len= 3, 底层数组地址 = 0x1400011a018, 变量地址 = 0x1400012c0a8 b = [10 3 4],cap = 4,len= 3, 底层数组地址 = 0x1400014e040, 变量地址 = 0x1400012c0c0 a = [1 10 3],cap = 3,len= 3, 底层数组地址 = 0x1400011a018, 变量地址 = 0x1400012c0a8 b = [20 3 4],cap = 4,len= 3, 底层数组地址 = 0x1400014e040, 变量地址 = 0x1400012c0c0 
 

通过上面的例子可以发现，切片对象拷贝后，由于b取的是a数组的后两个元素，而数组的空间是连续的，因此b切片的cap变为2，同时b的底层数据地址刚好指向a切片底层数组的第二个元素地址。由于我们的数组类型为int类型，系统为64位，每个元素占用8字节，由于数组地址连续，b的底层数组地址 正好等于 切片a 底层数组地址 0x1400011a018 + 8，即b切片第一个元素地址正对切片底层数组的第二个元素。此时我们修改 b[0] = 10 值，则a[1]也会同步被修改为10。
 

当我们针对b执行append(b, 4)操作时，由于其b变量的cap空间已经被全部占用，因此触发切片扩容，需要重现申请底层数组空间，此时我们可以看到，b切片指向的底层数组地址发生了变化。因此此时我们再修改b[0]时，a[1]的值不会受到影响。
 

4、总结
 

相信通过上面三个测试用例，可以很清楚的说明golang中数组和切片变量的对象复制区别。我们可以总结为以下几个要点：
 

  • 数组变量为值复制，复制后变量之间独立。除非指定为变量指针传递。
  • 切片变量为指针复制，复制后变量操作是否会影响原变量，取决于该才操作是否会触发切片的扩容。


请思考以下测试用例的输出结果：
 

 

golang
 

代码解读
 

复制代码
 

func main() { a := []int{1, 2, 3, 4} b := a[1:3] fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b[0] = 10 fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b = append(b, 5) fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b[0] = 20 fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b = append(b, 6) fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b[0] = 30 fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) }

                

        

    

    
  



    

      

        

            

              
                
                  Java八股文
                
              
            

            

                关注
              
            

        

        

          
      

      










                



	

		

			

				
					
Go语言高级面试必考：切片（slice）你真的掌握了吗？

				
			

			

				

					大模型大数据攻城狮的专栏
				

				

					07-10
					
					666
					
				

			

		

		

			
				
《Go语言切片深度解析》摘要：切片是Go语言中灵活且强大的动态数组结构，由指针、长度和容量三个核心字段组成。文章详细剖析了切片与数组的区别、内存结构、初始化方式及常见操作，揭示了append扩容机制和copy函数的工作原理。特别指出切片在并发环境下的数据竞争风险及解决方案，并提供了预分配容量、批量操作等性能优化技巧。通过分析runtime包源码，展示了切片底层实现逻辑，帮助开发者避开内存泄漏和性能陷阱，掌握切片的高效使用方法。文章兼具理论深度与实践指导价值，是深入理解Go切片的权威指南。

			
		

	



                

            
              



	

		

			

				
					
Go反射四讲---第一讲：什么是反射，反射常用的API，反射三原则以及注意事项

				
			

			

				

					weixin_55818116的博客
				

				

					08-25
					
					879
					
				

			

		

		

			
				
什么反射，在Go中如何使用反射，本文带你了解反射的常用API，注意事项，反射三原则以及如何使用等。

			
		

	



              


  
              

                


	

		

			

				
					
Golang：数组与切片的复制

				
			

			

				

					ミ安之偌素
				

				

					06-09
					
					2810
					
				

			

		

		

			
				
在Golang中，数组是值类型而切片是引用类型。因此值的复制与切片的复制并不相同。
数组的复制
对于值类型的数组来说，变量指向的并不是第一个元素的指针，而是整个数组。以下情况会发生数组的复制：

将数组变量赋值给另一个数组变量
将数组变量作为参数传递给方法
举个栗子：

package main

import "fmt"

func main() {
    sample1 := [2]string{"a", "b"}
    fmt.Printf("Sample1 Before: %v\n", samp

			
		

	





	

		

			

				
					
golang切片拷贝

				
			

			

				

					qingyu3044的博客
				

				

					07-05
					
					407
					
				

			

		

		

			
				
去若是浅拷贝，原始的切片变化后所有的切片都会变化，无论切片是否在一个函数，还是一个goroutine中，都会发生变化。出现非常奇怪的问题切片内容经常莫名奇妙的改变，最后发现是切片赋值的问题。如下代码问题困扰了好久，才发现是切片赋值的问题。golang切片有浅拷贝和深拷贝的区别。

			
		

	



		

			
		



	

		

			

				
					
golang：切片拷贝

				
			

			

				

					OceanStar的博客
				

				

					08-22
					
					2306
					
				

			

		

		

			
				
内置函数copy()可以将一个数组切片复制到另一个数组切片中，如果加入的两个数组切片不一样大，就会按照其中较小的那个数组切片的元素个数进行复制。
copy( destSlice, srcSlice []T) int

其中 srcSlice 为数据来源切片，destSlice 为复制的目标（也就是将 srcSlice 复制到 destSlice），目标切片必须分配过空间且足够承载复制的元素个数，并且来源和目标的类型必须一致，copy() 函数的返回值表示实际发生复制的元素个数。
下面的代码展示了使用 cop

			
		

	





	

		

			

				
					
golang切片和数组拷贝（浅拷贝和深拷贝）

				
			

			

				

					西京刀客
				

				

					10-22
					
					9658
					
				

			

		

		

			
				
我们提到的深拷贝和浅拷贝，则指的是引用类型的值处理方案。数组和切片属于哪种？
浅拷贝指的是，把变量里面存的内存地址拷贝了，所指向的真实值并没拷贝。

			
		

	





	

		

			

				
					
golang 复制对象

				
			

			

				

					whatday的专栏
				

				

					11-20
					
					2630
					
				

			

		

		

			
				
需求

　　实际运用种，传参是一对象指针，现在如何最简便地复制一对象？

实现

错误方法：&* 先拿到值再指针？


package main
 
import (
    "time"
    "log"
)
 
func main() {
 
    T1 := &TestS{1}
    T2 := &*T1
    T2.a = 5
    log.Print(T1)
    log.Print(T2)
}

输出


2017/06/15 20:14:27 &{.

			
		

	





	

		

			

				
					
Golang笔记

				
			

			

				

					怨行客
				

				

					10-18
					
					685
					
				

			

		

		

			
				
协程是用户态轻量级线程协程是线程调度的基本单位通常在函数前加上go关键字就能实现并发。一个Goroutine会以一个很小的栈启动2KB或4KB，当遇到栈空间不足时，栈会自动伸缩， 因此可以轻易实现成千上万个goroutine同时启动。

			
		

	





	

		

			

				
					
golang深度学习-内存管理

				
			

			

				

					G970620的博客
				

				

					03-02
					
					1057
					
				

			

		

		

			
				
TCMalloc（Thread-Caching Malloc）是由Google开发的一种内存分配器，用于替代标准C库中的malloc和free函数。它主要用于提高多线程环境下程序的内存分配和释放性能，特别是在高并发情况下。使用TCMalloc能够有效地提升程序的性能，特别是在多线程并发环境下，减少锁竞争和内存碎片对性能造成的影响。

			
		

	





	

		

			

				
					
【2022版】Golang面试题目全网超全超详细的口语化解答总结

				
			

			

				

					一年之内毫无半点成绩，想起来做人真是没趣。
				

				

					06-10
					
					9784
					
				

			

		

		

			
				
GO语言面试题目总结，站在巨人的肩膀上吧，也有自己的分析。有相关的题目。

			
		

	





	

		

			

				
					
【Golang】数组 && 切片

				
			

			

				

					Suk_god的博客
				

				

					10-02
					
					981
					
				

			

		

		

			
				
当 map 增长到容量上限的时候，如果再增加新的 key-value，map 的大小会自动加 1，所以出于性能的考虑，对于大的 map 或者会快速扩张的 map，即使只是大概知道容量，也最好先标明。Go语言的内置函数 copy() 可以将一个数组切片复制到另一个数组切片中，如果加入的两个数组切片不一样大，就会按照其中较小的那个数组切片的元素个数进行复制。N维数组本质上是一个一维数组，这个一维数组的每个元素是N-1维数组，以此类推，直到访问到最底一层，能够直接处理数组中的元素。

			
		

	





	

		

			

				
					
简单笔记：记一次 golang 的切片复制

				
			

			

				

					weixin_41346635的博客
				

				

					04-21
					
					1079
					
				

			

		

		

			
				
常规情况下 golang 的一维数组复制，可以这样写：


func copy(src []int) []int {
	copy0 := make([]int, len(src))
	copy(copy0, src)
    return copy0
}

这样写，会新开辟一块内存空间，对切片副本的任何修改操作，不会影响原切片。

如果需求是二维数组，出于惯性思维，可能会这样写：


func copy0(src [][]int) [][]int {
	copy0 := make_slice2(len(sr

			
		

	





	

		

			

				
					
golang复制切片的方法（避免操作同一底层数组）

				
			

			

				

					weixin_43970884的博客
				

				

					07-29
					
					880
					
				

			

		

		

			
				
切片拷贝

			
		

	





	

		

			

				
					
Go语言切片【复制（copy 、append）、剪切、删除（append、copy、len）等操作

				
			

			

				

					wgchen
				

				

					08-03
					
					1171
					
				

			

		

		

			
				
然而，如果切片 a 的长度为偶数，例如长度为 6，那么中间的元素索引为 2 和 3。然后，使用循环遍历排序后的切片，将不重复的元素移到切片的前部。使用两个 append 函数完成，即先将索引i之后的元素追加到一个长度为 j 的切片后，再将这个切片中的所有元素追加到切片 a 的索引i之后。这个示例展示了如何在切片中移动元素并维护元素的相对位置，以及如何在需要时将新的元素添加到切片的前面。最后，我们通过切片操作。的元素，无需保留切片元素原有的顺序，那么还可以使用下面这种简单的方式进行删除。

			
		

	





	

		

			

				
					
golang-切片copy

				
			

			

				

					浩秦的博客
				

				

					05-29
					
					304
					
				

			

		

		

			
				
package main

import (
    "fmt"
)

func main() {
    fmt.Println("-------------")
    data := []int{1,2,3,5,3,6,2,3}
    s1 := data[6:]//23
    s2 := data[:3]//123
    fmt.Println(s...

			
		

	





	

		

			

				
					
线上问题排查-golang使用json进行对象copy

				
			

			

				

					weixin_42854904的博客
				

				

					06-19
					
					465
					
				

			

		

		

			
				
第一步操作完成,经验证机器可以正常运行,借助gops导出cpu运行图和内存消耗情况



执行上述两个命令后,其会生成文件在tmp目录下


内存的火焰图如下

cpu的火焰图如下
通过对火焰图的分析,可以明显的看到json.Marshal 和 json.Unmarshal 有明显的占用问题。跟着火焰图去找寻调用此处的该方法,定位到此处就不列出runtime.Context对象的具体情况了,你可以理解为里面多处指针,多处切片。反正就是结构体很大 【PS:改天针对大结构体出个压测结果】发现问题后更换如下代码进

			
		

	





	

		

			

				
					
Golang 数组拷贝是值拷贝

				
			

			

				

					CHEENE
				

				

					09-22
					
					1619
					
				

			

		

		

			
				
Golang 数组拷贝是值拷贝，两个的地址不相同，内容相同
	var ar1 [5]string
	ar2 := [5]string{"Red"}
	ar1 = ar2
	fmt.Printf("%p, %p, %+v\n", &ar1, &ar2, ar1 == ar2) // 0xc0000b2000, 0xc0000b2050, true




			
		

	





	

		

			

				
					
Go语言如何深度拷贝对象

				
			

			

				

					weixin_34111790的博客
				

				

					12-11
					
					131
					
				

			

		

		

			
				
2019独角兽企业重金招聘Python工程师标准>>>   
                                        
         ...

			
		

	





	

		

			

				
					
golang中数组和切片的区别

					
最新发布

				
			

			

				

					03-14
				

			

		

		

			
				
<think>好的，我现在需要回答用户关于Golang中数组和切片区别的问题。首先，我得回忆一下自己之前学过的相关知识，并结合用户提供的引用内容来整理答案。

用户给出的引用资料挺多的，我需要仔细看看每个引用提到的内容。比如引用[1]提到切片是对数组的连续片段的引用，属于引用类型，并且数据结构包含指针、长度和容量。引用[3]也类似，说明切片由指针、长度和容量组成，是数组的引用。而引用[5]则提到了如何基于数组创建切片，以及直接创建切片的方法。

接下来，数组和切片的主要区别应该包括它们的定义、内存结构、传递方式、初始化方法以及容量特性等方面。数组是值类型，切片是引用类型，这点可能在函数传参时有不同的表现。比如数组作为参数传递时会复制整个数组，而切片传递的是引用，不会复制底层数组。

然后，我需要考虑用户可能的疑问点，比如长度是否固定、内存管理上的差异，以及nil切片和空切片的区别。引用[4]提到空切片指针不为nil，而nil切片指针为nil，但它们的操作效果一样，这点可能需要解释清楚。

另外，用户提供的示例代码中有数组和切片的声明方式，比如使用make创建切片，或者基于数组生成切片。这些例子可以用来对比两者的不同初始化方法。

在组织内容时，应该分点列出，结构清晰，每个区别点单独说明。同时，要使用用户要求的格式，比如行内公式用$...$，独立公式用$$...$$，但这里可能用不上太多数学公式，所以主要注意中文回答和引用标识的添加。

最后，生成的相关问题需要围绕数组和切片的区别，可能涉及使用场景、性能影响、底层实现等，确保问题有针对性，帮助用户深入理解。

现在需要检查是否遗漏了重要的区别点，比如切片的动态扩容机制，这也是切片和数组的重要不同之处。引用中提到的容量(cap)在切片中是可变的，而数组长度固定，这一点必须强调。

总结下来，回答的结构应该是先概述，再分点详细说明每个区别，引用对应的引用资料，并在末尾添加相关问题。确保语言准确，符合用户的要求。</think>### Golang 数组 vs 切片 区别 解释

在 Golang 中，数组和切片是两种不同的数据结构，主要区别如下：

---

#### 1. **定义与类型**
- **数组（Array）**  
  数组是**值类型**，长度固定，声明时必须指定长度。例如：  
  ```go
  var arr [3]int // 长度为3的整型数组
  ```
- **切片（Slice）**  
  切片是**引用类型**，基于数组实现，长度可变。其底层数据结构包含三个字段：  
  ```go
  type slice struct {
      array unsafe.Pointer // 指向底层数组的指针[^1][^3]
      len   int           // 当前元素个数
      cap   int           // 容量（cap ≥ len）
  }
  ```

---

#### 2. **内存分配与传递**
- **数组**  
  - 赋值或传参时会**复制整个数组**，内存开销较大。  
  - 示例：  
    ```go
    a := [2]int{1, 2}
    b := a  // b是a的完整副本
    ```
- **切片**  
  - 赋值或传参时仅传递**引用**（指针、长度、容量），底层数组共享。  
  - 示例：  
    ```go
    s1 := []int{1, 2}
    s2 := s1  // s2与s1共享底层数组
    ```

---

#### 3. **初始化方式**
- **数组**  
  显式指定长度，元素类型和长度共同决定数组类型：  
  ```go
  arr1 := [2]int{1, 2}  // 长度为2的数组
  arr2 := [...]int{1, 2} // 编译器推断长度[^5]
  ```
- **切片**  
  可通过多种方式创建：  
  - 基于数组截取：  
    ```go
    array := [5]int{1,2,3,4,5}
    slice := array[1:3]  // 包含元素2,3，容量为4[^5]
    ```
  - 直接创建：  
    ```go
    s1 := make([]int, 2, 4) // 长度2，容量4[^1]
    s2 := []int{1, 2}       // 自动初始化底层数组
    ```

---

#### 4. **容量与动态扩容**
- **数组**  
  长度固定，无法扩容。
- **切片**  
  - 容量（`cap`）表示底层数组可容纳的元素上限。  
  - 当切片长度超过容量时，会触发动态扩容（通常按 2 倍容量扩展）[^3]。  
  - 示例：  
    ```go
    s := []int{1, 2}
    s = append(s, 3)  // 容量不足时扩容
    ```

---

#### 5. **空值与 nil**
- **数组**  
  无 `nil` 状态，始终有固定长度。
- **切片**  
  - `nil` 切片：指针为 `nil`，长度和容量为 0。  
  - 空切片：指针非 `nil`（如 `make([]int, 0)`），但行为和 `nil` 切片一致[^4]。  
  - 示例：  
    ```go
    var s1 []int      // nil切片
    s2 := []int{}     // 空切片
    ```

---

#### 6. **应用场景**
- **数组**  
  适合固定长度、无需修改的场景（如配置表）。  
- **切片**  
  适合动态数据集合（如读取文件内容、网络流处理）。

---

### 性能与注意事项
- **数组**的复制开销大，需谨慎用于函数参数传递。  
- **切片**通过引用共享底层数组，修改切片可能影响其他引用。  
- 使用 `append` 时需注意潜在的**内存重新分配**问题。

---

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值