golang?cache帶索引超時緩存庫實戰(zhàn)示例
更新時間：2022年09月09日 17:04:42 作者：w008p
這篇文章主要為大家介紹了golang?cache帶索引超時緩存庫實戰(zhàn)示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪
正文
cache 是一個帶索引帶超時的緩存庫
目的在于優(yōu)化代碼結構，提供了若干實踐。 https://github.com/weapons97/cache
example
定義泛型函數
1.18 已經發(fā)布一段實踐了。通過泛型函數。我們可以減少循環(huán)的使用，優(yōu)化代碼結構。下面分享幾個泛型函數和代碼上的實踐。
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帶索引超時緩存庫實戰(zhàn)示例的詳細內容，更多關于golang cache索引超時緩存庫的資料請關注腳本之家其它相關文章！
相關文章
Golang判斷struct/slice/map是否相等以及對比的方法總結
平時開發(fā)中對比兩個struct或者map、slice是否相等是經常遇到的，有很多對比的方式，比如==，reflect.DeepEqual()，cmp.Equal()等也是經常容易混淆的，這么多種對比方式，適用場景和優(yōu)缺點都有哪些呢？今天我們來具體總結一下，感興趣的小伙伴們可以參考借鑒2022-11-11
這篇文章主要介紹了golang 比較浮點數的大小方式，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2021-05-05
Go語言內置的log庫提供了基本的日志記錄功能,支持日志的格式化輸出、設置日志前綴、配置輸出位置等,可以通過標準logger或創(chuàng)建新的Logger對象來使用,log庫簡單易用,但功能有限,可能需要配合第三方日志庫如logrus、zap等來滿足復雜需求2024-09-09
在并發(fā)編程中，資源的分配和回收是一個很重要的問題。Go?語言的?Sync.Pool?是一個可以幫助我們優(yōu)化這個問題的工具。本篇文章將會介紹?Sync.Pool?的用法、原理以及如何在項目中正確使用它，希望對大家有所幫助2023-05-05
這篇文章主要為大家介紹了Go語言基礎閉包的底層原理及實例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步早日升職加薪2021-11-11
這篇文章主要介紹了golang實現http服務器處理靜態(tài)文件的方法,涉及Go語言基于http協議處理文件的相關技巧,需要的朋友可以參考下2016-07-07
這篇文章主要為大家詳細一些Golang開發(fā)中常用的slice關聯的性能優(yōu)化手段,文中的示例代碼講解詳細,感興趣的小伙伴可以跟隨小編一起學習一下2024-10-10
數組用于在單個變量中存儲相同類型的多個值,而不是為每個值聲明單獨的變量,這篇文章主要為大家介紹了Go語言中數組的簡單使用,需要?的可以參考下2023-08-08
gin通過go build -tags實現json包切換及庫分析
這篇文章主要為大家介紹了gin通過go build -tags實現json包切換及庫分析,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪2023-09-09
這篇文章主要為大家介紹了Go?Singleflight導致死鎖問題解決分析,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪2023-09-09