脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 脚本专栏 → Golang → golang cache索引超时缓存库

golang cache带索引超时缓存库实战示例

 更新时间：2022年09月09日 17:04:42   作者：w008p  
这篇文章主要为大家介绍了golang cache带索引超时缓存库实战示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪

正文

cache 是一个带索引带超时的缓存库

目的在于优化代码结构，提供了若干实践。 https://github.com/weapons97/cache

example

定义泛型函数

1.18 已经发布一段实践了。通过泛型函数。我们可以减少循环的使用，优化代码结构。下面分享几个泛型函数和代码上的实践。

Filter 函数

// Filter filter one slice
func Filter[T any](objs []T, filter func(obj T) bool) []T {
    res := make([]T, 0, len(objs))
    for i := range objs {
        ok := filter(objs[i])
        if ok {
            res = append(res, objs[i])
        }
    }
    return res
}

// 测试[]int
func TestFilter(t *testing.T) {
    ans := []int{2, 4, 6}
    a := []int{1, 2, 3, 4, 5, 6}
    b := Filter(a, func(i int) bool {
        return i%2 == 0
    })
    require.Equal(t, ans, b)
    spew.Dump(b)
}
// 结果
=== RUN   TestFilter
([]int) (len=3 cap=6) {
 (int) 2,
 (int) 4,
 (int) 6
}
--- PASS: TestFilter (0.00s)
PASS
// NoSpace is filter func for strings
func NoSpace(s string) bool {
    return strings.TrimSpace(s) != ""
}
// 测试[]sting
func TestFilterNoSpace(t *testing.T) {
    ans1 := []string{"1", "2", "3"}
    a := []string{"", "1", "", "2", "", "3", ""}
    b := Filter(a, NoSpace)
    require.Equal(t, ans1, b)
    spew.Dump(b)
}
// 结果
=== RUN   TestFilterNoSpace
([]string) (len=3 cap=7) {
 (string) (len=1) "1",
 (string) (len=1) "2",
 (string) (len=1) "3"
}
--- PASS: TestFilterNoSpace (0.00s)
PASS

Map 函数

// Map one slice
func Map[T any, K any](objs []T, mapper func(obj T) ([]K, bool)) []K {
    res := make([]K, 0, len(objs))
    for i := range objs {
        others, ok := mapper(objs[i])
        if ok {
            res = append(res, others...)
        }
    }
    return res
}
// 测试 []int -> []string
func TestMap(t *testing.T) {
    ans := []string{"2", "4", "6", "end"}
    a := []int{1, 2, 3, 4, 5, 6}
    b := Map(a, func(i int) ([]string, bool) {
        if i == 6 {
            return []string{fmt.Sprintf(`%v`, i), `end`}, true
        }
        if i%2 == 0 {
            return []string{fmt.Sprintf(`%v`, i)}, true
        } else {
            return nil, false
        }
    })
    require.Equal(t, ans, b)
    spew.Dump(b)
}
// 结果
=== RUN   TestMap
([]string) (len=4 cap=6) {
 (string) (len=1) "2",
 (string) (len=1) "4",
 (string) (len=1) "6",
 (string) (len=3) "end"
}
--- PASS: TestMap (0.00s)
PASS

First 函数

// First make return first for slice
func First[T any](objs []T) (T, bool) {
    if len(objs) > 0 {
        return objs[0], true
    }
    return *new(T), false
}
func TestFirstInt(t *testing.T) {
    ans1, ans2 := 1, 0
    a := []int{1, 2, 3, 4, 5, 6}
    b, ok := First(a)
    require.True(t, ok)
    require.Equal(t, ans1, b)
    spew.Dump(b)
    c := []int{}
    d, ok := First(c)
    require.False(t, ok)
    require.Equal(t, ans2, d)
    spew.Dump(d)
}
// result
=== RUN   TestFirstInt
(int) 1
(int) 0
--- PASS: TestFirstInt (0.00s)
PASS
func TestFirstString(t *testing.T) {
    ans1, ans2 := "1", ""
    a := []string{"1", "2", "3", "4", "5", "6"}
    b, ok := First(a)
    require.True(t, ok)
    require.Equal(t, ans1, b)
    spew.Dump(b)
    c := []string{}
    d, ok := First(c)
    require.False(t, ok)
    require.Equal(t, ans2, d)
    spew.Dump(d)
}
// result
=== RUN   TestFirstString
(string) (len=1) "1"
(string) ""
--- PASS: TestFirstString (0.00s)
PASS

