以下常用方法列表，文档更新可能滞后于代码新特性，更多的方法及示例请参考代码文档：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"))
    6.     // Output:
    7.     // [1,2,3,4,5,6,7,8,9] <nil>
    8. }

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"))
    8.     // Output:
    9.     // [1,2,3,4,5,6,7,8,9] <nil>
    10.  }

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)
    7.     // Returns false when the key name already exists
    8.     k2, err := c.SetIfNotExist(ctx, "k1", "v2", 1000*time.Millisecond)
    9.     fmt.Println(k2, err)
    11.     // Print the current list of key values
    12.     keys1, _ := c.Keys(ctx)
    13.     fmt.Println(keys1)
    15.     // It does not expire if `duration` == 0. It deletes the `key` if `duration` < 0 or given `value` is nil.
    16.     c.SetIfNotExist(ctx, "k1", 0, -10000)
    18.     // Wait 1 second for K1: V1 to expire automatically
    19.     time.Sleep(1200 * time.Millisecond)
    21.     // Print the current key value pair again and find that K1: V1 has expired
    22.     keys2, _ := c.Keys(ctx)
    23.     fmt.Println(keys2)
    25.     // Output:
    26.     // true <nil>
    27.     // false <nil>
    28.     // [k1]
    29.     // [<nil>]
    30.  }

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)
    11.     // Gets the specified key value
    12.     v1, _ := c.Get(ctx, "k1")
    13.     v2, _ := c.Get(ctx, "k2")
    14.     v3, _ := c.Get(ctx, "k3")
    16.     fmt.Println(v1, v2, v3)
    18.     // Output:
    19.     // v1 v2 v3
    20.  }

Size

  • 说明: Size返回缓存中的项数。

  • 格式: 

    1. Size(ctx context.Context) (size int, err error)

  • 示例：

    1. func ExampleCache_Size() {
    2.     c := gcache.New()
    4.     // Add 10 elements without expiration
    5.     for i := 0; i < 10; i++ {
    6.         c.Set(ctx, i, i, 0)
    7.     }
    9.     // Size returns the number of items in the cache.
    10.     n, _ := c.Size(ctx)
    11.     fmt.Println(n)
    13.     // Output:
    14.     // 10
    15. }

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)
    5.     k1, _ := c.Get(ctx, "k1")
    6.     fmt.Println(k1)
    7.     k2, _ := c.Get(ctx, "k2")
    8.     fmt.Println(k2)
    9.     k3, _ := c.Get(ctx, "k3")
    10.     fmt.Println(k3)
    12.     re, exist, _ := c.Update(ctx, "k1", "v11")
    13.     fmt.Println(re, exist)
    15.     re1, exist1, _ := c.Update(ctx, "k4", "v44")
    16.     fmt.Println(re1, exist1)
    18.     kup1, _ := c.Get(ctx, "k1")
    19.     fmt.Println(kup1)
    20.     kup2, _ := c.Get(ctx, "k2")
    21.     fmt.Println(kup2)
    22.     kup3, _ := c.Get(ctx, "k3")
    23.     fmt.Println(kup3)
    25.     // Output:
    26.     // v1
    27.     // v2
    28.     // v3
    29.     // v1 true
    30.     //  false
    31.     // v11
    32.     // v2
    33.     // v3 
    34.  }

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)
    7.     c.UpdateExpire(ctx, "k1", 500*time.Millisecond)
    9.     expire1, _ := c.GetExpire(ctx, "k1")
    10.     fmt.Println(expire1)
    12.     // Output:
    13.     // 1s
    14.     // 500ms    
    15. }

Values

  • 说明: 通过Values获取缓存中的所有值，以切片方式返回。

  • 格式: 

    1. Values(ctx context.Context) (values []interface{}, err error)

  • 示例：通过UpdateExpire更新key的过期时间并打印查看。

    1. func ExampleCache_Values() {     
    2.     c := gcache.New()
    4.     c.Set(ctx, "k1", g.Map{"k1": "v1", "k2": "v2"}, 0)
    6.     // Values returns all values in the cache as slice.
    7.     data, _ := c.Values(ctx)
    8.     fmt.Println(data)
    10.     // May Output:
    11.     // [map[k1:v1 k2:v2]]
    12. }

