Go-Slice

2024-09-04 21:58
文章标签 go slice

本文主要是介绍Go-Slice，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

要点

  • 一个区间：[low:high]
  • 两个概念：length, capability
  • 三个函数：make(), append(), copy()

概念

Array是在声明的时候都确定了长度，之后不可更改。Slice和数组类似，也是表示一个有序元素，但这个序列的长度可变。

在Go中，Slice序列中各元素的数据类型必须一致，因为在声明slice的时候即要指定类型。

可以在Python中找到Slice，和Go的Slice基本上是一致的语义和用法。Slice中文通常被译为切片，大抵是因为可以从一个序列中存取指定的某一部分。下面是Collins词典中对于slice的解释，有助于了解该词的含义：

  • N-COUNT (指食物切下的)片，薄片 A slice of bread, meat, fruit, or other food is a thin piece that has been cut from a larger piece. 语法信息

  • VERB 将…切成薄片 If you slice bread, meat, fruit, or other food, you cut it into thin pieces.

在第一次接触Python的slice的时候，对于这个slice或切片，觉得很是怪异，因为在C/C++、Java中还没有对应的术语。——虽然substr()的功用和slice有些相似，但显然slice的用法更加简洁和灵活，更显脚本语言的本色。

以上都是废话，下面给出示例。

声明&赋值

package main
import "fmt"/*
D:\examples>go run helloworld.go
values[0]=1
values[1]=2
values[2]=3
values[3]=4
values[4]=5D:\examples>
*/
func main() {var values []int // (1)values = make([]int, 5) // (2)for i, _ := range values {values[i] = i + 1}for i, item := range values {fmt.Printf("values[%d]=%d\n", i, item)}
}

要点：

  • (1)声明：和数组类似，但是不用指定长度。在这个时候，slice的长度为0，所以还不直接放数据。
  • (2)分配存储空间：调用内置make()函数为slice分配存储空间。
  • 接下来的存取则和普通的数组语法一致。

可以看到，slice和数组非常类似的，即内部存储是有序的数组形式，访问也是索引方式，仅仅在于其动态长度特性。如此，slice又和C++ STL的vector类似，不用指定长度。vector可以声明最大capability，可以动态改变长度。此为，slice和Java的ArrayList也是类似的。所以，通俗的讲，slice也可看做列表。——Go有一个list package，后面会提到。

用Array给slice赋值

package main
import "fmt"/*
D:\examples>go run helloworld.go
the_slice[0]=3
the_slice[1]=4
the_slice[2]=5D:\examples>
*/
func main() {the_array := [5]int {1, 2, 3, 4, 5} the_slice := the_array[2:5]for i, item := range the_slice {fmt.Printf("the_slice[%d]=%d\n", i, item)}
}

要点：
- 直接用[low:high]这种方式定义一个slice
- 这里的[low:high]，用数学集合的方式来讲，就是[low, high)，即左闭右开。
- 这种创建slice的方式，不需要make()函数。

[low:high]

Go的[low:high]和Python的语法一致。要点：
- [:]等价于[0:len(array)]
- [:n]等价于[0:n]
- [n:]等价于[n:len(array)]

注：别挑战low小于0或high大于len(array)的这种异常。