带超时的cache

  • 某些情况下，我们删除过期的cache， 通过利用带超时的cache，简化代码

cache 结构

// 用辅助map删除
if apiRet.TotalCount > 0 {
var hc sync.Map
for _, h := range apiRet.Hcis {
hc.Store(h.HostID, h)
hostCpu.Store(h.HostID, h)
}
hostCpu.Range(func(key, _ interface{}) bool {
_, ok := hc.Load(key)
if !ok {
 hostCpu.Delete(key)
}
return true
})
}
// 直接设置，过期的key 会删除
for _, h := range apiRet.Hcis {
  hostCpu.Set(h.HostID, h)
}

func TestNewCache(t *testing.T) {
  c := NewCache(WithTTL[string, int](time.Second))
  b := 1
  c.Set(`a`, b)
  d, ok := c.Get(`a`)
  require.True(t, ok)
  require.Equal(t, b, d)
  time.Sleep(time.Second)
  d, ok = c.Get(`a`)
  require.False(t, ok)
  // 超时返回0值
  require.Equal(t, d, 0)
}

集合操作

通过 set 做集合，可以给集合去重。可以给结合相并，想交，等操作。

set 结构

func TestSetUnion(t *testing.T) {
    s := NewSet[string]()
    s.Add(`a`)
    s.Add(`b`)
    s2 := NewSet[string]()
    s2.Add(`b`)
    s2.Add(`d`)
    s3 := s.Union(s2)
    wantS3 := []string{`a`, `b`, `d`}
    ans := s3.List()
    sort.Strings(ans)
    require.Equal(t, wantS3, ans)
    spew.Dump(s.List(), s2.List(), s3.List())
}
func TestSetJoin(t *testing.T) {
    s := NewSet[string]()
    s.Add(`a`)
    s.Add(`b`)
    s2 := NewSet[string]()
    s2.Add(`b`)
    s2.Add(`d`)
    s3 := s.Join(s2)
    wantS3 := []string{`b`}
    ans := s3.List()
    sort.Strings(ans)
    require.Equal(t, wantS3, ans)
    spew.Dump(s.List(), s2.List(), s3.List())
}
func TestSetJoinLeft(t *testing.T) {
    s := NewSet[string]()
    s.Add(`a`)
    s.Add(`b`)
    s2 := NewSet[string]()
    s2.Add(`b`)
    s2.Add(`d`)
    s3 := s.JoinLeft(s2)
    wantS3 := []string{`a`, `b`}
    ans := s3.List()
    sort.Strings(ans)
    require.Equal(t, wantS3, ans)
    spew.Dump(s.List(), s2.List(), s3.List())
}
func TestSetJoinRight(t *testing.T) {
    s := NewSet[string]()
    s.Add(`a`)
    s.Add(`b`)
    s2 := NewSet[string]()
    s2.Add(`b`)
    s2.Add(`d`)
    s3 := s.JoinRight(s2)
    wantS3 := []string{`b`, `d`}
    ans := s3.List()
    sort.Strings(ans)
    require.Equal(t, wantS3, ans)
    spew.Dump(s.List(), s2.List(), s3.List())
}
func TestSetSub(t *testing.T) {
    s := NewSet[string]()
    s.Add(`a`)
    s.Add(`b`)
    s2 := NewSet[string]()
    s2.Add(`b`)
    s2.Add(`d`)
    s3 := s.Sub(s2)
    wantS3 := []string{`a`}
    ans := s3.List()
    sort.Strings(ans)
    require.Equal(t, wantS3, ans)
    spew.Dump(s.List(), s2.List(), s3.List())
}

