资讯

精准传达 • 有效沟通

从品牌网站建设到网络营销策划，从策略到执行的一站式服务

网站建设 >

查看其它板块

go语言切片怎么生成

本篇内容介绍了“go语言切片怎么生成”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

洪雅ssl适用于网站、小程序/APP、API接口等需要进行数据传输应用场景，ssl证书未来市场广阔！成为成都创新互联公司的ssl证书销售渠道，可以享受市场价格4-6折优惠！如果有意向欢迎电话联系或者加微信：028-86922220（备注：SSL证书合作）期待与您的合作！

在go语言中，切片（slice）是对数组的一个连续片段的引用，所以切片是一个引用类型，这个片段可以是整个数组，也可以是由起始和终止索引标识的一些项的子集；切片的内存分布是连续的，所以可以把切片当做一个大小不固定的数组。切片有三个字段的数据结构：指向底层数组的指针、切片访问的元素的个数（即长度）和切片允许增长到的元素个数（即容量）。

切片（slice）是对数组的一个连续片段的引用，所以切片是一个引用类型（因此更类似于 C/C++ 中的数组类型，或者 Python 中的 list 类型），这个片段可以是整个数组，也可以是由起始和终止索引标识的一些项的子集，需要注意的是，终止索引标识的项不包括在切片内。

Go语言中切片的内部结构包含地址、大小和容量，切片一般用于快速地操作一块数据集合，如果将数据集合比作切糕的话，切片就是你要的“那一块”，切的过程包含从哪里开始（切片的起始位置）及切多大（切片的大小），容量可以理解为装切片的口袋大小，如下图所示。

go语言切片怎么生成
图：切片结构和内存分配

切片的内存分布是连续的，所以你可以把切片当做一个大小不固定的数组。

切片有三个字段的数据结构，这些数据结构包含 Go 语言需要操作底层数组的元数据，这 3 个字段分别是指向底层数组的指针、切片访问的元素的个数（即长度）和切片允许增长到的元素个数（即容量）。后面会进一步讲解长度和容量的区别。

go语言切片怎么生成

从数组或切片生成新的切片

切片默认指向一段连续内存区域，可以是数组，也可以是切片本身。

从连续内存区域生成切片是常见的操作，格式如下：

slice [开始位置 : 结束位置]

语法说明如下：

  • slice：表示目标切片对象；

  • 开始位置：对应目标切片对象的索引；

  • 结束位置：对应目标切片的结束索引。

从数组生成切片，代码如下：

var a  = [3]int{1, 2, 3}
fmt.Println(a, a[1:2])

其中 a 是一个拥有 3 个整型元素的数组，被初始化为数值 1 到 3，使用 a[1:2] 可以生成一个新的切片，代码运行结果如下：

[1 2 3]  [2]

其中 [2] 就是 a[1:2] 切片操作的结果。

从数组或切片生成新的切片拥有如下特性：

  • 取出的元素数量为：结束位置 - 开始位置；

  • 取出元素不包含结束位置对应的索引，切片最后一个元素使用 slice[len(slice)] 获取；

  • 当缺省开始位置时，表示从连续区域开头到结束位置；

  • 当缺省结束位置时，表示从开始位置到整个连续区域末尾；

  • 两者同时缺省时，与切片本身等效；

  • 两者同时为 0 时，等效于空切片，一般用于切片复位。

根据索引位置取切片 slice 元素值时，取值范围是（0～len(slice)-1），超界会报运行时错误，生成切片时，结束位置可以填写 len(slice) 但不会报错。

下面通过实例来熟悉切片的特性。

1) 从指定范围中生成切片

切片和数组密不可分，如果将数组理解为一栋办公楼，那么切片就是把不同的连续楼层出租给使用者，出租的过程需要选择开始楼层和结束楼层，这个过程就会生成切片，示例代码如下：

var highRiseBuilding [30]int
for i := 0; i < 30; i++ {
        highRiseBuilding[i] = i + 1
}
// 区间
fmt.Println(highRiseBuilding[10:15])
// 中间到尾部的所有元素
fmt.Println(highRiseBuilding[20:])
// 开头到中间指定位置的所有元素
fmt.Println(highRiseBuilding[:2])

代码输出如下：

go语言切片怎么生成

代码中构建了一个 30 层的高层建筑，数组的元素值从 1 到 30，分别代表不同的独立楼层，输出的结果是不同的租售方案。