package main
import "fmt"/*
D:\examples>go run helloworld.go
[:] elements:
the_slice[0]=1
the_slice[1]=2
the_slice[2]=3
the_slice[3]=4
the_slice[4]=5
[2:] elements:
the_slice[0]=3
the_slice[1]=4
the_slice[2]=5
[:4] elements:
the_slice[0]=1
the_slice[1]=2
the_slice[2]=3
the_slice[3]=4
[:4] elements:
the_slice[0]=1
the_slice[1]=2
the_slice[2]=3
the_slice[3]=4
[1:4] elements:
the_slice[0]=2
the_slice[1]=3
the_slice[2]=4
panic: runtime error: slice bounds out of rangegoroutine 1 [running]:
panic(0x49cba0, 0xc04200a040)C:/Go/src/runtime/panic.go:500 +0x1af
main.main()D:/examples/helloworld.go:29 +0x191
exit status 2D:\examples>
*/
func main() {the_array := [5]int {1, 2, 3, 4, 5} the_slice := the_array[:]debug_slice(the_slice, "[:] elements:")debug_slice(the_array[2:], "[2:] elements:")debug_slice(the_array[:4], "[:4] elements:")debug_slice(the_array[:4], "[:4] elements:")debug_slice(the_array[1:4], "[1:4] elements:")// invalid slice index -1 (index must be non-negative)//debug_slice(the_array[-1:40], "[-1:40] elements:")//invalid slice index 40 (out of bounds for 5-element array)//debug_slice(the_array[0:40], "[:40] elements:")//Runtime Errorthe_slice2 := make([]int, 5)debug_slice(the_slice2[0:40], "[:40] elements:")
}func debug_slice(the_slice []int, msg string) {fmt.Println(msg)for i, item := range the_slice {fmt.Printf("the_slice[%d]=%d\n", i, item)}
}

length & capability

先给出示例代码：

package main
import "fmt"/*
D:\examples>go run helloworld.go
default values of slice:
the_slice[0]=0
the_slice[1]=0
the_slice[2]=0
the_slice[3]=0
the_slice[4]=0D:\examples>
*/
func main() {var the_slice []int;the_slice = make([]int, 5, 10)debug_slice(the_slice, "default values of slice:")
}func debug_slice(the_slice []int, msg string) {fmt.Println(msg)for i, item := range the_slice {fmt.Printf("the_slice[%d]=%d\n", i, item)}
}

在make()的时候，5表示长度为5个元素，此即length的概念；10表示整个容器的长度，即capability的概念。在这里，slice可以放10个元素，但目前只放了5个元素。make()的时候会自动初始化这5个元素为缺省值(???)。

在 <> Ch4 Composite Types, P88 有如下的描述：

make([]T, len)
make([]T, len, capability) // same as make([]T capability)[:len]

也就是说， 对于第一种情形，make直接创建长度为len的数组，并返回这个数组的元素。对于第二种情形，make会创建长度为capability的数组，但仅仅返回前面的len个元素。显然，返回的slice的长度就是len。

因为slice是依存于数组数据结构而存在，虽然第二种情形下slice的长度为len，但在添加新的元素的时候，只要不超过capability，就无须动态创建新的数组，而直接把要添加的元素放在slice已有元素的后面。

slice的length和capability的概念，和C++ STL vector对应的含义是一致的。——python的slice/list貌似没用这个概念。。。不确定。。。

当capability不至于放新的原始的时候，slice对象就会重新创建一个数组，并把原来的数据拷贝到新的数组里。

可以认为，capability对于功能无影响，但对于程序的性能会有影响。如果设置不当，会因为频繁的数据拷贝而降低性能。

TODO: 暂不清楚Go是否有OO的ctor的概念，如果有的话，用slice存放OO对象+ctor打印，会比较好的说明capability的作用。

对于以上解读，再给出一个例子：

package main
import "fmt"/*
D:\examples>go run helloworld.go
default value of slice:
the_slice[0]=0
the_slice[1]=0
the_slice[2]=0
slice:
the_slice[0]=1
the_slice[1]=2
the_slice[2]=3
the_slice[3]=4
the_slice[4]=5
the_slice[5]=6D:\examples>
*/
func main() {the_array := [6]int {1,2,3,4,5,6}the_slice := make([]int, 3, 5)debug_slice(the_slice, "default value of slice:")the_slice = the_array[:]debug_slice(the_slice, "slice:")
}func debug_slice(the_slice []int, msg string) {fmt.Println(msg)for i, item := range the_slice {fmt.Printf("the_slice[%d]=%d\n", i, item)}
}