通过set 去重

// ShowImageInManifest 抓取 manifest 中imgs
func ShowImageInManifest(manifest string) (imgs []string) {
    rx := regImages.FindAllStringSubmatch(manifest, -1)
    set := cache.NewSet[string]()
    for i := range rx {
        for j := range rx[i] {
            if strings.HasPrefix(rx[i][j], `image:`) {
                continue
            }
            tx0 := strings.TrimSpace(rx[i][j])
            tx1 := strings.Trim(tx0, `'`)
            tx2 := strings.Trim(tx1, `"`)
            set.Add(tx2)
        }
    }
    imgs = set.List()
    return imgs
}

带索引的cache

某些情况下，我们可能根据cache 的某个元素对cache进行遍历，这时候如果给cache 加上索引结构，可以对遍历加速。

index 结构

type Person struct {
    id       string
    lastName string
    fullName string
    country  string
}
const (
    IndexByLastName = `IndexByLastName`
    IndexByCountry  = `IndexByCountry`
)
func (p *Person) Indexs() map[string]IndexFunc {
    return map[string]IndexFunc{
        IndexByLastName: func(indexed Indexed) (key []string) {
            ci := indexed.(*Person)
            return []string{ci.lastName}
        },
        IndexByCountry: func(indexed Indexed) (key []string) {
            ci := indexed.(*Person)
            return []string{ci.country}
        },
    }
}
func (p *Person) ID() (mainKey string) {
    return p.id
}
func (p *Person) Set(v interface{}) (Indexed, bool) {
    rx, ok := v.(*Person)
    if !ok {
        return nil, false
    }
    return rx, true
}
func (p *Person) Get(v Indexed) (interface{}, bool) {
    rx, ok := v.(*Person)
    if !ok {
        return nil, false
    }
    return rx, true
}

// 测试数据
var (
    p1 = &Person{
        id:       `1`,
        lastName: "魏",
        fullName: "魏鹏",
        country:  `China`,
    }
    p2 = &Person{
        id:       `2`,
        lastName: "魏",
        fullName: "魏无忌",
        country:  `America`,
    }
    p3 = &Person{
        id:       `3`,
        lastName: "李",
        fullName: "李云",
        country:  `China`,
    }
    p4 = &Person{
        id:       `4`,
        lastName: "黄",
        fullName: "黄帅来",
        country:  `China`,
    }
    p5 = &Person{
        id:       `5`,
        lastName: "Cook",
        fullName: "TimCook",
        country:  `America`,
    }
    p6 = &Person{
        id:       `6`,
        lastName: "Jobs",
        fullName: "SteveJobs",
        country:  `America`,
    }
    p7 = &Person{
        id:       `7`,
        lastName: "Musk",
        fullName: "Elon Musk",
        country:  `America`,
    }
)

func TestIndexByCountry(t *testing.T) {
    index := NewIndexer(&Person{})
    // set
    index.Set(p1)
    index.Set(p2)
    index.Set(p3)
    index.Set(p4)
    index.Set(p5)
    index.Set(p6)
    index.Set(p7)
    // search
    rs := index.Search(IndexByCountry, `China`)
    require.False(t, rs.Failed())
    rx := rs.InvokeAll()
    require.Len(t, rx, 3)
    spew.Dump(rx)
    one := rs.InvokeOne().(*Person)
    require.Equal(t, one.country, `China`)
    spew.Dump(one)
}
// result
=== RUN   TestIndexByCountry
([]interface {}) (len=3 cap=3) {
 (*cache.Person)(0x14139c0)({
  id: (string) (len=1) "3",
  lastName: (string) (len=3) "李",
  fullName: (string) (len=6) "李云",
  country: (string) (len=5) "China"
 }),
 (*cache.Person)(0x1413a00)({
  id: (string) (len=1) "4",
  lastName: (string) (len=3) "黄",
  fullName: (string) (len=9) "黄帅来",
  country: (string) (len=5) "China"
 }),
 (*cache.Person)(0x1413940)({
  id: (string) (len=1) "1",
  lastName: (string) (len=3) "魏",
  fullName: (string) (len=6) "魏鹏",
  country: (string) (len=5) "China"
 })
}
(*cache.Person)(0x14139c0)({
 id: (string) (len=1) "3",
 lastName: (string) (len=3) "李",
 fullName: (string) (len=6) "李云",
 country: (string) (len=5) "China"
})
--- PASS: TestIndexByCountry (0.00s)
PASS