代码说明如下：

  • 第 8 行，尝试出租一个区间楼层。

  • 第 11 行，出租 20 层以上。

  • 第 14 行，出租 2 层以下，一般是商用铺面。

切片有点像C语言里的指针，指针可以做运算，但代价是内存操作越界，切片在指针的基础上增加了大小，约束了切片对应的内存区域，切片使用中无法对切片内部的地址和大小进行手动调整，因此切片比指针更安全、强大。

2) 表示原有的切片

生成切片的格式中，当开始和结束位置都被忽略时，生成的切片将表示和原切片一致的切片，并且生成的切片与原切片在数据内容上也是一致的，代码如下：

a := []int{1, 2, 3}
fmt.Println(a[:])

a 是一个拥有 3 个元素的切片，将 a 切片使用 a[:] 进行操作后，得到的切片与 a 切片一致，代码输出如下：

[1 2 3]

3) 重置切片，清空拥有的元素

把切片的开始和结束位置都设为 0 时，生成的切片将变空，代码如下：

a := []int{1, 2, 3}
fmt.Println(a[0:0])

代码输出如下：

go语言切片怎么生成

直接声明新的切片

除了可以从原有的数组或者切片中生成切片外，也可以声明一个新的切片，每一种类型都可以拥有其切片类型，表示多个相同类型元素的连续集合，因此切片类型也可以被声明，切片类型声明格式如下：

var name []Type

其中 name 表示切片的变量名，Type 表示切片对应的元素类型。

下面代码展示了切片声明的使用过程：

// 声明字符串切片
var strList []string

// 声明整型切片
var numList []int

// 声明一个空切片
var numListEmpty = []int{}

// 输出3个切片
fmt.Println(strList, numList, numListEmpty)

// 输出3个切片大小
fmt.Println(len(strList), len(numList), len(numListEmpty))

// 切片判定空的结果
fmt.Println(strList == nil)
fmt.Println(numList == nil)
fmt.Println(numListEmpty == nil)

代码输出结果：

go语言切片怎么生成

代码说明如下：

  • 第 2 行，声明一个字符串切片，切片中拥有多个字符串。

  • 第 5 行，声明一个整型切片，切片中拥有多个整型数值。

  • 第 8 行，将 numListEmpty 声明为一个整型切片，本来会在{}中填充切片的初始化元素，这里没有填充，所以切片是空的，但是此时的 numListEmpty 已经被分配了内存，只是还没有元素。

  • 第 11 行，切片均没有任何元素，3 个切片输出元素内容均为空。

  • 第 14 行，没有对切片进行任何操作，strList 和 numList 没有指向任何数组或者其他切片。

  • 第 17 行和第 18 行，声明但未使用的切片的默认值是 nil，strList 和 numList 也是 nil，所以和 nil 比较的结果是 true。

  • 第 19 行，numListEmpty 已经被分配到了内存，但没有元素，因此和 nil 比较时是 false。

切片是动态结构，只能与 nil 判定相等，不能互相判定相等。声明新的切片后，可以使用 append() 函数向切片中添加元素。

使用 make() 函数构造切片

如果需要动态地创建一个切片，可以使用 make() 内建函数，格式如下：

make( []Type, size, cap )

其中 Type 是指切片的元素类型，size 指的是为这个类型分配多少个元素，cap 为预分配的元素数量，这个值设定后不影响 size，只是能提前分配空间，降低多次分配空间造成的性能问题。

示例如下：

a := make([]int, 2)
b := make([]int, 2, 10)

fmt.Println(a, b)
fmt.Println(len(a), len(b))

代码输出如下：

go语言切片怎么生成

其中 a 和 b 均是预分配 2 个元素的切片，只是 b 的内部存储空间已经分配了 10 个，但实际使用了 2 个元素。

容量不会影响当前的元素个数，因此 a 和 b 取 len 都是 2。

温馨提示

使用 make() 函数生成的切片一定发生了内存分配操作，但给定开始与结束位置（包括切片复位）的切片只是将新的切片结构指向已经分配好的内存区域，设定开始与结束位置，不会发生内存分配操作。

切片的使用

切片的使用和数组是一模一样的：

func main() {
    slice1 := []int{1,2,3,4}
    fmt.Println(slice1[1])
}

切片创建切片

切片之所以称为切片，是因为它只是对应底层数组的一部分，看如下所示代码：

func main() {
    slice := []int{10, 20, 30, 40, 50}
    newSlice := slice[1:3]
}

