缓存管理-方法介绍 - 图1提示

以下常用方法列表,文档更新可能滞后于代码新特性,更多的方法及示例请参考代码文档: https://pkg.go.dev/github.com/gogf/gf/v2/os/gcache

Set

  • 说明:使用 key-value 键值对设置缓存,键值可以是任意类型。
  • 格式:
  1. Set(ctx context.Context, key interface{}, value interface{}, duration time.Duration) error
  • 示例:将 slice 切片设置到键名 k1 的缓存中。
  1. func ExampleCache_Set() {
  2. c := gcache.New()
  3. c.Set(ctx, "k1", g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9}, 0)
  4. fmt.Println(c.Get(ctx, "k1"))
  5. // Output:
  6. // [1,2,3,4,5,6,7,8,9] <nil>
  7. }

SetAdapter

  • 说明: SetAdapter 更改此缓存对象的底层适配器。请注意,此设置函数不是并发安全的。
  • 格式:
  1. SetAdapter(adapter Adapter)
  • 示例:可以自己根据需要实现任意缓存适配器,实现接口方法即可。
  1. func ExampleCache_SetAdapters() {
  2. c := gcache.New()
  3. adapter := gcache.New()
  4. c.SetAdapter(adapter)
  5. c.Set(ctx, "k1", g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9}, 0)
  6. fmt.Println(c.Get(ctx, "k1"))
  7. // Output:
  8. // [1,2,3,4,5,6,7,8,9] <nil>
  9. }

SetIfNotExist

  • 说明: 当指定 key 的键值不存在时设置其对应的键值 value 并返回 true,否则什么都不做并返回 false
  • 格式:
  1. SetIfNotExist(ctx context.Context, key interface{}, value interface{}, duration time.Duration) (ok bool, err error)
  • 示例:通过 SetIfNotExist 直接 判断写入,并设置过期时间。
  1. func ExampleCache_SetIfNotExist() {
  2. c := gcache.New()
  3. // Write when the key name does not exist, and set the expiration time to 1000 milliseconds
  4. k1, err := c.SetIfNotExist(ctx, "k1", "v1", 1000*time.Millisecond)
  5. fmt.Println(k1, err)
  6. // Returns false when the key name already exists
  7. k2, err := c.SetIfNotExist(ctx, "k1", "v2", 1000*time.Millisecond)
  8. fmt.Println(k2, err)
  9. // Print the current list of key values
  10. keys1, _ := c.Keys(ctx)
  11. fmt.Println(keys1)
  12. // It does not expire if `duration` == 0. It deletes the `key` if `duration` < 0 or given `value` is nil.
  13. c.SetIfNotExist(ctx, "k1", 0, -10000)
  14. // Wait 1 second for K1: V1 to expire automatically
  15. time.Sleep(1200 * time.Millisecond)
  16. // Print the current key value pair again and find that K1: V1 has expired
  17. keys2, _ := c.Keys(ctx)
  18. fmt.Println(keys2)
  19. // Output:
  20. // true <nil>
  21. // false <nil>
  22. // [k1]
  23. // [<nil>]
  24. }

SetMap

  • 说明: 批量设置键值对,输入参数类型为 map[interface{}]interface{}
  • 格式:
  1. SetMap(ctx context.Context, data map[interface{}]interface{}, duration time.Duration) error
  • 示例:
  1. func ExampleCache_SetMap() {
  2. c := gcache.New()
  3. // map[interface{}]interface{}
  4. data := g.MapAnyAny{
  5. "k1": "v1",
  6. "k2": "v2",
  7. "k3": "v3",
  8. }
  9. c.SetMap(ctx, data, 1000*time.Millisecond)
  10. // Gets the specified key value
  11. v1, _ := c.Get(ctx, "k1")
  12. v2, _ := c.Get(ctx, "k2")
  13. v3, _ := c.Get(ctx, "k3")
  14. fmt.Println(v1, v2, v3)
  15. // Output:
  16. // v1 v2 v3
  17. }