Close

  • 说明: 关闭缓存，让GC回收资源，默认情况下可不关闭。

  • 格式: 

    1. Close(ctx context.Context) error

  • 示例：通过Close即可关闭缓存。

    1. func ExampleCache_Close() {     
    2.      c := gcache.New()
    4.     c.Set(ctx, "k1", "v", 0)
    5.     data, _ := c.Get(ctx, "k1")
    6.     fmt.Println(data)
    8.     // Close closes the cache if necessary.
    9.     c.Close(ctx)
    11.     data1, _ := c.Get(ctx, "k1")
    13.     fmt.Println(data1)
    15.      // Output:
    16.     // v
    17.     // v
    18. }

Contains

  • 说明: 如果缓存中存在指定的key，则Contains返回true，否则返回false。

  • 格式: 

    1. Contains(ctx context.Context, key interface{}) (bool, error)

  • 示例：

    1. func ExampleCache_Contains() {     
    2.      c := gcache.New()
    4.     // Set Cache
    5.     c.Set(ctx, "k", "v", 0)
    7.     data, _ := c.Contains(ctx, "k")
    8.     fmt.Println(data)
    10.     // return false
    11.     data1, _ := c.Contains(ctx, "k1")
    12.     fmt.Println(data1)
    14.      // Output:
    15.     // true
    16.     // false
    17. }

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()
    4.     c.SetMap(ctx, g.MapAnyAny{"k1": "v1"}, 0)
    5.     //c.Set(ctx, "k5", "v5", 0)
    7.     data, _ := c.Data(ctx)
    8.     fmt.Println(data)
    10.      // Output:
    11.     // map[k1:v1]
    12. }

Get

  • 说明: Get检索并返回给定key的关联值。如果它不存在、值为零或已过期，则返回nil。

  • 格式: 

    1. Get(ctx context.Context, key interface{}) (*gvar.Var, error)

  • 示例：

    1. func ExampleCache_Get() {     
    2.        c := gcache.New()
    4.     // Set Cache Object
    5.     c.Set(ctx, "k1", "v1", 0)
    7.     data, _ := c.Get(ctx, "k1")
    8.     fmt.Println(data)
    9.      // Output:
    10.     // v1
    11. }

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()
    4.     // Set cache without expiration
    5.     c.Set(ctx, "k", "v", 10000*time.Millisecond)
    7.     expire, _ := c.GetExpire(ctx, "k")
    8.     fmt.Println(expire)
    10.      // Output:
    11.     // 10s
    12. }

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()
    4.     data, _ := c.GetOrSet(ctx, "k", "v", 10000*time.Millisecond)
    5.     fmt.Println(data)
    7.     data1, _ := c.Get(ctx, "k")
    8.     fmt.Println(data1)
    10.     // Output:
    11.     // v
    12.     // v
    13. }

GetOrSetFunc

  • 说明: 检索并返回key的值，如果key对应的值不存在则使用函数func的结果设置key，如果缓存中存在key，则返回其结果。

  • 格式: 

    1. GetOrSetFunc(ctx context.Context, key interface{}, f func() (interface{}, error), duration time.Duration) (result *gvar.Var, err error)

  • 示例：key1的设置返回func执行结果，key2返回nil则不执行任何操作。

    1. func ExampleCache_GetOrSetFunc() {     
    2.     c := gcache.New()
    4.     c.GetOrSetFunc(ctx, 1, func() (interface{}, error) {
    5.         return 111, nil
    6.     }, 10000*time.Millisecond)
    7.     v, _ := c.Get(ctx, 1)
    8.     fmt.Println(v)
    10.     c.GetOrSetFunc(ctx, 2, func() (interface{}, error) {
    11.         return nil, nil
    12.     }, 10000*time.Millisecond)
    13.     v1, _ := c.Get(ctx, 2)
    14.     fmt.Println(v1)
    16.     // Output:
    17.     // 111
    18.     //
    19. }