为了说明上面的代码，我们看下面的这张图：
go语言切片怎么生成

第一个切片slice 能够看到底层数组全部5 个元素的容量，不过之后的newSlice 就看不到。对于newSlice，底层数组的容量只有4 个元素。newSlice 无法访问到它所指向的底层数组的第一个元素之前的部分。所以，对newSlice 来说，之前的那些元素就是不存在的。

需要记住的是，现在两个切片共享同一个底层数组。如果一个切片修改了该底层数组的共享部分，另一个切片也能感知到，运行下面的代码：

func main() {
    slice := []int{10, 20, 30, 40, 50}
    newSlice := slice[1:3]

    slice[1] = 200
    fmt.Println(newSlice[0])
}

运行结果如下：

200

切片只能访问到其长度内的元素。试图访问超出其长度的元素将会导致语言运行时异常，比如对上面的newSlice，他只能访问索引为1和2的元素（不包括3），比如：

func main() {
    slice := []int{10, 20, 30, 40, 50}
    newSlice := slice[1:3]

    fmt.Println(newSlice[3])
}

运行代码，控制台会报错：

panic: runtime error: index out of range

goroutine 1 [running]:
main.main()
    E:/go-source/go-arr/main.go:20 +0x11

子切片的容量

我们知道切片可以再生出切片，那么子切片的容量为多大呢？我们来测试一下：

func main() {
    slice := make([]int, 2, 10)
    slice1 := slice[1:2]
    fmt.Println(cap(slice1))
}

控制台打印结果为：

9
9

从结果我们可以推测，子切片的容量为底层数组的长度减去切片在底层数组的开始偏移量，比如在上面的例子中，slice1的偏移值为1，底层数组的大小为10，所以两者相减，得到结果9。

向切片中追加元素

go提供了append方法用于向切片中追加元素，如下所示：

func main() {
    slice := make([]int, 2, 10)
    slice1 := slice[1:2]
    slice2 := append(slice1, 1)
    slice2[0] = 10001
    fmt.Println(slice)
    fmt.Println(cap(slice2))
}

输出结果如下：

[0 10001]
9

此时slice，slice1，slice2共享底层数组，所以只要一个切片改变了某一个索引的值，会影响到所有的切片，还有一点值得注意，就是slice2的容量为9，记住这个值。

为了说明问题，我把例子改为如下所示代码：

func main() {
    slice := make([]int, 2, 10)
    slice1 := slice[1:2]
    slice2 := append(slice1, 1)
    slice2 = append(slice2, 1)
    slice2 = append(slice2, 1)
    slice2 = append(slice2, 1)
    slice2 = append(slice2, 1)
    slice2 = append(slice2, 1)
    slice2 = append(slice2, 1)
    slice2 = append(slice2, 1)
    slice2 = append(slice2, 1)
    slice2 = append(slice2, 1)
    slice2 = append(slice2, 1)
    slice2 = append(slice2, 1)
    slice2[0] = 10001
    fmt.Println(slice)
    fmt.Println(slice1)
    fmt.Println(cap(slice2))
}

此时我们再次打印结果，神奇的事情出现了：

[0 0]
[0]
18

虽然我们改变0位置的值，但是并没有影响到原来的slice和slice1，这是为啥呢？我们知道原始的slice2对应的底层数组的容量为9，经过我们一系列的append操作，原始的底层数组已经无法容纳更多的元素了，此时Go会分配另外一块内存，把原始切片从位置1开始的内存复制到新的内存地址中，也就是说现在的slice2切片对应的底层数组和slice切片对应的底层数组完全不是在同一个内存地址，所以当你此时更改slice2中的元素时，对slice已经来说，一点儿关系都没有。

另外根据上面的打印结果，你也应该猜到了，当切片容量不足的时候，Go会以原始切片容量的2倍建立新的切片，在我们的例子中2*9=18，就是这么粗暴。

如何创建子切片时指定容量

在前面的例子中，我们创建子切片的时候，没有指定子切片的容量，所以子切片的容量和我们上面讨论的计算子切片的容量方法相等，那么我们如何手动指定子切片的容量呢？

在这里我们借用《Go实战》中的一个例子：

func main() {
    source := []string{"Apple", "Orange", "Plum", "Banana", "Grape"}
    slice := source[2:3:4]
    fmt.Println(cap(slice))
}