Size

  • 说明: Size 返回缓存中的 项数
  • 格式:
  1. Size(ctx context.Context) (size int, err error)
  • 示例:
  1. func ExampleCache_Size() {
  2. c := gcache.New()
  3. // Add 10 elements without expiration
  4. for i := 0; i < 10; i++ {
  5. c.Set(ctx, i, i, 0)
  6. }
  7. // Size returns the number of items in the cache.
  8. n, _ := c.Size(ctx)
  9. fmt.Println(n)
  10. // Output:
  11. // 10
  12. }

Update

  • 说明: Update 更新 key 的对应的键值,但不更改其 过期时间,并返回旧值。如果缓存中不存在 key,则返回的 exist 值为 false
  • 格式:
  1. Update(ctx context.Context, key interface{}, value interface{}) (oldValue *gvar.Var, exist bool, err error)
  • 示例:通过 SetMap 添加多个缓存,通过 Update 指定 key 修改 value
  1. func ExampleCache_Update() {
  2. c := gcache.New()
  3. c.SetMap(ctx, g.MapAnyAny{"k1": "v1", "k2": "v2", "k3": "v3"}, 0)
  4. k1, _ := c.Get(ctx, "k1")
  5. fmt.Println(k1)
  6. k2, _ := c.Get(ctx, "k2")
  7. fmt.Println(k2)
  8. k3, _ := c.Get(ctx, "k3")
  9. fmt.Println(k3)
  10. re, exist, _ := c.Update(ctx, "k1", "v11")
  11. fmt.Println(re, exist)
  12. re1, exist1, _ := c.Update(ctx, "k4", "v44")
  13. fmt.Println(re1, exist1)
  14. kup1, _ := c.Get(ctx, "k1")
  15. fmt.Println(kup1)
  16. kup2, _ := c.Get(ctx, "k2")
  17. fmt.Println(kup2)
  18. kup3, _ := c.Get(ctx, "k3")
  19. fmt.Println(kup3)
  20. // Output:
  21. // v1
  22. // v2
  23. // v3
  24. // v1 true
  25. // false
  26. // v11
  27. // v2
  28. // v3
  29. }

UpdateExpire

  • 说明: UpdateExpire 更新 key 的过期时间并返回旧的 过期时间值。如果缓存中不存在 key,则返回 -1
  • 格式:
  1. UpdateExpire(ctx context.Context, key interface{}, duration time.Duration) (oldDuration time.Duration, err error)
  • 示例:通过 UpdateExpire 更新 key 的过期时间并打印查看。
  1. func ExampleCache_UpdateExpire() {
  2. c := gcache.New()
  3. c.Set(ctx, "k1", "v1", 1000*time.Millisecond)
  4. expire, _ := c.GetExpire(ctx, "k1")
  5. fmt.Println(expire)
  6. c.UpdateExpire(ctx, "k1", 500*time.Millisecond)
  7. expire1, _ := c.GetExpire(ctx, "k1")
  8. fmt.Println(expire1)
  9. // Output:
  10. // 1s
  11. // 500ms
  12. }

Values

  • 说明: 通过 Values 获取缓存中的所有值,以切片方式返回。
  • 格式:
  1. Values(ctx context.Context) (values []interface{}, err error)
  • 示例:
  1. func ExampleCache_Values() {
  2. c := gcache.New()
  3. c.Set(ctx, "k1", g.Map{"k1": "v1", "k2": "v2"}, 0)
  4. // Values returns all values in the cache as slice.
  5. data, _ := c.Values(ctx)
  6. fmt.Println(data)
  7. // May Output:
  8. // [map[k1:v1 k2:v2]]
  9. }

