深圳企业专业网站建设,做网站跟赚钱嘛,苏州工业园区有哪些企业,网站用的字体Redis基本数据类型代码示例#
这里示例使用 go-redis v8 #xff0c;不过 go-redis latest 是 v9
安装v8#xff1a;go get github.com/go-redis/redis/v8
Redis 5 种基本数据类型#xff1a; string 字符串类型#xff1b;list列表类型#xff1b;hash哈希表类型#…Redis基本数据类型代码示例#
这里示例使用 go-redis v8 不过 go-redis latest 是 v9
安装v8go get github.com/go-redis/redis/v8
Redis 5 种基本数据类型 string 字符串类型list列表类型hash哈希表类型set集合类型zset有序集合类型 最基本的Set/Get操作#
setget.go
package main
import (
context
fmt
time github.com/go-redis/redis/v8
)
func main() {
rdb : redis.NewClient(redis.Options{
Addr: localhost:6379,
Password: ,
DB: 0,
IdleTimeout: 350,
PoolSize: 50, // 连接池连接数量
})
ctx, cancel : context.WithTimeout(context.Background(), time.Second*10)
defer cancel()
_, err : rdb.Ping(ctx).Result() // 检查连接redis是否成功
if err ! nil {
fmt.Println(Connect Failed: %v \n, err)
panic(err)
} ctx context.Background()
// 设置 key 的值0 表示永不过期
err rdb.Set(ctx, setkey-1, value-1, 0).Err()
if err ! nil {
panic(err)
} // 设置 key 的值的过期时间为 30 秒
err rdb.Set(ctx, setkey-2, value-2, time.Second*30).Err()
if err ! nil {
panic(err)
} // 获取key的值
val, err : rdb.Get(ctx, setkey-1).Result()
if err redis.Nil { // 如果返回 redis.Nil 说明key不存在
fmt.Println(key not exixt)
} else if err ! nil {
fmt.Println(Get Val error: , err)
panic(err)
}
fmt.Println(Get Val: , val) val, _ rdb.Get(ctx, setkey-2).Result()
fmt.Println(Get Val setkey-2: , val)
}
string(s)字符串类型#
可以从 redis docs 的 COMMANDS 查询 string 的所有命令。
String 类型命令文档Commands | Redis 更具体的用法比如详细语法参数设置等点击每一个命令然后进去查看。比如点进去后 SET 的详细语法格式
Copy
SET key value [NX | XX] [GET] [EX seconds | PX milliseconds | EXAT unix-time-seconds | PXAT unix-time-milliseconds | KEEPTTL]
具体命令用法可以搜索上面 command 然后点进去查看这里主要是代码示例就不介绍具体命令用法了。
string 的底层是 SDS 数据结构原理简析可以看这篇文章https://www.cnblogs.com/jiujuan/p/15828302.html。
string 常用命令
1.SET/GET设置获取值。
2.SETNX/EXISTSSETNX设置并指定过期时间仅key不存在EXISTS 检查某个 key 是否存在。
3.MSET/MGET批量设置获取值。
4.DEL删除值。
5.INCR/INCRBY - DECR/DECRBYINCR 原子加1INCRBY 加具体数值。DECR/DECRBY 刚好相反。
6.GetRange字符串截取返回字符串的总长度。
7.Expire/ExpireAt/TTL设置值的过期时间端/点。TTL 获取过期的时间。
8.StrLen获取key的值长度
1、SET/GET设置和获取值见最上面SET/GET例子2、SETNX/EXISTS
SETNX设置并指定过期时间仅当 key 不存在时候才设置有效。
EXISTS: 检查某个 key 是否存在
Copy
package main
import (
context
fmt
time github.com/go-redis/redis/v8
)
func main() {
rdb : redis.NewClient(redis.Options{
Addr: localhost:6379,
Password: ,
DB: 0,
IdleTimeout: 350,
PoolSize: 50, // 连接池连接数量
})
ctx, cancel : context.WithTimeout(context.Background(), time.Second*10)
defer cancel()
_, err : rdb.Ping(ctx).Result() // 检查连接redis是否成功
if err ! nil {
fmt.Println(Connect Failed: %v \n, err)
panic(err)
} ctx context.Background() // SetNX 设置并指定过期时间仅当 key 不存在时候才设置有效
err rdb.SetNX(ctx, setnx-key, setnx-val, 0).Err()
if err ! nil {
fmt.Println(setnx value failed: , err)
panic(err)
} // 这里用SetNX设置值第二次运行后 val2 返回 false因为第二次运行时 setnx-key2 已经存在
val2, err : rdb.SetNX(ctx, setnx-key2, setnx-val2, time.Second*20).Result()
if err ! nil {
panic(err)
}
fmt.Printf(val2: %v \n, val2) // Exists 检查某个key是否存在
n, _ : rdb.Exists(ctx, setnx-key).Result()
if n 0 {
fmt.Println(n: , n)
fmt.Println(set nx key exists)
} else {
fmt.Println(set nx key not exists)
} val, _ : rdb.Get(ctx, setnx-key).Result()
fmt.Println(val)
}
3、MSET/MGET批量设置值批量获取值
Copy
ctx context.Background()// MSet 设置值
err rdb.MSet(ctx, mset-key1, mset-val1, mset-key2, mset-val2, mset-key3, mset-val3).Err()if err ! nil { fmt.Println(MSet ERROR : , err)
}// MGet 获取值
vals, err : rdb.MGet(ctx, mset-key1, mset-key2, mset-key3).Result()if err ! nil { fmt.Println(MGet ERROR: , err) panic(err)
}
fmt.Println(vals: , vals)
4、DEL删除操作支持删除多个 key 的操作
Copy
ctx context.Background()
n, err : rdb.Del(ctx, setkey, setnx-key).Result()if err ! nil { panic(err)
}
fmt.Println(del nums: , n)
5、INCR/INCRBY - DECR/DECRBY
INCR对数字进行原子加 1 操作INCRBY加某个数值。
同理 DECR 都是相反操作
Copy
package main
import (
context
fmt
time github.com/go-redis/redis/v8
)
func main() {
rdb : redis.NewClient(redis.Options{
Addr: localhost:6379,
Password: ,
DB: 0,
IdleTimeout: 350,
PoolSize: 50, // 连接池连接数量
})
ctx, cancel : context.WithTimeout(context.Background(), time.Second*10)
defer cancel()
_, err : rdb.Ping(ctx).Result() // 检查连接redis是否成功
if err ! nil {
fmt.Println(Connect Failed: %v \n, err)
panic(err)
} ctx context.Background() err rdb.SetNX(ctx, nums, 2, 0).Err()
if err ! nil {
panic(err)
}
fmt.Println(set nums : , 2) // Incr
val, err : rdb.Incr(ctx, nums).Result()
if err ! nil {
panic(err)
}
fmt.Println(incr: , val) // IncrBy
val, err rdb.IncrBy(ctx, nums, 10).Result()
if err ! nil {
panic(err)
}
fmt.Println(incrby: , val) //Decr
val, _ rdb.Decr(ctx, nums).Result()
fmt.Println(desc: , val) //DecrBy
val, _ rdb.DecrBy(ctx, nums, 5).Result()
fmt.Println(decrby: , val)
}
6、GetRange字符串截取返回字符串的总长度
Copy
// GetRange字符串截取操作返回字符串截取后的值
val, _ rdb.GetRange(ctx, setkey-1, 1, 3).Result()
fmt.Println(get range: , val)
可以放到GET/SET代码里去测试
7、Expire/ExpireAt/TTL 设置过期时间
Expire设置某个时间段后过期。
ExpireAt设置某个时间点过期。
TTL获取剩余时间
Copy
package main
import (
context
fmt
time github.com/go-redis/redis/v8
)
func main() {
rdb : redis.NewClient(redis.Options{
Addr: localhost:6379,
Password: ,
DB: 0,
IdleTimeout: 350,
PoolSize: 50, // 连接池连接数量
})
ctx, cancel : context.WithTimeout(context.Background(), time.Second*10)
defer cancel()
_, err : rdb.Ping(ctx).Result() // 检查连接redis是否成功
if err ! nil {
fmt.Println(Connect Failed: %v \n, err)
panic(err)
} ctx context.Background() rdb.Set(ctx, setkey-expire-1, value-expire-1, 0).Err()
rdb.Set(ctx, setkey-expire-2, value-expire-2, time.Second*40).Err() // Expire, 设置key在某个时间段后过期
val1, _ : rdb.Expire(ctx, setkey-expire-1, time.Second*20).Result()
fmt.Println(expire: , val1) // ExpireAt设置key在某个时间点后过期
val2, _ : rdb.ExpireAt(ctx, setkey-expire-2, time.Now().Add(time.Second*50)).Result()
fmt.Println(expire at: , val2) // TTL
expire, err : rdb.TTL(ctx, setkey-expire-1).Result()
fmt.Println(expire, err)
}/**
expire: true
expire at: true
20s nil
**/
8、StrLen 获取key的值的长度
Copy
// STRLEN获取key的值的长度
strlen, _ : rdb.StrLen(ctx, setkey-1).Result()
fmt.Println(strlen: , strlen)
list列表类型#
list 类型的操作命令文档Commands | Redis 。
list 列表是一个字符串列表可以从头部或尾部插入元素。 list 的源码简析可以看这篇文章https://www.cnblogs.com/jiujuan/p/15839269.html。
list 常用命令
1.LPUSHlist头部(左边)插入值最后的值在最前面。LPUSHX 仅当列表值存在时才插入值
2.LPOP移除列表的头部值并返回这个值
3.RPUSHlist尾部(右边)插入值。RPUSHX 仅当列表值存在才插入值
4.RPOP移除列表的尾部值并返回这个值
5.LRANGE返回key列表指定区间的值
6.BLPOP: 语法 BLPOP key [key ...] timeout从 key 列表头部弹出一个值没有就阻塞 timeout 秒如果 timeout0 则一直阻塞
7.BRPOP与上面 BLPOP 用法相似只不过 BRPOP 是从尾部弹出一个值
8.LLEN返回列表的长度
9.LINSERT在指定位置插入数据
10.LREM删除列表中的数据
11.LINDEX根据索引查询列表中的值
12.LSET根据索引设置列表中的某个值
Copy
package main
import (
context
fmt
time github.com/go-redis/redis/v8
)
func main() {
rdb : redis.NewClient(redis.Options{
Addr: localhost:6379,
Password: ,
DB: 0,
IdleTimeout: 350,
PoolSize: 50, // 连接池连接数量
})
ctx, cancel : context.WithTimeout(context.Background(), time.Second*10)
defer cancel()
_, err : rdb.Ping(ctx).Result() // 检查连接redis是否成功
if err ! nil {
fmt.Println(Connect Failed: %v \n, err)
panic(err)
} ctx context.Background()
// LPUSH 从头部(左边)插入数据最后的值在最前面
count, err : rdb.LPush(ctx, listkeyone, one, two, three, four).Result()
if err ! nil {
fmt.Println(lpush err, err)
}
fmt.Println(lpush count: , count) // LRANGE 返回列表范围数据。例子中返回 0 到 -1就是返回所有数据
rangeval, err : rdb.LRange(ctx, listkeyone, 0, -1).Result()
if err ! nil {
panic(err)
}
fmt.Println(LRange values: , rangeval) // LLen 返回列表数据大小
len, err : rdb.LLen(ctx, listkeyone).Result()
if err ! nil {
panic(err)
}
fmt.Println(llen: , len) // LInsert 在指定位置插入数据
err rdb.LInsert(ctx, listkeyone, before, two, 2).Err()
if err ! nil {
panic(err)
} vals, _ : rdb.LRange(ctx, listkeyone, 0, -1).Result()
fmt.Println(LInsert val: , vals) // RPUSH 在 list 尾部插入值
count, err : rdb.RPush(ctx, listkeyone, six, five).Result()
if err ! nil {
panic(err)
}
fmt.Println(RPush count: , count) // RPOP 删除list列表尾部(右边)值
val, err : rdb.RPop(ctx, listkeyone).Result()
if err ! nil {
panic(err)
}
fmt.Println(rpop val: , val)
vals, _ rdb.LRange(ctx, listkeyone, 0, -1).Result()
fmt.Println((rpop)lrange val: , vals) // LPOP 删除list列表头部(左边)值
val, err rdb.LPop(ctx, listkeyone).Result()
fmt.Println(rpop val: , val) // LIndex 根据索引查询值索引是从0开始
val1, _ : rdb.LIndex(ctx, listkeyone, 3).Result()
fmt.Println(LIndex val: , val1) // LSET 根据索引设置某个值索引从0开始
val2, _ : rdb.LSet(ctx, listkeyone, 3, han).Result()
fmt.Println(lset: , val2) // LREM 删除列表中的数据
del, err : rdb.LRem(ctx, listkeyone, 1, 5) // 从列表左边开始删除值 5出现重复元素只删除一次
if err ! nil {
panic(err)
}
fmt.Println(del : , del) rdb.LRem(ctx, listkeyone, 2, 5) // 从列表头部(左边)开始删除值 5如果存在多个值 5则删除 2 个 5 rdb.LRem(ctx, listkeyone, -3, 6) // 从列表尾部(右边)开始删除值 6如果存在多个值 6 则删除 3 个 6 }
hash哈希表类型#
hash类型数据操作命令Commands | Redis 官方文档
hash类型原理简析https://www.cnblogs.com/jiujuan/p/15944061.html 参考文档
hash 数据结构图 hash 哈希表数据类型常用命令redisdoc.com 这个地址把Redis分类列出来了还有详细解释
1.HSET 单个设置值。
2.HGET 单个获取值。
3.HMSET 批量设置。
4.HMGET 批量获取值。
5.HGETALL 获取所有值。
6.HDEL 删除字段支持删除多个字段。
7.HLEN 获取hash表中key的值数量。
8.HEXISTS 判断元素是否存在。
9.HINCRBY 根据key的field字段的整数值加减一个数值。
10.HSETNX 如果某个字段不存在则设置该字段值。
更多命令请查看Commands | Redis
代码示例
Copy
package main
import (
context
fmt
time github.com/go-redis/redis/v8
)
func main() {
rdb : redis.NewClient(redis.Options{
Addr: localhost:6379,
Password: ,
DB: 0,
IdleTimeout: 350,
PoolSize: 50, // 连接池连接数量
})
ctx, cancel : context.WithTimeout(context.Background(), time.Second*10)
defer cancel()
_, err : rdb.Ping(ctx).Result() // 检查连接redis是否成功
if err ! nil {
fmt.Println(Connect Failed: %v \n, err)
panic(err)
} ctx context.Background()
// HSET根据key设置field字段值
err rdb.HSet(ctx, hashkey, field-val, value-one).Err()
if err ! nil {
panic(err)
}
_ rdb.HSet(ctx, hashkey, field1, value1, field2, value2).Err()
_ rdb.HSet(ctx, hashkey, map[string]interface{}{field3: value3, field4: value4}).Err()
_ rdb.HSet(ctx, hashkey-two, []string{field0, value0, field1, value1}).Err() // HSETNX如果某个字段不存在则设置值
ok, err : rdb.HSetNX(ctx, hashkey, field1, oneval).Result() // 字段 field1 已存在所以返回ok值为false
if err ! nil {
panic(err)
}
fmt.Println(HSetNX bool: , ok) // HGET根据key和field查询值
val, err : rdb.HGet(ctx, hashkey, field-val).Result()
if err ! nil {
panic(err)
}
fmt.Println(HGet: , val) val, _ rdb.HGet(ctx, hashkey-two, field0).Result()
fmt.Println(HGet hashkey-two: , val) // HGETALL获取key的所有field-val值
fieldvals, err : rdb.HGetAll(ctx, hashkey).Result()
if err ! nil {
panic(err)
}
fmt.Println(HGetAll: , fieldvals) // 返回 map 类型 // HMSET根据hash key设置多个字段值与上面的 HSet 设置多个值很像
fieldvalues : make(map[string]interface{})
fieldvalues[age] 23
fieldvalues[firstname] Chare
fieldvalues[lastname] Jimmy
err rdb.HMSet(ctx, hmsetkey, fieldvalues).Err()
if err ! nil {
panic(err)
}
/*//也可以像上面HSet直接设置map值 rdb.HMSet(ctx, hmsetkey, map[string]interface{}{age:23,firstname:Chare,LastName:Jimmy}).Err()
*/ // HMGET, 根据hash key和多个字段获取值
vals, err : rdb.HMGet(ctx, hmsetkey, age, lastname).Result()
if err ! nil {
panic(err)
}
fmt.Println(HMGET vals: , vals) // HEXISTX某个hashkey中字段field否存在
ok, _ rdb.HExists(ctx, hmsetkey, lastname).Result()
fmt.Println(HExists: , ok) // HExists: true // HLen获取hashkey的字段多少
len, _ : rdb.HLen(ctx, hashkey).Result()
fmt.Println(HLen hashkey , len) // HLen hashkey: 5 // HIncrBy根据key的field字段的整数值加减一个数值
age, err : rdb.HIncrBy(ctx, hmsetkey, age, -3).Result()
if err ! nil {
panic(err)
}
fmt.Println(HIncrBy : , age) // HIncrBy : 20 // HDel删除字段支持删除多个字段
rdb.HSet(ctx, hashkeydel, map[string]interface{}{field10: value10, field11: value11, field12: value12, field13: value13}).Err()
rdb.HDel(ctx, hashkeydel, field10, field12) //删除多个字段 delvals, err : rdb.HGetAll(ctx, hashkeydel).Result()
if err ! nil {
panic(err)
}
fmt.Println(HGetAll hashkeydel: , delvals) }
/**
HSetNX bool: false
HGet: value-one
HGet hashkey-two: value0
HGetAll: map[field-val:value-one field1:value1 field2:value2 field3:value3 field4:value4]
HMGET vals: [23 Jimmy]
HExists: true
HLen hashkey 5
HIncrBy : 20
HGetAll hashkeydel: map[field11:value11 field13:value13] * */
set集合类型#
Redis 中的 set 集合类型是一个无序的唯一值集合也就是说一个set集合中的值唯一它的存储顺序不会按照插入顺序进行存储。
set与list的区别
list 可以存储重复的元素而 set 不能list 可以按照元素先后顺序存储而 set 不能 set 集合操作命令文档 1.Commands | Redis 2.集合 — Redis 命令参考 set 常用命令
SADDSADD key member [member...]将一个或多个元素数据添加到集合 key 中SISMEMBER: SISMEMBER key member判断 member 是否是集合 key 的成员SMEMBERS: SMEMBERS key获取 key 中的所有元素数据SREMSREM key member [member ...]删除 key 中的一个或多个数据SPOPSPOP key随机移除集合中的一个数据并返回SCARDSCARD key获取集合 key 中元素的数量SDIFFSDIFF key [key...]计算多个集合的差集SUNIONSUNION key [key...]计算多个集合的并集SINTERSINTER key [key...]计算多个集合的交集
代码例子
Copy
package main
import (
context
fmt
time github.com/go-redis/redis/v8
)
func main() {
rdb : redis.NewClient(redis.Options{
Addr: localhost:6379,
Password: ,
DB: 0,
IdleTimeout: 350,
PoolSize: 50, // 连接池连接数量
})
ctx, cancel : context.WithTimeout(context.Background(), time.Second*10)
defer cancel()
_, err : rdb.Ping(ctx).Result() // 检查连接redis是否成功
if err ! nil {
fmt.Println(Connect Failed: %v \n, err)
panic(err)
} ctx context.Background()
// SADD将一个或多个元素数据添加到集合中
err rdb.SAdd(ctx, setkey:1, 20, dog).Err()
if err ! nil {
panic(err)
}
rdb.SAdd(ctx, setkey:1, []string{hanmeimei, lilei, tom, dog, one}) // 切片增加数据dog只有一个数据
rdb.SAdd(ctx, setkey:2, []string{jimmy, pig, dog, lilei}) // SMEMBERS获取集合中的所有元素数据
smembers, err : rdb.SMembers(ctx, setkey:1).Result()
if err ! nil {
panic(err)
}
fmt.Println(SMemberssetkey:1: , smembers) // SCARD获取集合中的元素数量
scards, err : rdb.SCard(ctx, setkey:2).Result()
if err ! nil {
panic(err)
}
fmt.Println(SCard,setkey:2: , scards) // SPOP随机移除一个数据并返回这个数据
rdb.SAdd(ctx, setkey:3, []string{one, two, three, four, six})
spop, _ : rdb.SPop(ctx, setkey:3).Result()
res, _ : rdb.SMembers(ctx, setkey:3).Result()
fmt.Println(spop: , spop, , SMembers: , res)
// SPOPN随机移除多个元素并返回
spopn, _ : rdb.SPopN(ctx, setkey:3, 2).Result()
res, _ rdb.SMembers(ctx, setkey:3).Result()
fmt.Println(spopn: , spopn, , SMembers: , res) // SISMEMBER判断元素是否在集合中
ok, err : rdb.SIsMember(ctx, setkey:3, two).Result()
if err ! nil {
panic(err)
}
fmt.Println(SIsMember, two : , ok) // SDIFF,差集SDIFF key1,key2 与 SDIFF key1,key2 差集是不同看下面的例子
diff, _ : rdb.SDiff(ctx, setkey:1, setkey:2).Result()
fmt.Println(sdiff: , diff)
diff2, _ : rdb.SDiff(ctx, setkey:2, setkey:1).Result()
fmt.Println(sdiff2: , diff2)
// SUNION,并集
union, _ : rdb.SUnion(ctx, setkey:1, setkey:2).Result()
fmt.Println(union: , union)
// SINTER,交集
inter, _ : rdb.SInter(ctx, setkey:1, setkey:2).Result()
fmt.Println(inter: , inter) // SREM , 删除值返回删除元素个数
rdb.SAdd(ctx, setkey:4, []string{one, two, three})
count, err : rdb.SRem(ctx, setkey:4, one, three).Result()
if err ! nil {
panic(err)
}
fmt.Println(SRem: , count)
}
/*
SMemberssetkey:1: [20 hanmeimei one lilei tom dog]
SCard,setkey:2: 4
spop: six , SMembers: [four three one two]
spopn: [one two] , SMembers: [four three]
SIsMember, two : false
sdiff: [tom 20 hanmeimei one]
sdiff2: [jimmy pig]
union: [hanmeimei one jimmy lilei tom dog 20 pig]
inter: [lilei dog]
SRem: 2
*/
zset有序集合类型#
zset 是一个不重复值的有序集合与 set 集合一样值是不能重复。
zset 排序集是按照相关分数排序的唯一字符串成员的集合。它的底层数据结构是由压缩列表或跳表skiplist实现的。
如果有序集合元素个数小于 128 且每个元素值小于 64 字节redis 会使用 压缩列表作为 zset 类型的底层数据结构如果不满足上面的条件那么就用跳表作为底层数据结构。
跳表的原理简析https://www.cnblogs.com/jiujuan/p/12884824.html
zset 有序集合命令列表
Commands | RedisZADD key score member [[score member] [score member] …] — Redis 命令参考
zset有序集合图 zset 有序集合常用命令
ZADDZADD key score member [[score member] [score member] …]将一个或多个member元素以及score加入到有序集合key中ZSCOREZSCORE key member返回集合 key 中 member 成员的分数ZRANGEZRANGE key start stop [WITHSCORES]返回集合 key 中指定区间的元素score 从小到大排序start 和 stop 都是 0 开始。ZREVRANGEZREVRANGE key start stop [WITHSCORES]与 zrange 相反返回集合 key 中指定区间元素score 从大到小排序。ZRANGEBYSCOREZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]返回结果的数量区间score 从小到大排序LIMIT 参数指定返回结果集的数量和区间后面可选的 [limit offset count] 像 SQL 中的 select ... limit offset,count。ZREVRANGEBYSCORE与上面 ZRANGEBYSCORE 几乎相同不同是 score 是从大到小排序ZREVRANGEBYSCOREWITHSCORES和 ZRANGEBYSCORE 一样区别是它不仅返回集合元素也返回元素对应分数ZREM删除元素ZREMRANGEBYRank根据索引范围删除ZREMRANGEBYSCORE根据分数区间删除
还有 ZCOUNT 获取区间内元素个数ZCARD 获取元素个数ZINCRBY 增加元素分数ZRANK 根据元素查询在集合中的排名分数从小到大排序查询。
代码示例
Copy
package main
import (
context
fmt
time github.com/go-redis/redis/v8
)
func main() {
rdb : redis.NewClient(redis.Options{
Addr: localhost:6379,
Password: ,
DB: 0,
IdleTimeout: 350,
PoolSize: 50, // 连接池连接数量
})
ctx, cancel : context.WithTimeout(context.Background(), time.Second*10)
defer cancel()
_, err : rdb.Ping(ctx).Result() // 检查连接redis是否成功
if err ! nil {
fmt.Println(Connect Failed: %v \n, err)
panic(err)
} ctx context.Background()
// ZADD添加一个或多个数据到集合中
//* 添加一个*/
n, err : rdb.ZAdd(ctx, zsetkey, redis.Z{23.0, tom}).Result()
/* 或把字段写上
member : redis.Z{
Score: 23.0,
Member: tom,
} n, err : rdb.ZAdd(ctx, zsetkey, member).Result()
if err ! nil {
panic(err)
}
*/
fmt.Println(zadd: , n)
val, _ : rdb.ZRange(ctx, zsetkey, 0, -1).Result()
fmt.Println(ZRange, zsetkey: , val) //* ZADD批量增加*/
fruits_price_z : []*redis.Z{
redis.Z{Score: 5.0, Member: apple},
redis.Z{Score: 3.5, Member: orange},
redis.Z{Score: 6.0, Member: banana},
redis.Z{Score: 9.1, Member: peach},
redis.Z{Score: 19.0, Member: cherry},
}
num, err : rdb.ZAdd(ctx, fruits_price, fruits_price_z...).Result()
if err ! nil {
panic(err)
}
fmt.Println(zadd : , num) // ZRANGE索引范围返回元素分数从小到大 0 到 -1 就是所有元素
vals, err : rdb.ZRange(ctx, fruits_price, 0, -1).Result()
if err ! nil {
panic(err)
}
fmt.Println(ZRange,fruits_price: , vals) // ZREVRANGE分数从大到小
vals, err rdb.ZRevRange(ctx, fruits_price, 0, -1).Result()
if err ! nil {
panic(err)
}
fmt.Println(ZRevRange,fruits_price: , vals) // ZRANGEBYSCORE offset 和 count 可用于分页
rangbyscore : redis.ZRangeBy{
Min: 3, // 最小分数
Max: 7, // 最大分数
Offset: 0, // 开始偏移量
Count: 4, // 一次返回多少数据
}
vals, err rdb.ZRangeByScore(ctx, fruits_price, rangbyscore).Result()
if err ! nil {
panic(err)
}
fmt.Println(ZRangeByScore: , vals) // ZCOUNT 统计某个分数内的元素个数
count, _ : rdb.ZCount(ctx, fruits_price, 3, 7).Result()
fmt.Println(ZCount: , count) // ZREVRANGEBYSCOREWITHSCORES, 和 ZRANGEBYSCORE 一样区别是它不仅返回集合元素也返回元素对应分数
rangbyscorewithscores : redis.ZRangeBy{
Min: 3, // 最小分数
Max: 7, // 最大分数
Offset: 0, // 开始偏移量
Count: 4, // 一次返回多少数据
}
keyvals, err : rdb.ZRangeByScoreWithScores(ctx, fruits_price, rangbyscorewithscores).Result()
if err ! nil {
panic(err)
}
fmt.Println(ZRangeByScoreWithScores: , keyvals) // ZCRORE, 查询集合中元素的分数
score, _ : rdb.ZScore(ctx, fruits_price, peach).Result()
fmt.Println(ZScore: , score) // ZRANK 根据元素查询在集合中的排名分数从小到大排序查询
rank, _ : rdb.ZRank(ctx, fruits_price, peach).Result()
fmt.Println(ZRank: , rank) // ZREM根据Member删除值一次可以删除一个或多个
age_z : []*redis.Z{
redis.Z{Score: 20, Member: tom},
redis.Z{Score: 34, Member: jim},
redis.Z{Score: 23, Member: lilei},
redis.Z{Score: 43, Member: hanxu},
redis.Z{Score: 30, Member: jimmy},
redis.Z{Score: 55, Member: MA},
redis.Z{Score: 50, Member: MB},
redis.Z{Score: 52, Member: MC},
redis.Z{Score: 54, Member: MD},
redis.Z{Score: 59, Member: ME},
redis.Z{Score: 70, Member: MF},
redis.Z{Score: 75, Member: MG},
}
rdb.ZAdd(ctx, people_age, age_z...).Err() rdb.ZRem(ctx, people_age, jim).Err() // 删除一个
// rdb.ZRem(ctx, people_age, jim, jimmy).Err() // 删除多个
agevals, _ : rdb.ZRange(ctx, people_age, 0, -1).Result()
fmt.Println(ZRem, ZRange age: , agevals) //ZREMRANGEBYSCORE 根据分数区间删除
// rdb.ZRemRangeByScore(people_age, 20, 30).Err() // 删除 20分数30
rdb.ZRemRangeByScore(ctx, people_age, 20, (30).Err() // 删除 20分数30 agevals, _ rdb.ZRange(ctx, people_age, 0, -1).Result()
fmt.Println(ZRemRangeByScore, ZRange age: , agevals) // ZREMRANGEBYRANK根据分数排名删除
// 从低分到高分进行排序然后按照索引删除
rdb.ZRemRangeByRank(ctx, people_age, 6, 7) // 低分到高分排序删除第6个元素到第7个元素
agevals, _ rdb.ZRange(ctx, people_age, 0, -1).Result()
fmt.Println(ZRemRangeByRank, ZRange age: , agevals)
// 如果写成负数那么从高分开始删除
// rdb.ZRemRangeByRank(ctx, people_age, -6, -7) // ZIncrBy, 增加分数
rdb.ZIncrBy(ctx, people_age, 12, MG).Err()
score, _ rdb.ZScore(ctx, people_age, MG).Result()
fmt.Println(ZScore: , score)
}
/*
zadd: 0
ZRange, zsetkey: [tom]
zadd : 0
ZRange,fruits_price: [orange apple banana peach cherry]
ZRevRange,fruits_price: [cherry peach banana apple orange]
ZRangeByScore: [orange apple banana]
ZCount: 3
ZRangeByScoreWithScores: [{3.5 orange} {5 apple} {6 banana}]
ZScore: 9.1
ZRank: 3
ZRem, ZRange age: [tom lilei jimmy hanxu MB MC MD MA ME MF MG]
ZRemRangeByScore, ZRange age: [jimmy hanxu MB MC MD MA ME MF MG]
ZRemRangeByRank, ZRange age: [jimmy hanxu MB MC MD MA MG]
ZScore: 87
*/