如果你仔细看的话，上面的子切片的生成方式和普通的切片有所不同，[]里面有三个部分组成，，第一个值表示新切片开始元素的索引位置，这个例子中是2。第二个值表示开始的索引位置（2）加上希望包括的元素的个数（1），2+1 的结果是3，所以第二个值就是3。为了设置容量，从索引位置2 开始，加上希望容量中包含的元素的个数（2），就得到了第三个值4。所以这个新的切片slice的长度为1，容量为2。还有一点大家一定要记住，你指定的容量不能比原先的容量，这里就是source的容量大，加入我们这样设置的话：

func main() {
    source := []string{"Apple", "Orange", "Plum", "Banana", "Grape"}
    slice := source[2:3:10]
    fmt.Println(cap(slice))
}

运行结果如下，报错了，哈哈：

panic: runtime error: slice bounds out of range [::10] with capacity 5

goroutine 1 [running]:
main.main()
    E:/learn-go/slice/main.go:7 +0x1d

迭代切片

关于如何迭代切片，我们可以使用range配置来使用，如下：

func main() {
    slice:=[]int{1,2,4,6}
    for _, value:=range slice{
        fmt.Println(value)
    }
}

关于迭代切片，大家有一点需要注意，就以上面的例子为例，value只是slice中元素的副本，为啥呢？我们来验证这一点：

func main() {
    slice:=[]int{1,2,4,6}
    for index, value:=range slice{
        fmt.Printf("value[%d],indexAddr:[%X],valueAddr:[%X],sliceAddr:[%X]\n",value,&index,&value,&slice[index])
    }
}

控制台打印结果如下：

value[1],indexAddr:[C00000A0B8],valueAddr:[C00000A0D0],sliceAddr:[C000010380]
value[2],indexAddr:[C00000A0B8],valueAddr:[C00000A0D0],sliceAddr:[C000010388]
value[4],indexAddr:[C00000A0B8],valueAddr:[C00000A0D0],sliceAddr:[C000010390]
value[6],indexAddr:[C00000A0B8],valueAddr:[C00000A0D0],sliceAddr:[C000010398]

从上面的结果可以看到index和value的地址始终是不变的，所以它们始终是同一个变量，只是变量引用地址的内容发生了变化，从而验证迭代的时候，只能是切片元素的副本，最后看看sliceAddr代表的地址相隔8个字节，因为在64位系统上，每一个int类型的大小为8个字节。

函数间传递切片

函数间传递切片，也是以值的方式传递的，但是你还记得这篇博文开头给出的切片的布局么？
go语言切片怎么生成
切片由三个部分组成，包括指向底层数组的指针，当前切片的长度，当前切片的容量，所以切片本身并不大，我们来测试一个切片的大小：

func main() {
    slice:=[]int{1,2,4,6}
    fmt.Println(unsafe.Sizeof(slice))
}

测试结果为：

24

也就是这个slice切片的大小为24字节，所以当切片作为参数传递的时候，几乎没有性能开销，还有很重要的一点，参数生成的副本的地址指针和原始切片的地址指针是一样的，因此，如果你在函数里面修改了切片，那么会影响到原始的切片，我们来验证这点：

func main() {
    slice:=[]int{1,2,4,6}
    handleSlice(slice)
    fmt.Println(slice)
}

打印结果：

[100 2 4 6]

“go语言切片怎么生成”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注创新互联网站，小编将为大家输出更多高质量的实用文章！


网站标题：go语言切片怎么生成
文章起源：http://www.cdkjz.cn/article/jecoee.html
返回首页 了解更多建站资讯

相关资讯

多年建站经验

多一份参考，总有益处

联系快上网，免费获得专属《策划方案》及报价

咨询相关问题或预约面谈，可以通过以下方式与我们联系

大客户专线   成都：13518219792   座机：028-86922220

在线咨询 提交需求
友情链接 交换友情链接
成都服装定制国泰民安消防成都定制网站温江网站设计抖音短视频关键词优化成都柴油发电机组重庆外贸网站建设医药医疗网站建设方案鑫友邦火锅桌

成都网站建设公司地址：成都市青羊区太升南路288号锦天国际A座10层 建设咨询028-86922220

成都快上网科技有限公司-四川网站建设设计公司 | 蜀ICP备19037934号 Copyright 2020,ALL Rights Reserved cdkjz.cn | 成都网站建设 | © Copyright 2020版权所有.

专家团队为您提供成都网站建设,成都网站设计,成都品牌网站设计,成都营销型网站制作等服务,成都建网站就找快上网！ | 成都网站建设哪家好？ | 网站建设地图