Close

  • 说明: 关闭缓存,让 GC 回收资源,默认情况下 可不关闭
  • 格式:
  1. Close(ctx context.Context) error
  • 示例:通过 Close 即可关闭缓存。
  1. func ExampleCache_Close() {
  2. c := gcache.New()
  3. c.Set(ctx, "k1", "v", 0)
  4. data, _ := c.Get(ctx, "k1")
  5. fmt.Println(data)
  6. // Close closes the cache if necessary.
  7. c.Close(ctx)
  8. data1, _ := c.Get(ctx, "k1")
  9. fmt.Println(data1)
  10. // Output:
  11. // v
  12. // v
  13. }

Contains

  • 说明: 如果缓存中存在指定的 key,则 Contains 返回 true,否则返回 false
  • 格式:
  1. Contains(ctx context.Context, key interface{}) (bool, error)
  • 示例:
  1. func ExampleCache_Contains() {
  2. c := gcache.New()
  3. // Set Cache
  4. c.Set(ctx, "k", "v", 0)
  5. data, _ := c.Contains(ctx, "k")
  6. fmt.Println(data)
  7. // return false
  8. data1, _ := c.Contains(ctx, "k1")
  9. fmt.Println(data1)
  10. // Output:
  11. // true
  12. // false
  13. }

Data

  • 说明: 数据以 map 类型返回缓存中所有 键值对('key':'value') 的拷贝。
  • 格式:
  1. Data(ctx context.Context) (data map[interface{}]interface{}, err error)
  • 示例:获取所有缓存数据以 map[interface{}]interface{} 返回
  1. func ExampleCache_Data() {
  2. c := gcache.New()
  3. c.SetMap(ctx, g.MapAnyAny{"k1": "v1"}, 0)
  4. //c.Set(ctx, "k5", "v5", 0)
  5. data, _ := c.Data(ctx)
  6. fmt.Println(data)
  7. // Output:
  8. // map[k1:v1]
  9. }

Get

  • 说明: Get 检索并返回给定 key 的关联值。如果它不存在、值为零或已过期,则返回 nil
  • 格式:
  1. Get(ctx context.Context, key interface{}) (*gvar.Var, error)
  • 示例:
  1. func ExampleCache_Get() {
  2. c := gcache.New()
  3. // Set Cache Object
  4. c.Set(ctx, "k1", "v1", 0)
  5. data, _ := c.Get(ctx, "k1")
  6. fmt.Println(data)
  7. // Output:
  8. // v1
  9. }

GetExpire

  • 说明: GetExpire 检索并返回缓存中 key 的过期时间。注意,如果 key 为永不过期,则返回 0。如果缓存中不存在 key,则返回 -1
  • 格式:
  1. GetExpire(ctx context.Context, key interface{}) (time.Duration, error)
  • 示例:
  1. func ExampleCache_GetExpire() {
  2. c := gcache.New()
  3. // Set cache without expiration
  4. c.Set(ctx, "k", "v", 10000*time.Millisecond)
  5. expire, _ := c.GetExpire(ctx, "k")
  6. fmt.Println(expire)
  7. // Output:
  8. // 10s
  9. }

GetOrSet

  • 说明: 检索并返回 key 的值,或者设置 key-value 对,如果缓存中不存在 key,则直接设置。
  • 格式:
  1. GetOrSet(ctx context.Context, key interface{}, value interface{}, duration time.Duration) (result *gvar.Var, err error)
  • 示例:用 GetOrSet 判断 key 不存在则直接设置,并设置 duration 时间。
  1. func ExampleCache_GetOrSet() {
  2. c := gcache.New()
  3. data, _ := c.GetOrSet(ctx, "k", "v", 10000*time.Millisecond)
  4. fmt.Println(data)
  5. data1, _ := c.Get(ctx, "k")
  6. fmt.Println(data1)
  7. // Output:
  8. // v
  9. // v
  10. }

