golang切片内存应用技巧详解

在 Go 语言中切片是使用非常频繁的一种聚合类型，它代表变长的序列，底层引用一个数组对象。一个切片由三个部分构成：指针、长度和容量。指针指向该切片自己第一个元素对应的底层数组元素的内存地址。

切片的类型声明如下：

type slice struct {
 array unsafe.Pointer
 len  int
 cap  int
}

多个切片之间可以共享底层数组的数据，并且引用的数组区间可能重叠。利用切片 的这个特性我们可以在原有内存空间中对切片进行反转、筛选和去重等操作，这样就不用声明一个指向新内存的切片来存储结果，从而节省了内存空间以及扩展底层数组的消耗，这在切片长度足够大时效果就会非常显著。

下面这些例子都是在切片底层数组的内存空间上进行的操作，需要注意的是这些操作在底层数组上生成新切片的同时也会更改底层数组。

删除指定位置的元素

下面的函数从原切片中删除索引位置i上的元素

func remove(slice []int, i int) []int {
  copy(slice[i:], slice[i+1:])
  return slice[:len(slice)-1]
}

func main() {
  s := []int{5, 6, 7, 8, 9}
  fmt.Println(remove(s, 2)) // "[5 6 8 9]"
}

内置的copy函数可以方便地将一个切片复制另一个相同类型的切片上。

筛选元素

下面的函数从输入的源切片中筛选出满足条件的切片元素，返回一个满足条件的元素组成的新切片。

type funcType func(T) bool //代表筛选逻辑函数，可以按需实现

func filter(a []T, f funcType) []T {
  b := a[:0]
  for _, x := range a {
   if f(x) {
   b = append(b, x)
   }
  }
  return b
}

反转切片

func reverse(a []T) []T {
  for i := len(a)/2-1; i >= 0; i-- {
    opp := len(a)-1-i
   a[i], a[opp] = a[opp], a[i]
 }

 return a
}

分组切片

下面的函数接收一个[]int 类型的源切片actions, 返回一个按指定长度分组的嵌套切片（解释起来好难，用过PHP 的同学可以理解为 Go 版本的array_chunk 函数，没用过的看下面例子）。假设切面值为：[]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}，设置分组中元素长度batchSize为3，函数调用后返回的分组后的切片为[[0 1 2] [3 4 5] [6 7 8] [9]]

func chunk(actions []int, batchSize int) []int {
 var batches [][]int

 for batchSize < len(actions) {
   actions, batches = actions[batchSize:], append(batches, actions[0:batchSize:batchSize])
 }
 batches = append(batches, actions)

  return batches
}

func main() {
 actions := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
 batchSize := 3
  chunks = chunk(actions, batchSize)
  //chunks 为[[0 1 2] [3 4 5] [6 7 8] [9]]
}

这里顺便说一下，完整的切片表达式形式如下：

input[low:high:max]

最后一个 max 的作用是，生成的切片的cap（容量）为max - low。

原地去重(只针对可比较的切片类型)

import "sort"

func main() {
 in := []int{3,2,1,4,3,2,1,4,1} // any item can be sorted
 sort.Ints(in)
 j := 0
 for i := 1; i < len(in); i++ {
    if in[j] == in[i] {
      continue
 }
 j++

 in[j] = in[i]
 }
 result := in[:j+1]
 fmt.Println(result) // [1 2 3 4]
}

文章中部分例子来自golang 官方的 GitHub 的 wiki ，在这个 wiki 里介绍了很多的切片使用技巧，了解更多可以访问golang 的 GitHub Wiki https://github.com/golang/go/wiki/SliceTricks#filtering-without-allocating

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。

赞 (0)