append

append()函数是在slice后面添加元素。同前面对capability的描述，append()的时候可能涉及到数组的动态创建。

package main
import "fmt"/*
D:\examples>go run helloworld.go
slice1: 1       2       3
slice2: 1       2       3       4       5
slice1: 1       2       3       4       5       6
slice2: 1       2       3       4       5D:\examples>
*/
func main() {the_slice1 := []int {1,2,3}the_slice2 := append(the_slice1, 4, 5)debug_slice(the_slice1, "slice1:")debug_slice(the_slice2, "slice2:")the_slice1 = append(the_slice1, 4, 5, 6)debug_slice(the_slice1, "slice1:")debug_slice(the_slice2, "slice2:")//the_slice1.append undefined (type []int has no field or method append)//the_slice1.append(7)
}func debug_slice(the_slice []int, msg string) {fmt.Print(msg, "\t")for _, item := range the_slice {fmt.Print(item, "\t")}fmt.Println()
}

不清楚，为什么不支持.append()这种语法，而是append(slice, elements …)。

copy

copy()函数是把一个slice的“所有”元素拷贝到另外一个slice中。——是拷贝，而不是追加(append)。需要注意的是：如果目标slice的长度小于源slice的长度，那么就不会拷贝源slice的所有原始。

package main
import "fmt"/*
D:\examples>go run helloworld.go
slice1: 1       2       3
slice2: 0       0
slice3: 10      0       0       0
slice1: 1       2       3
slice2: 1       2
slice3: 1       2       3       0D:\examples>
*/
func main() {slice1 := []int {1,2,3}slice2 := make([]int, 2)slice3 := make([]int, 4)slice3[0] = 10debug_slice(slice1, "slice1:")debug_slice(slice2, "slice2:")debug_slice(slice3, "slice3:")copy(slice2, slice1)copy(slice3, slice1)debug_slice(slice1, "slice1:")debug_slice(slice2, "slice2:")debug_slice(slice3, "slice3:")
}func debug_slice(the_slice []int, msg string) {fmt.Print(msg, "\t")for _, item := range the_slice {fmt.Print(item, "\t")}fmt.Println()
}

附 append documentation

func append

func append(slice []Type, elems ...Type) []Type

The append built-in function appends elements to the end of a slice. If it has sufficient capacity, the destination is resliced to accommodate the new elements. If it does not, a new underlying array will be allocated. Append returns the updated slice. It is therefore necessary to store the result of append, often in the variable holding the slice itself:

slice = append(slice, elem1, elem2)
slice = append(slice, anotherSlice...)

As a special case, it is legal to append a string to a byte slice, like this:

slice = append([]byte("hello "), "world"...)

附 copy documentation

func copy

func copy(dst, src []Type) int

The copy built-in function copies elements from a source slice into a destination slice. (As a special case, it also will copy bytes from a string to a slice of bytes.) The source and destination may overlap. Copy returns the number of elements copied, which will be the minimum of len(src) and len(dst).

这篇关于Go-Slice的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1137147。

相关文章

go中空接口的具体使用

go中空接口的具体使用

《go中空接口的具体使用》空接口是一种特殊的接口类型,它不包含任何方法,本文主要介绍了go中空接口的具体使用,具有一定的参考价值,感兴趣的可以了解一下... 目录接口-空接口1. 什么是空接口？2. 如何使用空接口？第一，第二，第三，3. 空接口几个要注意的坑坑1：坑2：坑3：接口-空接口1. 什么是空接
阅读更多...
利用Go语言开发文件操作工具轻松处理所有文件

利用Go语言开发文件操作工具轻松处理所有文件

《利用Go语言开发文件操作工具轻松处理所有文件》在后端开发中,文件操作是一个非常常见但又容易出错的场景,本文小编要向大家介绍一个强大的Go语言文件操作工具库,它能帮你轻松处理各种文件操作场景... 目录为什么需要这个工具？核心功能详解1. 文件/目录存javascript在性检查2. 批量创建目录3. 文件
阅读更多...
Go语言中最便捷的http请求包resty的使用详解