GetOrSetFunc

  • 说明: 检索并返回 key 的值,如果 key 对应的值不存在则使用函数 func 的结果设置 key,如果缓存中存在 key,则返回其结果。
  • 格式:
  1. GetOrSetFunc(ctx context.Context, key interface{}, f func(ctx context.Context) (interface{}, error), duration time.Duration) (result *gvar.Var, err error)
  • 示例: k1 的设置返回 func 执行结果, k2 返回 nil 则不执行任何操作。
  1. func ExampleCache_GetOrSetFunc() {
  2. c := gcache.New()
  3. c.GetOrSetFunc(ctx, "k1", func(ctx context.Context) (value interface{}, err error) {
  4. return "v1", nil
  5. }, 10000*time.Millisecond)
  6. v, _ := c.Get(ctx, "k1")
  7. fmt.Println(v)
  8. c.GetOrSetFunc(ctx, "k2", func(ctx context.Context) (value interface{}, err error) {
  9. return nil, nil
  10. }, 10000*time.Millisecond)
  11. v1, _ := c.Get(ctx, "k2")
  12. fmt.Println(v1)
  13. // Output:
  14. // v1
  15. }

GetOrSetFuncLock

  • 说明: 与 GetOrSetFunc 一致,但是不能重复或者 覆盖注册 缓存。
  • 格式:
  1. GetOrSetFuncLock(ctx context.Context, key interface{}, f func(ctx context.Context) (interface{}, error), duration time.Duration) (result *gvar.Var, err error)
  • 示例:第1次的设置返回 func 执行结果,第2次设置操作则失效。
  1. func ExampleCache_GetOrSetFuncLock() {
  2. c := gcache.New()
  3. c.GetOrSetFuncLock(ctx, "k1", func(ctx context.Context) (value interface{}, err error) {
  4. return "v1", nil
  5. }, 0)
  6. v, _ := c.Get(ctx, "k1")
  7. fmt.Println(v)
  8. c.GetOrSetFuncLock(ctx, "k1", func(ctx context.Context) (value interface{}, err error) {
  9. return "update v1", nil
  10. }, 0)
  11. v, _ = c.Get(ctx, "k1")
  12. fmt.Println(v)
  13. c.Remove(ctx, g.Slice{"k1"}...)
  14. // Output:
  15. // v1
  16. // v1
  17. }

Keys

  • 说明: 缓存中所有的 key 所有键名并以 切片格式(Slice) 返回。
  • 格式:
  1. Keys(ctx context.Context) (keys []interface{}, err error)
  • 示例:
  1. func ExampleCache_Keys() {
  2. c := gcache.New()
  3. c.SetMap(ctx, g.MapAnyAny{"k1": "v1"}, 0)
  4. // Print the current list of key values
  5. keys1, _ := c.Keys(ctx)
  6. fmt.Println(keys1)
  7. // Output:
  8. // [k1]
  9. }

KeyStrings

  • 说明: KeyStrings 以字符串 切片 的形式返回缓存中的 所有键
  • 格式:
  1. func (c *Cache) KeyStrings(ctx context.Context) ([]string, error) {
  2. keys, err := c.Keys(ctx)
  3. if err != nil {
  4. return nil, err
  5. }
  6. return gconv.Strings(keys), nil
  7. }
  • 示例:
  1. func ExampleCache_KeyStrings() {
  2. c := gcache.New()
  3. c.SetMap(ctx, g.MapAnyAny{"k1": "v1", "k2": "v2"}, 0)
  4. // KeyStrings returns all keys in the cache as string slice.
  5. keys,_ := c.KeyStrings(ctx)
  6. fmt.Println(keys)
  7. // May Output:
  8. // [k1 k2]
  9. }

Remove

  • 说明: 移除从缓存中 删除一个或多个键,并返回最后一个删除的键值。
  • 格式:
  1. Remove(ctx context.Context, keys ...interface{}) (lastValue *gvar.Var, err error)
  • 示例:
  1. func ExampleCache_Remove() {
  2. c := gcache.New()
  3. c.SetMap(ctx, g.MapAnyAny{"k1": "v1", "k2": "v2"}, 0)
  4. c.Remove(ctx, "k1")
  5. data, _ := c.Data(ctx)
  6. fmt.Println(data)
  7. // Output:
  8. // map[k2:v2]
  9. }