相关推荐

  • 浅谈golang slice 切片原理

    浅谈golang slice 切片原理

    slice介绍 数组的长度在定义之后无法再次修改:数组是值类型,每次传递都将产生一份副本.显然这种数据结构无法完全满足开发者的真实需求.在初始定义数组时,我们并不知道需要多大的数组,因此我们就需要"动态数组".在Go里面这种数据结构叫slice,slice并不是真正意义上的动态数组,而是一个引用类型.slice总是指向一个底层array,slice的声明也可以像array一样,只是不需要长度,它是可变长的,可以随时往slice里面加数据. 初看起来,数组切片就像一个指向数组的指针,实际

  • Golang中切片的用法与本质详解

    Golang中切片的用法与本质详解

    前言 Go 数组的长度不可改变,在特定场景中这样的集合就不太适用,Go中提供了一种灵活,功能强悍的内置类型切片("动态数组"),与数组相比切片的长度是不固定的,可以追加元素,在追加时可能使切片的容量增大 Go的切片类型为处理同类型数据序列提供一个方便而高效的方式. 切片有些类似于其他语言中的数组,但是有一些不同寻常的特性. 本文将深入切片的本质,并讲解它的用法. 数组 Go的切片是在数组之上的抽象数据类型,因此在了解切片之前必须要先理解数组. 数组类型定义了长度和元素类型.例如, [4

  • golang常用手册之切片(Slice)原理

    切片,这是一个在go语言中引入的新的理念.它有一些特征如下: 对数组抽象 数组长度不固定 可追加元素 切片容量可增大 容量大小成片增加 我们先把上面的理念整理在这里,但是实际的还是要撸码来解决问题. 定义或申明切片 首先我们看看申明切片: var sliceName []type 定义完成后,我们需要定义切片: sliceName = make([]type, len) 也可以适当简写: sliceName := make([]type, len) 在上面的例子中,我们申明了一个切片,我们现在先

  • Golang slice切片操作之切片的追加、删除、插入等

    本文介绍了Golang slice切片操作之切片的追加.删除.插入等,分享给大家,具体如下: 一.一般操作 1,声明变量,go自动初始化为nil,长度:0,地址:0,nil func main(){ var ss []string; fmt.Printf("length:%v \taddr:%p \tisnil:%v",len(ss),ss, ss==nil) } --- Running... length:0 addr:0x0 isnil:true Success: process

  • 理解Golang中的数组（array）、切片（slice）和map

    理解Golang中的数组（array）、切片（slice）和map

    我比较喜欢先给出代码,然后得出结论 数组 复制代码 代码如下: package main import (     "fmt" ) func main() {     arr := [...]int{1, 2, 3}     //打印初始的指针     fmt.Printf("the pointer is : %p \n", &arr)     printPointer(arr) } func printPointer(any interface{}) {

  • golang切片内存应用技巧详解

    在 Go 语言中切片是使用非常频繁的一种聚合类型,它代表变长的序列,底层引用一个数组对象.一个切片由三个部分构成:指针.长度和容量.指针指向该切片自己第一个元素对应的底层数组元素的内存地址. 切片的类型声明如下: type slice struct { array unsafe.Pointer len int cap int } 多个切片之间可以共享底层数组的数据,并且引用的数组区间可能重叠.利用切片 的这个特性我们可以在原有内存空间中对切片进行反转.筛选和去重等操作,这样就不用声明一个指向新内

  • GoLang切片并发安全解决方案详解

    目录 1.介绍切片并发问题 2.实践检验真理 3.回答切片并发安全问题 4.解决切片并发安全问题方式 5.附 1.介绍切片并发问题 关于切片的,Go语言中的切片原生支持并发吗? 2.实践检验真理 实践是检验真理的唯一标准,所以当我们遇到一个不确定的问题,直接写demo来验证,因为切片的特点,我们可以分多种情况来验证 1.不指定索引,动态扩容并发向切片添加数据 2.指定索引,指定容量并发向切片添加数据 不指定索引,动态扩容并发向切片添加数据 不指定索引,动态扩容并发向切片添加数据: 通过打印数据发

  • golang 切片截取参数方法详解

    golang 切片截取参数方法详解

    以 s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}为例 0. 建议:做slice截取时建议用两个参数,尤其是从底层数组进行切片操作时,因为这样在进行第一次append操作时,会给切片重新分配空间,这样减少切片对数组的影响. 1. 结论:s = s[low : high : max] 切片的三个参数的切片截取的意义为 low为截取的起始下标(含), high为窃取的结束下标(不含high),max为切片保留的原切片的最大下标(不含max):即新切片从老切片的low

  • Golang 内存管理简单技巧详解

    目录 引言 预先分配切片 结构中的顺序字段 使用 map[string]struct{} 而不是 map[string]bool 引言 除非您正在对服务进行原型设计,否则您可能会关心应用程序的内存使用情况.内存占用更小,基础设施成本降低,扩展变得更容易/延迟. 尽管 Go 以不消耗大量内存而闻名,但仍有一些方法可以进一步减少消耗.其中一些需要大量重构,但很多都很容易做到. 预先分配切片 数组是具有连续内存的相同类型的集合.数组类型定义指定长度和元素类型.数组的主要问题是它们的大小是固定的——它们

  • Performance 内存监控使用技巧详解

    Performance 内存监控使用技巧详解

    目录 Performance 介绍 使⽤ 内存问题的具体体现 监控内存的⼏种⽅式 TimeLine Performance 介绍 为什么使⽤Performance呢?GC 的⽬的是为了实现内存空间的良性循环,⽽良性循环的基⽯是合理的使⽤内存空间. 由于 ECMAScript 并没有提供操作内存的 API,所以内存分配是否合理我们不可知.Performance 提供了多种⽅式,在程序运⾏时可以时时监控,确定内存分配是否合理. 使⽤ 具体步骤 打开浏览器输⼊⽬标⽹址 进⼊开发⼈员⼯具⾯板 开启录制功

  • golang字符串本质与原理详解

    目录 一.字符串的本质 1.字符串的定义 2.字符串的长度 3.字符与符文 二.字符串的原理 1.字符串的解析 2.字符串的拼接 3.字符串的转换 总结 一.字符串的本质 1.字符串的定义 golang中的字符(character)串指的是所有8比特位字节字符串的集合,通常(非必须)是UTF-8 编码的文本. 字符串可以为空,但不能是nil. 字符串在编译时即确定了长度,值是不可变的. // go/src/builtin/builtin.go // string is the set of al

  • myeclipse8.5优化技巧详解

    还在为自己的配置低而抛弃MyEclipse8.5?还在为那低下的速度而苦恼吗?下面我们看看myeclipse8.5优化技巧的具体方法. 取消自动validation validation有一堆,什么xml.jsp.jsf.js等等,我们没有必要全部都去自动校验一下,只是需要的时候才会手工校验一下! 取消方法: windows–>perferences–>myeclipse–>validation 除开Manual下面的复选框全部选中之外,其他全部不选 手工验证方法: 在要验证的文件上,单

  • C++ 中继承与动态内存分配的详解

    C++ 中继承与动态内存分配的详解 继承是怎样与动态内存分配进行互动的呢?例如,如果基类使用动态内存分配,并重新定义赋值和复制构造函数,这将怎样影响派生类的实现呢?这个问题的答案取决于派生类的属性.如果派生类也使用动态内存分配,那么就需要学习几个新的小技巧.下面来看看这两种情况: 一.派生类不使用new 派生类是否需要为显示定义析构函数,复制构造函数和赋值操作符呢? 不需要! 首先,来看是否需要析构函数,如果没有定义析构函数,编译器将定义一个不执行任何操作的默认构造函数.实际上,派生类的默认构造

  • 深入Golang中的sync.Pool详解

    深入Golang中的sync.Pool详解

    我们通常用golang来构建高并发场景下的应用,但是由于golang内建的GC机制会影响应用的性能,为了减少GC,golang提供了对象重用的机制,也就是sync.Pool对象池. sync.Pool是可伸缩的,并发安全的.其大小仅受限于内存的大小,可以被看作是一个存放可重用对象的值的容器. 设计的目的是存放已经分配的但是暂时不用的对象,在需要用到的时候直接从pool中取. 任何存放区其中的值可以在任何时候被删除而不通知,在高负载下可以动态的扩容,在不活跃时对象池会收缩. sync.Pool首先

  • Golang之sync.Pool使用详解

    前言 我们通常用 Golang 来开发并构建高并发场景下的服务,但是由于 Golang 内建的GC机制多少会影响服务的性能,因此,为了减少频繁GC,Golang提供了对象重用的机制,也就是使用sync.Pool构建对象池. sync.Pool介绍 首先sync.Pool是可伸缩的临时对象池,也是并发安全的.其可伸缩的大小会受限于内存的大小,可以理解为是一个存放可重用对象的容器.sync.Pool设计的目的就是用于存放已经分配的但是暂时又不用的对象,而且在需要用到的时候,可以直接从该pool中取.

随机推荐