Go语言中最便捷的http请求包resty的使用详解

《Go语言中最便捷的http请求包resty的使用详解》go语言虽然自身就有net/http包,但是说实话用起来没那么好用,resty包是go语言中一个非常受欢迎的http请求处理包,下面我们一起来学... 目录安装一、一个简单的get二、带查询参数三、设置请求头、body四、设置表单数据五、处理响应六、超
阅读更多...
Golang基于内存的键值存储缓存库go-cache

Golang基于内存的键值存储缓存库go-cache

《Golang基于内存的键值存储缓存库go-cache》go-cache是一个内存中的key:valuestore/cache库,适用于单机应用程序,本文主要介绍了Golang基于内存的键值存储缓存库... 目录文档安装方法示例1示例2使用注意点优点缺点go-cache 和 Redis 缓存对比1）功能特性
阅读更多...
Go 1.23中Timer无buffer的实现方式详解

Go 1.23中Timer无buffer的实现方式详解

《Go1.23中Timer无buffer的实现方式详解》在Go1.23中,Timer的实现通常是通过time包提供的time.Timer类型来实现的,本文主要介绍了Go1.23中Timer无buff... 目录Timer 的基本实现无缓冲区的实现自定义无缓冲 Timer 实现更复杂的 Timer 实现总结在
阅读更多...
Go使用pprof进行CPU,内存和阻塞情况分析

Go使用pprof进行CPU,内存和阻塞情况分析

《Go使用pprof进行CPU,内存和阻塞情况分析》Go语言提供了强大的pprof工具,用于分析CPU、内存、Goroutine阻塞等性能问题,帮助开发者优化程序,提高运行效率,下面我们就来深入了解下... 目录1. pprof 介绍2. 快速上手：启用 pprof3. CPU Profiling：分析 C
阅读更多...
使用Go语言开发一个命令行文件管理工具

使用Go语言开发一个命令行文件管理工具

《使用Go语言开发一个命令行文件管理工具》这篇文章主要为大家详细介绍了如何使用Go语言开发一款命令行文件管理工具,支持批量重命名,删除,创建,移动文件,需要的小伙伴可以了解下... 目录一、工具功能一览二、核心代码解析1. 主程序结构2. 批量重命名3. 批量删除4. 创建文件/目录5. 批量移动三、如何安
阅读更多...
Go路由注册方法详解

Go路由注册方法详解

《Go路由注册方法详解》Go语言中,http.NewServeMux()和http.HandleFunc()是两种不同的路由注册方式,前者创建独立的ServeMux实例,适合模块化和分层路由,灵活性高... 目录Go路由注册方法1. 路由注册的方式2. 路由器的独立性3. 灵活性4. 启动服务器的方式5.
阅读更多...
Go语言中三种容器类型的数据结构详解

Go语言中三种容器类型的数据结构详解

《Go语言中三种容器类型的数据结构详解》在Go语言中,有三种主要的容器类型用于存储和操作集合数据：本文主要介绍三者的使用与区别,感兴趣的小伙伴可以跟随小编一起学习一下... 目录基本概念1. 数组（Array）2. 切片（Slice）3. 映射（Map）对比总结注意事项基本概念在 Go 语言中，有三种主要
阅读更多...
Go Mongox轻松实现MongoDB的时间字段自动填充

Go Mongox轻松实现MongoDB的时间字段自动填充

《GoMongox轻松实现MongoDB的时间字段自动填充》这篇文章主要为大家详细介绍了Go语言如何使用mongox库,在插入和更新数据时自动填充时间字段,从而提升开发效率并减少重复代码,需要的可以... 目录前言时间字段填充规则Mongox 的安装使用 Mongox 进行插入操作使用 Mongox 进行更
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2