Removes

  • 说明: 从缓存中 删除多个键
  • 格式:
  1. func (c *Cache) Removes(ctx context.Context, keys []interface{}) error {
  2. _, err := c.Remove(ctx, keys...)
  3. return err
  4. }
  • 示例:
  1. func ExampleCache_Removes() {
  2. c := gcache.New()
  3. c.SetMap(ctx, g.MapAnyAny{"k1": "v1", "k2": "v2", "k3": "v3", "k4": "v4"}, 0)
  4. c.Removes(ctx, g.Slice{"k1", "k2", "k3"})
  5. data, _ := c.Data(ctx)
  6. fmt.Println(data)
  7. // Output:
  8. // map[k4:v4]
  9. }

Clear

  • 说明: 清除 所有缓存
  • 格式:
  1. func (c *Cache) Clear(ctx context.Context) error
  • 示例:
  1. func ExampleCache_Clear() {
  2. c := gcache.New()
  3. c.SetMap(ctx, g.MapAnyAny{"k1": "v1", "k2": "v2", "k3": "v3", "k4": "v4"}, 0)
  4. c.Clear(ctx)
  5. data, _ := c.Data(ctx)
  6. fmt.Println(data)
  7. // Output:
  8. // map[]
  9. }

MustGet

  • 说明: MustGet 检索并返回给定 key 的关联值。如果它不存在、值为零或已过期,则返回 nil 如果 err 返回不为空则会 panic(err)
  • 格 式:
  1. func (c *Cache) MustGet(ctx context.Context, key interface{}) *gvar.Var {
  2. v, err := c.Get(ctx, key)
  3. if err != nil {
  4. panic(err)
  5. }
  6. return v
  7. }
  • 示例:
  1. func ExampleCache_MustGet() {
  2. c := gcache.New()
  3. c.Set(ctx, "k1", "v1", 0)
  4. k2 := c.MustGet(ctx, "k2")
  5. k1 := c.MustGet(ctx, "k1")
  6. fmt.Println(k1)
  7. fmt.Println(k2)
  8. // Output:
  9. // v1
  10. //
  11. }

MustGetOrSet

  • 说明: 检索并返回 key 的值,或者设置 key-value 对,如果缓存中不存在 key,则直接设置。如果 err 返回不为空则会 panic(err)
  • 格 式:
  1. func (c *Cache) MustGetOrSet(ctx context.Context, key interface{}, value interface{}, duration time.Duration) *gvar.Var {
  2. v, err := c.GetOrSet(ctx, key, value, duration)
  3. if err != nil {
  4. panic(err)
  5. }
  6. return v
  7. }
  • 示例:
  1. func ExampleCache_MustGetOrSet() {
  2. // Create a cache object,
  3. // Of course, you can also easily use the gcache package method directly
  4. c := gcache.New()
  5. // MustGetOrSet acts like GetOrSet, but it panics if any error occurs.
  6. k1 := c.MustGetOrSet(ctx, "k1", "v1", 0)
  7. fmt.Println(k1)
  8. k2 := c.MustGetOrSet(ctx, "k1", "v2", 0)
  9. fmt.Println(k2)
  10. // Output:
  11. // v1
  12. // v1
  13. }

MustGetOrSetFunc

  • 说明: 检索并返回 key 的值,如果 key 对应的值不存在则使用函数 func 的结果设置 key,如果缓存中存在 key,则返回其结果。如果 err 返回不为空则会 panic(err)
  • 格 式:
  1. func (c *Cache) MustGetOrSetFunc(ctx context.Context, key interface{}, f func(ctx context.Context) (interface{}, error), duration time.Duration) *gvar.Var {
  2. v, err := c.GetOrSetFunc(ctx, key, f, duration)
  3. if err != nil {
  4. panic(err)
  5. }
  6. return v
  7. }
  • 示例:
  1. func ExampleCache_MustGetOrSetFunc() {
  2. c := gcache.New()
  3. c.MustGetOrSetFunc(ctx, 1, func(ctx context.Context) (interface{}, error) {
  4. return 111, nil
  5. }, 10000*time.Millisecond)
  6. v := c.MustGet(ctx, 1)
  7. fmt.Println(v)
  8. c.MustGetOrSetFunc(ctx, 2, func(ctx context.Context) (interface{}, error) {
  9. return nil, nil
  10. }, 10000*time.Millisecond)
  11. v1 := c.MustGet(ctx, 2)
  12. fmt.Println(v1)
  13. // Output:
  14. // 111
  15. //
  16. }

