golang中数组与切片的区别详析

目录

• 一. Go 切片和 Go 数组定义
• 二.切片与数组的区别
• 三. 切片使用
• 总结

一. Go 切片和 Go 数组定义

Go 切片:又称动态数组，它实际是基于数组类型做的一层封装。

Go 数组:数组是内置(build-in)类型,是一组同类型数据的集合，它是值类型，通过从 0 开始的下标索引访问元素值。在初始化后长度是固定的，无法修改其长度。当作为方法的参数传入时将复制一份数组而不是引用同一指针。数组的长度也是其类型的一部分，通过内置函数 len(array)获取其长度。

二.切片与数组的区别

Go 数组与像 C/C++等语言中数组略有不同：

1. Go 中的数组是值类型，换句话说，如果你将一个数组赋值给另外一个数组，那么，实际上就是将整个数组拷贝一份。因此，在 Go 中如果将数组作为函数的参数传递的话，那效率就肯定没有传递指针高了。

2. 数组的长度也是类型的一部分，这就说明[10]int和[20]int不是同一种数据类型。并且Go 语言中数组的长度是固定的，且不同长度的数组是不同类型，这样的限制带来不少局限性。

3. 而切片则不同，切片（slice）是一个拥有相同类型元素的可变长序列，可以方便地进行扩容和传递，实际使用时比数组更加灵活，这也正是切片存在的意义。而且切片是引用类型，因此在当传递切片时将引用同一指针，修改值将会影响其他的对象。

三. 切片使用

切片定义方式

  var a []int                    //nil切片，和nil相等，一般用来表示一个不存在的切片
   var b []int{}                //空切片，和nil不相等，一般用来表示一个空的集合
   var c []int{1, 2, 3}        //有3个元素的切片，len和cap都为3
   var d = c[:2]                //有2个元素的切片，len为2，cap为3
   var e = c[:2:cap(c)]        //有2个元素的切片，len为2，cap为3开发者_C学习
   var f = c[:0]                //有0个元素的切片，len为0，cap为3
   var g = make([http://www.devze.com]int, 3)        //创建一个切片，len和cap均为3
   var h = make([]int, 3, 6)    //创建一个切片，len为3，cap为5
   var i = make([]int, 0, 3)    //创建一个切片，len为0，cap为3

从数组中切取切片

数组和切片是紧密相连的。切片可以用来访问数组的部分或全部元素，而这个数组称为切片的底层数组。切片的指针指向数组第一个可以从切片中访问的元素，这个元素并不一定是数组的第一个元素。

一个底层数组可以对应多个切片，这些切片可以引用数组的任何位置，彼此之前的元素可以重叠。

slice 操作符 s[i:j] 创建了一个新的 slice，这个新的 slice 引用了 s 中从 i 到 j-1 索引位置的所有元素。

如果表达式省略了 i，那么默认是s[0:j]；如果省略了 j，默认是s[i:len(s)]；

  //创建一个数组
  months := [...]string{1:"January", /*...*/, 12: "December"}
  Q2 := months[4:7]
  summer := months[6:9]
  fmt.Println(Q2)                //["April" "May" "June"]
  fmt.Println(summer)            //["June" "July" "Auandroidgust"]

月份名称字符串数组与其对应的两个元素重叠的 slice 图示

注意：切片与原数组或切片共享底层空间，修改切片会影响原数组或切片

迭代切片

切片可以用 range 迭代，但是要注意：如果只用一个值接收 range，则得到的只是切片的下标，用两个值接收 range，则得到的才是下标和对应的值。

  //使用一个值接收range, 则得到的是切片的下标
   for i := range months {
       fmt.Println(i)        //返回下标 0 1 ... 12
   }
   //使用两个值接收range，则得到的是下标和对应的值
   for i, v := range months {
       fmt.Println(i, v)     //返回下标0 1 ... 12 和 值 "" "January" ... "December"
  VirmHkm }

切片拷贝

使用copy内置函数拷贝两个切片时，会将源切片的数据逐个拷贝到目的切片指向的数组中，拷贝数量取两个切片的最小值。

例如长度为 10 的切片拷贝到长度为 5 的切片时，将拷贝 5 个元素。也就是说，拷贝过程中不会发生扩容。

copy 函数有返回值，它返回实际上复制的元素个数，这个值就是两个 slice 长度的较小值。

切片扩容-append 函数

//通过append()函数可以在切片的尾部追加 N 个元素
  var a []int
  a = append(a, 1)                    // 追加一个元素
  a = append(a, 1, 2, 3)                // 追加多个元素
  a = append(a, []int{1, 2, 3}...)    // 追加一个切片，注意追加切片时后面要加...
//使用 append()函数也可以在切片头部添加元素
  a = append([]int{0}, a...)            // 在开头添加一个元素
  a = append([]int{1, 2, 3}, a...)    // 在开头添加一个切片

注:从头部添加元素会引起内存的重分配，导致已有元素全部复制一次。因此从头部添加元素的开销要比从尾部添加元素大很多

//通过 append()函数链式操作从中间插入元素
  a = append(a[:i], append([]int{x}, a[i:]...)...)        //在第i个位置上插入x
  a = append(a[:i], append([]int{1, 2, 3}, a[i:]...)...)    //在第i个位置上插入切片

使用链式操作在插入元素，在内层 append 函数中会创建一个临式切片，然后将a[i:]内容复制到新创建的临式切片中，再将临式切片追加至a[:i]中。

通过 append()和 copy()函数组合从中间插入元素

使用这种方式可以避免创建过程中间的临式切片，也可以做到从中间插入元素

  //中间插入一个元素
  a = append(a, 0)            //切片扩展一个空间
  copy(a[i+1:], a[i:])        //a[i:]向后移动一个位置
  a[i] = x                    //设置新添加的元素
  //中间插入多个元素
  a = append(a, x...)            //为x切片扩展足够的空间
  copy(a[i+len(x):], a[i:])    //a[i:]向后移动len(x)个位置
  copy(a[i:], x)                //复制新添加的切片

使用此方式虽然稍显复杂，但是可以减少创建中间临时切片的开销。

删除元素

很遗憾，Go 语言中并没有提供直接删除指定位置元素的方式。不过根据切片的性质，我们可以通过巧妙的拼接切片来达到删除指定数据的目的。

a = []int{1, 2, 3}
//删除尾部元素
phpa = a[:len(a) - 1]                //删除尾部一个元素
a = a[:len(a) - N]                //删除尾部N个元素
//删除头部元素
a = [1:]                        //删除开头1个元素
a = [N:]                        //删除开头N个元素
//删除中间元素
a = append(a[:i],android a[i+1:]...)    //删除中间一个元素
a = append(a[:i], a[i+N:]...)    //删除中间N个元素

总结

到此这篇关于golang中数组与切片区别的文章就介绍到这了,更多相关go数组与切片区别内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！