以上就是golang cache带索引超时缓存库实战示例的详细内容，更多关于golang cache索引超时缓存库的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

相关文章

  • Go语言中错误处理实例分析

    Go语言中错误处理实例分析

    这篇文章主要介绍了Go语言中错误处理,实例分析了Go语言中针对错误处理的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
    2015-02-02
  • 浅析Golang中字符串拼接问题

    浅析Golang中字符串拼接问题

    Go的字符串是一个不可改变的数据结构,这和其他语言如JAVA,C++等的设定很类似.总体来说,有如下五种拼接方式,下面我们将论述各种方式的性能问题,以及如何选择
    2023-04-04
  • Golang 错误捕获Panic与Recover的使用

    Golang 错误捕获Panic与Recover的使用

    对于Go语言的错误是通过返回值的方式，本文主要介绍了Golang 错误捕获Panic与Recover的使用，文中根据实例编码详细介绍的十分详尽，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2022-03-03
  • Golang使用gorm实现分页功能的示例代码

    Golang使用gorm实现分页功能的示例代码

    在提供列表接口时一般要用到分页,对于存储在某些数据库中的数据进行分页起来非常的方便,下文给出一个通过gorm进行分页并通过http返回数据的例子,感兴趣的小伙帮跟着小编一起来看看吧
    2024-10-10
  • 详解Golang中string的实现原理与高效使用

    详解Golang中string的实现原理与高效使用

    在Go语言中,无论是字符串常量、字符串变量还是代码中出现的字符串字面量,它们的类型都被统一设置为string,下面就跟随小编一起来了解一下Golang中string的实现原理与高效使用吧
    2024-01-01
  • GO语言中ni,零值与空结构体的使用

    GO语言中ni,零值与空结构体的使用

    Go语言为Java开发者带来了一些新概念,如零值、nil和空结构体,理解这些概念有助于Go语言的学习和应用,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2024-10-10
  • Go打包附件内容到执行文件的方法

    Go打包附件内容到执行文件的方法

    处于种种原因, 我们不希望这部分额外的内容以附件的形式出现, 有没有什么办法能够将附件内容直接打包进可执行文件中呢，下面小编给大家介绍下Go打包附件内容到执行文件的方法，感兴趣的朋友一起看看吧
    2023-03-03
  • Go连接并操作SQLite数据库基本步骤

    Go连接并操作SQLite数据库基本步骤

    在这篇文章中,我们将详细描述如何在 Go 语言中使用 SQLite 数据库,我们将会从如何在 Go 中安装和使用 SQLite 驱动包开始讲起,然后逐步介绍如何创建数据库连接,执行 SQL 查询,处理返回的数据以及关闭数据库连接
    2024-01-01
  • GO语言基本类型String和Slice,Map操作详解

    GO语言基本类型String和Slice,Map操作详解

    这篇文章主要为大家介绍了GO语言基本类型String和Slice,Map操作示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2022-08-08
  • Go语言中strings.HasPrefix、strings.Split、strings.SplitN() 函数

    Go语言中strings.HasPrefix、strings.Split、strings.SplitN() 函数

    本文主要介绍了Go语言中strings.HasPrefix、strings.Split、strings.SplitN()函数,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2024-08-08

最新评论