MustGetOrSetFuncLock

  • 说明: 与 MustGetOrSetFunc 一致,但是不能重复或者 覆盖注册 缓存。如果 err 返回不为空则会 panic(err)
  • 格 式:
  1. func (c *Cache) MustGetOrSetFuncLock(ctx context.Context, key interface{}, f func(ctx context.Context) (interface{}, error), duration time.Duration) *gvar.Var {
  2. v, err := c.GetOrSetFuncLock(ctx, key, f, duration)
  3. if err != nil {
  4. panic(err)
  5. }
  6. return v
  7. }
  • 示例:
  1. func ExampleCache_MustGetOrSetFuncLock() {
  2. c := gcache.New()
  3. c.MustGetOrSetFuncLock(ctx, "k1", func(ctx context.Context) (interface{}, error) {
  4. return "v1", nil
  5. }, 0)
  6. v := c.MustGet(ctx, "k1")
  7. fmt.Println(v)
  8. // Modification failed
  9. c.MustGetOrSetFuncLock(ctx, "k1", func(ctx context.Context) (interface{}, error) {
  10. return "update v1", nil
  11. }, 0)
  12. v = c.MustGet(ctx, "k1")
  13. fmt.Println(v)
  14. // Output:
  15. // v1
  16. // v1
  17. }

MustContains

  • 说明: 如果缓存中存在指定的 key,则 Contains 返回 true,否则返回 false。如果 err 返回不为空则会 panic(err)
  • 格 式:
  1. func (c *Cache) MustContains(ctx context.Context, key interface{}) bool {
  2. v, err := c.Contains(ctx, key)
  3. if err != nil {
  4. panic(err)
  5. }
  6. return v
  7. }
  • 示例:
  1. func ExampleCache_MustContains() {
  2. c := gcache.New()
  3. // Set Cache
  4. c.Set(ctx, "k", "v", 0)
  5. // Contains returns true if `key` exists in the cache, or else returns false.
  6. // return true
  7. data := c.MustContains(ctx, "k")
  8. fmt.Println(data)
  9. // return false
  10. data1 := c.MustContains(ctx, "k1")
  11. fmt.Println(data1)
  12. // Output:
  13. // true
  14. // false
  15. }

MustGetExpire

  • 说明: MustGetExpire 检索并返回缓存中 key 的过期时间。注意,如果 key 为永不过期,则返回 0。如果缓存中不存在 key,则返回 -1,如果 err 返回不为空则会 panic(err)
  • 格 式:
  1. func (c *Cache) MustGetExpire(ctx context.Context, key interface{}) time.Duration {
  2. v, err := c.GetExpire(ctx, key)
  3. if err != nil {
  4. panic(err)
  5. }
  6. return v
  7. }
  • 示例:
  1. func ExampleCache_MustGetExpire() {
  2. c := gcache.New()
  3. // Set cache without expiration
  4. c.Set(ctx, "k", "v", 10000*time.Millisecond)
  5. // MustGetExpire acts like GetExpire, but it panics if any error occurs.
  6. expire := c.MustGetExpire(ctx, "k")
  7. fmt.Println(expire)
  8. // May Output:
  9. // 10s
  10. }

