本文主要介绍go语言中切片slice的增删修改操作。如果我.._IT教育论坛
&>&&>&&>&&>&《Golang中slice切片的修改操作》评论
《Golang中slice切片的修改操作》评论
本文主要介绍go语言中切片slice的增删修改操作。如果我们需要往切片中追加元素，可以使用内置的append()函数。这个函数接受一个需要被追加的切片，以及一个或者多个需要被追加的元素。如果我们需要往一个切片中追加另一个切片，那么我们必须使用...操作符来告诉Go语言将被添加进来的切片当成多个元素。例：s:=[]string{"A","B","C","D","E","F","G"}t:=[]string{"K","L","M","N"}u:=[]string{"m","n","o","p","q","r"}s=append(s,"h","i",".....&&
本帖标题：
本帖地址：
注意：本论坛的任何言论仅代表发言者个人的观点，与希赛网立场无关。请对您的言论负责，遵守中华人民共和国有关法律、法规。如果您的帖子违反希赛网论坛规则，将立即删除。
&&&&&&&&&&&&
希赛网 版权所有 & &&Golang Array 数组 和 Slice 切片
一 数组简介
数组是内置(build-in)类型,是一组同类型数据的集合，它是值类型，通过从0开始的下标索引访问元素值。在初始化后长度是固定的，无法修改其长度。当作为方法的参数传入时将复制一份数组而不是引用同一指针。数组的长度也是其类型的一部分，通过内置函数len(array)获取其长度。
注意：和C中的数组相比，又是有一些不同的
1. Go中的数组是值类型，换句话说，如果你将一个数组赋值给另外一个数组，那么，实际上就是将整个数组拷贝一份
2. 如果Go中的数组作为函数的参数，那么实际传递的参数是一份数组的拷贝，而不是数组的指针。这个和C要区分开。因此，在Go中如果将数组作为函数的参数传递的话，那效率就肯定没有传递指针高了。
3. array的长度也是Type的一部分，这样就说明[10]int和[20]int是不一样的。array的结构用图示表示是这样的：
len表示数组的长度，后面的int储存的是实际数据
二 数组初始化
初始化数组的初始化有多种形式,查看示例代码
[5] int {1,2,3,4,5}
长度为5的数组，其元素值依次为：1，2，3，4，5
[5] int {1,2}
长度为5的数组，其元素值依次为：1，2，0，0，0 。在初始化时没有指定初值的元素将会赋值为其元素类型int的默认值0,string的默认值是""
[...] int {1,2,3,4,5}
长度为5的数组，其长度是根据初始化时指定的元素个数决定的
[5] int { 2:1,3:2,4:3}
长度为5的数组，key:value,其元素值依次为：0，0，1，2，3。在初始化时指定了2，3，4索引中对应的值：1，2，3
[...] int {2:1,4:3}
长度为5的数组，起元素值依次为：0，0，1，0，3。由于指定了最大索引4对应的值3，根据初始化的元素个数确定其长度为5赋值与使用
三 数组的访问
数组通过下标访问元素，可修改其元素值
arr :=[...] int {1,2,3,4,5}
arr[4]=arr[1]+len(arr)
//arr[4]=2+5
通过for遍历数组元素
arr := [5]int{5, 4, 3}
for index, value := range arr {
fmt.Printf("arr[%d]=%d \n", index, value)
for index := 0; index < len(arr); index&#43;&#43; {
fmt.Printf("arr[%d]=%d \n", index, arr[index])
数组是&#20540;类型，将一个数组赋&#20540;给另一个数组时将复制一份新的元素
arr2 := [5]int{1, 2}
arr5 := arr2
arr5[0] = 5
arr2[4] = 2
fmt.Printf(" arr5= %d \n arr2=%d \n arr5[0]==arr2[0]= %s \n", arr5, arr2, arr5[0] == arr2[0])
arr5=[5 2 0 0 0]
arr2=[1 2 0 0 2]
arr5[0]==arr2[0]= false
四 切片简介
数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型Slices切片(“动态数组"),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。切片中有两个概念：一是len长度，二是cap容量，长度是指已经被赋过&#20540;的最大下标&#43;1，可通过内置函数len()获得。容量是指切片目前可容纳的最多元素个数，可通过内置函数cap()获得。切片是引用类型，因此在当传递切片时将引用同一指针，修改&#20540;将会影响其他的对象。
五 切片的使用
Slice并不是真正意义上的动态数组，而是一个引用类型。slice总是指向一个底层array,slice的声明也可以像array一样，只是不需要长度。
// 和声明array一样，只是少了长度
var fslice []int
接下来我们可以声明一个slice，并初始化数据，如下所示：
slice := []byte {'a', 'b', 'c', 'd'}
slice可以从一个数组或一个已经存在的slice中再次声明。slice通过array[i:j]来获取，其中i是数组的开始位置，j是结束位置，但不包含array[j]，它的长度是j-i。
// 声明一个含有10个元素元素类型为byte的数组
var ar = [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
// 声明两个含有byte的slice
var a, b []byte
// a指向数组的第3个元素开始，并到第五个元素结束，
a = ar[2:5]
//现在a含有的元素: ar[2]、ar[3]和ar[4]
// b是数组ar的另一个slice
b = ar[3:5]
// b的元素是：ar[3]和ar[4]
注意slice和数组在声明时的区别：声明数组时，方括号内写明了数组的长度或使用...自动计算长度，而声明slice时，方括号内没有任何字符。
它们的数据结构如下所示
slice有一些简便的操作
slice的默认开始位置是0，ar[:n]等价于ar[0:n]slice的第二个序列默认是数组的长度，ar[n:]等价于ar[n:len(ar)]如果从一个数组里面直接获取slice，可以这样ar[:]，因为默认第一个序列是0，第二个是数组的长度，即等价于ar[0:len(ar)]
下面这个例子展示了更多关于slice的操作：
// 声明一个数组
var array = [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
// 声明两个slice
var aSlice, bSlice []byte
// 演示一些简便操作
aSlice = array[:3] // 等价于aSlice = array[0:3] aSlice包含元素: a,b,c
aSlice = array[5:] // 等价于aSlice = array[5:10] aSlice包含元素: f,g,h,i,j
aSlice = array[:]
// 等价于aSlice = array[0:10] 这样aSlice包含了全部的元素
// 从slice中获取slice
aSlice = array[3:7]
// aSlice包含元素: d,e,f,g，len=4，cap=7
bSlice = aSlice[1:3] // bSlice 包含aSlice[1], aSlice[2] 也就是含有: e,f
bSlice = aSlice[:3]
// bSlice 包含 aSlice[0], aSlice[1], aSlice[2] 也就是含有: d,e,f
bSlice = aSlice[0:5] // 对slice的slice可以在cap范围内扩展，此时bSlice包含：d,e,f,g,h
bSlice = aSlice[:]
// bSlice包含所有aSlice的元素: d,e,f,g
slice是引用类型，所以当引用改变其中元素的&#20540;时，其它的所有引用都会改变该&#20540;，例如上面的aSlice和bSlice，如果修改了aSlice中元素的&#20540;，那么bSlice相对应的&#20540;也会改变。
从概念上面来说slice像一个结构体，这个结构体包含了三个元素：
一个指针，指向数组中slice指定的开始位置长度，即slice的长度
最大长度，也就是slice开始位置到数组的最后位置的长度
Array_a := [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
Slice_a := Array_a[2:5]
上面代码的真正存储结构如下图所示
对于slice有几个有用的内置函数：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"..."，这样才能表示是将slice中的元素依次追加到另一个slice中。另外在通过下标访问元素时下标不能超过len大小，如同数组的下标不能超出len范围一样。
s :=append(s,1,2,3,4)
s :=append(s,s1…)golang list slice 删除其中一项比对
- Go语言中文网 - Golang中文社区
<meta name="author" content="polaris ">
golang list slice 删除其中一项比对
panda1986_meng
· 11498 次点击 ·
开始浏览 & &
slice可以动态添加项（使用append()函数），但是没有删除项的函数。变通方法，可以使用slice重新组合的方式删除一个或多个项，slice是引用类型，存的是指针，性能上不会有太多影响，示例如下：package mainimport &#34;fmt&#34;func main() {
s := []int{11, 22, 33, 44, 55, 66} // 原始slice
// 待删除项索引
s = append(s[:i], s[i+1:]...)
// 最后面的“...”不能省略
fmt.Println(s) // 数据结果
[11 22 44 55 66]}
有人回答的很好：
这样是可以实现。不过从slice这种数据结构来看，本身并不适合做删除操作。抛开语言，只谈数据结构，我们知道数组删除是会移动元素的，效率会比较低。当然任何语言的数组实现（顺序存储），删除元素都避免不了移动元素。所以，如果会平凡删除中间或开头的元素，更好的是选择链表这样的数据结构。Go中可以使用map或container/list包。
那咱就上个list的吧：
自己写一个contain函数，判断某value是否存在在list中
func Contains(l *list.List, value string) (bool, *list.Element) {
for e := l.Front(); e != e = e.Next() {
if e.Value == value {
return true, e
return false, nil
那就直接掉remove接口呗
if contain, e := Contains(l, &#34;xxx&#34;); contain {
l.Remove(e)
11498 次点击 &
请尽量让自己的回复能够对别人有帮助
支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
支持 @ 本站用户；支持表情（输入 : 提示），见
记住登录状态
slice可以动态添加项（使用append()函数），但是没有删除项的函数。变通方法，可以使用slice重新组合的方式删除一个或多个项，slice是引用类型，存的是指针，性能上不会有太多影响，示例如下：package mainimport &#34;fmt&#34;func main() {
s := []int{11, 22, 33, 44, 55, 66} // 原始slice
// 待删除项索引
s = append(s[:i], s[i+1:]...)
// 最后面的“...”不能省略
fmt.Println(s) // 数据结果
[11 22 44 55 66]}
有人回答的很好：
这样是可以实现。不过从slice这种数据结构来看，本身并不适合做删除操作。抛开语言，只谈数据结构，我们知道数组删除是会移动元素的，效率会比较低。当然任何语言的数组实现（顺序存储），删除元素都避免不了移动元素。所以，如果会平凡删除中间或开头的元素，更好的是选择链表这样的数据结构。Go中可以使用map或container/list包。
那咱就上个list的吧：
自己写一个contain函数，判断某value是否存在在list中
func Contains(l *list.List, value string) (bool, *list.Element) {
for e := l.Front(); e != e = e.Next() {
if e.Value == value {
return true, e
return false, nil
那就直接掉remove接口呗
if contain, e := Contains(l, &#34;xxx&#34;); contain {
l.Remove(e)
333 人在线
&最高记录 1223
&2012- Go语言中文网，中国 Golang 社区，致力于构建完善的 Golang 中文社区，Go语言爱好者的学习家园。
Powered by
&o&服务器由
赞助 &·&CDN 由
VERSION: V3.0.0&·&3.864369ms&·&为了更好的体验，本站推荐使用 Chrome 或 Firefox 浏览器
登录和大家一起探讨吧
记住登录状态
还不是会员golang中对slice操作工具类
- Go语言中文网 - Golang中文社区
<meta name="author" content="polaris ">
golang中对slice操作工具类
· 3477 次点击 ·
开始浏览 & &
转自/astaxie/beeku/blob/master/slice.go,是beego框架的作者写的对slice的操作,很棒
package beeku
&#34;math/rand&#34;
&#34;time&#34;
type reducetype func(interface{}) interface{}
type filtertype func(interface{}) bool
func Slice_randList(min, max int) []int {
if max & min {
min, max = max, min
length := max - min + 1
t0 := time.Now()
rand.Seed(int64(t0.Nanosecond()))
list := rand.Perm(length)
for index, _ := range list {
list[index] += min
return list
func Slice_merge(slice1, slice2 []interface{}) (c []interface{}) {
c = append(slice1, slice2...)
func In_slice(val interface{}, slice []interface{}) bool {
for _, v := range slice {
if v == val {
return true
return false
func Slice_reduce(slice []interface{}, a reducetype) (dslice []interface{}) {
for _, v := range slice {
dslice = append(dslice, a(v))
func Slice_rand(a []interface{}) (b interface{}) {
randnum := rand.Intn(len(a))
b = a[randnum]
func Slice_sum(intslice []int64) (sum int64) {
for _, v := range intslice {
func Slice_filter(slice []interface{}, a filtertype) (ftslice []interface{}) {
for _, v := range slice {
ftslice = append(ftslice, v)
func Slice_diff(slice1, slice2 []interface{}) (diffslice []interface{}) {
for _, v := range slice1 {
if !In_slice(v, slice2) {
diffslice = append(diffslice, v)
func Slice_intersect(slice1, slice2 []interface{}) (diffslice []interface{}) {
for _, v := range slice1 {
if !In_slice(v, slice2) {
diffslice = append(diffslice, v)
func Slice_chunk(slice []interface{}, size int) (chunkslice [][]interface{}) {
if size &= len(slice) {
chunkslice = append(chunkslice, slice)
end := size
for i := 0; i &= (len(slice) - size); i += size {
chunkslice = append(chunkslice, slice[i:end])
end += size
func Slice_range(start, end, step int64) (intslice []int64) {
for i := i &= i += step {
intslice = append(intslice, i)
func Slice_pad(slice []interface{}, size int, val interface{}) []interface{} {
if size &= len(slice) {
return slice
for i := 0; i & (size - len(slice)); i++ {
slice = append(slice, val)
return slice
func Slice_unique(slice []interface{}) (uniqueslice []interface{}) {
for _, v := range slice {
if !In_slice(v, uniqueslice) {
uniqueslice = append(uniqueslice, v)
func Slice_shuffle(slice []interface{}) []interface{} {
for i := 0; i & len(slice); i++ {
a := rand.Intn(len(slice))
b := rand.Intn(len(slice))
slice[a], slice[b] = slice[b], slice[a]
return slice
3477 次点击 &
请尽量让自己的回复能够对别人有帮助
支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
支持 @ 本站用户；支持表情（输入 : 提示），见
记住登录状态
转自/astaxie/beeku/blob/master/slice.go,是beego框架的作者写的对slice的操作,很棒
package beeku
&#34;math/rand&#34;
&#34;time&#34;
type reducetype func(interface{}) interface{}
type filtertype func(interface{}) bool
func Slice_randList(min, max int) []int {
if max & min {
min, max = max, min
length := max - min + 1
t0 := time.Now()
rand.Seed(int64(t0.Nanosecond()))
list := rand.Perm(length)
for index, _ := range list {
list[index] += min
return list
func Slice_merge(slice1, slice2 []interface{}) (c []interface{}) {
c = append(slice1, slice2...)
func In_slice(val interface{}, slice []interface{}) bool {
for _, v := range slice {
if v == val {
return true
return false
func Slice_reduce(slice []interface{}, a reducetype) (dslice []interface{}) {
for _, v := range slice {
dslice = append(dslice, a(v))
func Slice_rand(a []interface{}) (b interface{}) {
randnum := rand.Intn(len(a))
b = a[randnum]
func Slice_sum(intslice []int64) (sum int64) {
for _, v := range intslice {
func Slice_filter(slice []interface{}, a filtertype) (ftslice []interface{}) {
for _, v := range slice {
ftslice = append(ftslice, v)
func Slice_diff(slice1, slice2 []interface{}) (diffslice []interface{}) {
for _, v := range slice1 {
if !In_slice(v, slice2) {
diffslice = append(diffslice, v)
func Slice_intersect(slice1, slice2 []interface{}) (diffslice []interface{}) {
for _, v := range slice1 {
if !In_slice(v, slice2) {
diffslice = append(diffslice, v)
func Slice_chunk(slice []interface{}, size int) (chunkslice [][]interface{}) {
if size &= len(slice) {
chunkslice = append(chunkslice, slice)
end := size
for i := 0; i &= (len(slice) - size); i += size {
chunkslice = append(chunkslice, slice[i:end])
end += size
func Slice_range(start, end, step int64) (intslice []int64) {
for i := i &= i += step {
intslice = append(intslice, i)
func Slice_pad(slice []interface{}, size int, val interface{}) []interface{} {
if size &= len(slice) {
return slice
for i := 0; i & (size - len(slice)); i++ {
slice = append(slice, val)
return slice
func Slice_unique(slice []interface{}) (uniqueslice []interface{}) {
for _, v := range slice {
if !In_slice(v, uniqueslice) {
uniqueslice = append(uniqueslice, v)
func Slice_shuffle(slice []interface{}) []interface{} {
for i := 0; i & len(slice); i++ {
a := rand.Intn(len(slice))
b := rand.Intn(len(slice))
slice[a], slice[b] = slice[b], slice[a]
return slice
333 人在线
&最高记录 1223
&2012- Go语言中文网，中国 Golang 社区，致力于构建完善的 Golang 中文社区，Go语言爱好者的学习家园。
Powered by
&o&服务器由
赞助 &·&CDN 由
VERSION: V3.0.0&·&3.847934ms&·&为了更好的体验，本站推荐使用 Chrome 或 Firefox 浏览器
登录和大家一起探讨吧
记住登录状态
还不是会员