GetOrSetFuncLock

  • 说明: 与GetOrSetFunc一致，但是不能重复或者覆盖注册缓存。

  • 格式: 

    1. GetOrSetFuncLock(ctx context.Context, key interface{}, f func() (interface{}, error), duration time.Duration) (result *gvar.Var, err error)

  • 示例：key1的设置返回func执行结果，key2设置操作则失效。

    1. func ExampleCache_GetOrSetFuncLock() {     
    2.     c := gcache.New()
    4.     c.GetOrSetFuncLock(ctx, 1, func() (interface{}, error) {
    5.         return 11, nil
    6.     }, 0)
    7.     v, _ := c.Get(ctx, 1)
    8.     fmt.Println(v)
    10.     // Modification failed
    11.     c.GetOrSetFuncLock(ctx, 1, func() (interface{}, error) {
    12.         return 111, nil
    13.     }, 0)
    14.     v, _ = c.Get(ctx, 1)
    15.     fmt.Println(v)
    17.     c.Remove(ctx, g.Slice{1, 2, 3}...)
    19.     // Modify locking
    20.     c.GetOrSetFuncLock(ctx, 1, func() (interface{}, error) {
    21.         return 111, nil
    22.     }, 0)
    23.     v, _ = c.Get(ctx, 1)
    24.     fmt.Println(v)
    26.     // Modification failed
    27.     c.GetOrSetFuncLock(ctx, 1, func() (interface{}, error) {
    28.         return 11, nil
    29.     }, 0)
    30.     v, _ = c.Get(ctx, 1)
    31.     fmt.Println(v)
    33.     // Output:
    34.     // 11
    35.     // 11
    36.     // 111
    37.     // 111
    38. }

Keys

  • 说明: 缓存中所有的key所有键名并以切片格式(Slice)返回。

  • 格式: 

    1. Keys(ctx context.Context) (keys []interface{}, err error)

  • 示例：

    1. func ExampleCache_Keys() {     
    2.     c := gcache.New()
    4.     c.SetMap(ctx, g.MapAnyAny{"k1": "v1"}, 0)
    6.     // Print the current list of key values
    7.     keys1, _ := c.Keys(ctx)
    8.     fmt.Println(keys1)
    10.     // Output:
    11.     // [k1]
    12. }

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()
    4.     c.SetMap(ctx, g.MapAnyAny{"k1": "v1", "k2": "v2"}, 0)
    6.     // KeyStrings returns all keys in the cache as string slice.
    7.     keys,_ := c.KeyStrings(ctx)
    8.     fmt.Println(keys)
    10.     // May Output:
    11.     // [k1 k2]
    12. }

Remove

  • 说明: 移除从缓存中删除一个或多个键，并返回最后一个删除的键值。

  • 格式: 

    1. Remove(ctx context.Context, keys ...interface{}) (lastValue *gvar.Var, err error)

  • 示例：

    1. func ExampleCache_Remove() {     
    2.     c := gcache.New()
    4.     c.SetMap(ctx, g.MapAnyAny{"k1": "v1", "k2": "v2"}, 0)
    6.     c.Remove(ctx, "k1")
    8.     data, _ := c.Data(ctx)
    9.     fmt.Println(data)
    11.     // Output:
    12.     // map[k2:v2]
    13. }

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()
    4.     c.SetMap(ctx, g.MapAnyAny{"k1": "v1", "k2": "v2", "k3": "v3", "k4": "v4"}, 0)
    6.     c.Removes(ctx, g.Slice{"k1", "k2", "k3"})
    8.     data, _ := c.Data(ctx)
    9.     fmt.Println(data)
    11.     // Output:
    12.     // map[k4:v4]
    13. }

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()        
    4.      c.Set(ctx, "k1", "v1", 0)
    5.      k2 := c.MustGet(ctx, "k2")
    7.      k1 := c.MustGet(ctx, "k1")
    8.     fmt.Println(k1)
    10.     fmt.Println(k2)
    12.      // Output:
    13.     // v1
    14. }

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() {
    3.     // Create a cache object,
    4.     // Of course, you can also easily use the gcache package method directly
    5.     c := gcache.New()
    7.     // MustGetOrSet acts like GetOrSet, but it panics if any error occurs.
    8.     k1 := c.MustGetOrSet(ctx, "k1", "v1", 0)
    9.     fmt.Println(k1)
    11.     k2 := c.MustGetOrSet(ctx, "k1", "v2", 0)
    12.     fmt.Println(k2)
    14.     // Output:
    15.     // v1
    16.     // v1
    18. }