MustSize

  • 说明: MustSize 返回缓存中的项数。如果 err 返回不为空则会 panic(err)
  • 格 式:
  1. func (c *Cache) MustSize(ctx context.Context) int {
  2. v, err := c.Size(ctx)
  3. if err != nil {
  4. panic(err)
  5. }
  6. return v
  7. }
  • 示例:
  1. func ExampleCache_MustSize() {
  2. c := gcache.New()
  3. // Add 10 elements without expiration
  4. for i := 0; i < 10; i++ {
  5. c.Set(ctx, i, i, 0)
  6. }
  7. // Size returns the number of items in the cache.
  8. n := c.MustSize(ctx)
  9. fmt.Println(n)
  10. // Output:
  11. // 10
  12. }

MustData

  • 说明: 数据以 map 类型返回缓存中所有 键值对('key':'value') 的拷贝。如果 err 返回不为空则会 panic(err)
  • 格 式:
  1. func (c *Cache) MustData(ctx context.Context) map[interface{}]interface{} {
  2. v, err := c.Data(ctx)
  3. if err != nil {
  4. panic(err)
  5. }
  6. return v
  7. }
  • 示例:
  1. func ExampleCache_MustData() {
  2. c := gcache.New()
  3. c.SetMap(ctx, g.MapAnyAny{"k1": "v1"}, 0)
  4. data := c.MustData(ctx)
  5. fmt.Println(data)
  6. // Set Cache
  7. c.Set(ctx, "k5", "v5", 0)
  8. data1, _ := c.Get(ctx, "k1")
  9. fmt.Println(data1)
  10. // Output:
  11. // map[k1:v1]
  12. // v1
  13. }

MustKeys

  • 说明: MustKeys(slice)切片 的形式返回缓存中的所有键,如果 err 返回不为空则会 panic(err)
  • 格 式:
  1. func (c *Cache) MustKeys(ctx context.Context) []interface{} {
  2. v, err := c.Keys(ctx)
  3. if err != nil {
  4. panic(err)
  5. }
  6. return v
  7. }
  • 示例:
  1. func ExampleCache_MustKeys() {
  2. c := gcache.New()
  3. c.SetMap(ctx, g.MapAnyAny{"k1": "v1", "k2": "v2"}, 0)
  4. // MustKeys acts like Keys, but it panics if any error occurs.
  5. keys1 := c.MustKeys(ctx)
  6. fmt.Println(keys1)
  7. // May Output:
  8. // [k1 k2]
  9. }

MustKeyStrings

  • 说明: MustKeyStrings字符串(slice)切片 的形式返回缓存中的 所有键。如果 err 返回不为空则会 panic(err)
  • 格 式:
  1. func (c *Cache) MustKeyStrings(ctx context.Context) []string {
  2. v, err := c.KeyStrings(ctx)
  3. if err != nil {
  4. panic(err)
  5. }
  6. return v
  7. }
  • 示例:
  1. func ExampleCache_MustKeyStrings() {
  2. c := gcache.New()
  3. c.SetMap(ctx, g.MapAnyAny{"k1": "v1", "k2": "v2"}, 0)
  4. // MustKeyStrings returns all keys in the cache as string slice.
  5. // MustKeyStrings acts like KeyStrings, but it panics if any error occurs.
  6. keys := c.MustKeyStrings(ctx)
  7. fmt.Println(keys)
  8. // May Output:
  9. // [k1 k2]
  10. }

MustValues

  • 说明: MustValues(slice)切片 的形式返回缓存中的所有值,如果 err 返回不为空则会 panic(err)
  • 格 式:
  1. func (c *Cache) MustValues(ctx context.Context) []interface{} {
  2. v, err := c.Values(ctx)
  3. if err != nil {
  4. panic(err)
  5. }
  6. return v
  7. }
  • 示例:
  1. func ExampleCache_MustValues() {
  2. c := gcache.New()
  3. // Write value
  4. c.Set(ctx, "k1", "v1", 0)
  5. // Values returns all values in the cache as slice.
  6. data := c.MustValues(ctx)
  7. fmt.Println(data)
  8. // Output:
  9. // [v1]
  10. }