MustGetOrSetFunc

  • 说明: 检索并返回key的值，如果key对应的值不存在则使用函数func的结果设置key，如果缓存中存在key，则返回其结果。如果err返回不为空则会panic(err)。

  • 格 式: 

    1. func (c *Cache) MustGetOrSetFunc(ctx context.Context, key interface{}, f func() (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()
    4.     c.MustGetOrSetFunc(ctx, 1, func() (interface{}, error) {
    5.         return 111, nil
    6.     }, 10000*time.Millisecond)
    7.     v := c.MustGet(ctx, 1)
    8.     fmt.Println(v)
    10.     c.MustGetOrSetFunc(ctx, 2, func() (interface{}, error) {
    11.         return nil, nil
    12.     }, 10000*time.Millisecond)
    13.     v1 := c.MustGet(ctx, 2)
    14.     fmt.Println(v1)
    16.     // Output:
    17.     // 111
    18.     //
    19. }

MustGetOrSetFuncLock

  • 说明: 与MustGetOrSetFunc一致，但是不能重复或者覆盖注册缓存。如果err返回不为空则会panic(err)。

  • 格 式: 

    1. func (c *Cache) MustGetOrSetFuncLock(ctx context.Context, key interface{}, f func() (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()
    4.     c.MustGetOrSetFuncLock(ctx, "k1", func() (interface{}, error) {
    5.         return "v1", nil
    6.     }, 0)
    7.     v := c.MustGet(ctx, "k1")
    8.     fmt.Println(v)
    10.     // Modification failed
    11.     c.MustGetOrSetFuncLock(ctx, "k1", func() (interface{}, error) {
    12.         return "update v1", nil
    13.     }, 0)
    14.     v = c.MustGet(ctx, "k1")
    15.     fmt.Println(v)
    17.     // Output:
    18.     // v1
    19.     // v1
    20. }

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()
    4.     // Set Cache
    5.     c.Set(ctx, "k", "v", 0)
    7.     // Contains returns true if `key` exists in the cache, or else returns false.
    8.     // return true
    9.     data := c.MustContains(ctx, "k")
    10.     fmt.Println(data)
    12.     // return false
    13.     data1 := c.MustContains(ctx, "k1")
    14.     fmt.Println(data1)
    16.     // Output:
    17.     // true
    18.     // false
    20. }

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()
    4.     // Set cache without expiration
    5.     c.Set(ctx, "k", "v", 10000*time.Millisecond)
    7.     // MustGetExpire acts like GetExpire, but it panics if any error occurs.
    8.     expire := c.MustGetExpire(ctx, "k")
    9.     fmt.Println(expire)
    11.     // May Output:
    12.     // 10s
    13. }

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()
    4.     // Add 10 elements without expiration
    5.     for i := 0; i < 10; i++ {
    6.         c.Set(ctx, i, i, 0)
    7.     }
    9.     // Size returns the number of items in the cache.
    10.     n := c.MustSize(ctx)
    11.     fmt.Println(n)
    13.     // Output:
    14.     // 10
    15. }

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()
    4.     c.SetMap(ctx, g.MapAnyAny{"k1": "v1"}, 0)
    6.     data := c.MustData(ctx)
    7.     fmt.Println(data)
    9.     // Set Cache
    10.     c.Set(ctx, "k5", "v5", 0)
    11.     data1, _ := c.Get(ctx, "k1")
    12.     fmt.Println(data1)
    14.     // Output:
    15.     // map[k1:v1]
    16.     // v1
    17. }

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()
    4.     c.SetMap(ctx, g.MapAnyAny{"k1": "v1", "k2": "v2"}, 0)
    6.     // MustKeys acts like Keys, but it panics if any error occurs.
    7.     keys1 := c.MustKeys(ctx)
    8.     fmt.Println(keys1)
    10.     // May Output:
    11.     // [k1 k2]
    13. }

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()
    4.     c.SetMap(ctx, g.MapAnyAny{"k1": "v1", "k2": "v2"}, 0)
    6.     // MustKeyStrings returns all keys in the cache as string slice.
    7.     // MustKeyStrings acts like KeyStrings, but it panics if any error occurs.
    8.     keys := c.MustKeyStrings(ctx)
    9.     fmt.Println(keys)
    11.     // May Output:
    12.     // [k1 k2]
    13. }

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()
    4.     // Write value
    5.     c.Set(ctx, "k1", "v1", 0)
    7.     // Values returns all values in the cache as slice.
    8.     data := c.MustValues(ctx)
    9.     fmt.Println(data)
    11.     // Output:
    12.     // [v1]
    13. }