字符串 P39

Redis 的字符串是一个有字节组成的序列,可以存储以下 3 种类型的值:字节串(byte string)、整数、浮点数。

在需要的时候, Redis 会将整数转换成浮点数。整数的取值范围和系统的长整型(long)的相同,浮点数取值范围和精度与 IEEE 754 标准下的双精度浮点数(double)的相同。

Redis 中的自增命令和自减命令 P39
命令 格式 描述
INCR INCR key 将键存储的数字值加上 1
DECR DECR key 将键存储的数字值减去 1
INCRBY INCRBY key increment 将键存储的数字值加上整数增量 increment
DECRBY DECRBY key decrement 将键存储的数字值减去整数减量 decrement
INCRBYFLOAT INCRBYFLOAT key increment 将键存储的数字值加上浮点数增量 increment

相关演示代码如下(mainhandleResult 定义见:01. Redis 数据结构简介.md):

// 执行字符串类型数字相关操作
func executeNumberOperation(conn redis.Conn) {
// 删除原有值
handleResult(redis.Int(conn.Do("DEL", "number")))
// 获取值,输出 -> ERROR: redigo: nil returned
handleResult(redis.Int(conn.Do("GET", "number")))
// 自增 1,返回自增后的值 -> 1
handleResult(redis.Int(conn.Do("INCR", "number")))
// 自增 2,返回自增后的值 -> 3
handleResult(redis.Int(conn.Do("INCRBY", "number", "2")))
// 自减 1,返回自减后的值 -> 2
handleResult(redis.Int(conn.Do("DECR", "number")))
// 自减 2,返回自减后的值 -> 0
handleResult(redis.Int(conn.Do("DECRBY", "number", "2")))
// 自增 1.5,返回自增后的值 -> 1.5
handleResult(redis.Float64(conn.Do("INCRBYFLOAT", "number", "1.5")))
// 自增 -1.3,返回自增后的值 -> 0.2
handleResult(redis.Float64(conn.Do("INCRBYFLOAT", "number", "-1.3")))
}
供 Redis 处理子串和二进制位的命令 P40
命令 格式 描述
APPEND APPEND key value 将 value 追加到 key 当前值的末尾
GETRANGE GETRANGE key start end 返回 [start, end] 范围内子串
SETRANGE SETRANGE key offset value 将子串 [offset, offset + len(value)) 设置为 value
GETBIT GETBIT key offset 将字符串看作是二进制位串,获取 offset 上的位
SETBIT SETBIT key offset value 将字符串看作是二进制位串,设置 offset 上的位为 value
BITCOUNT BITCOUNT key [start end] 统计 [start, end] 范围内子串在二进制下有多少个 1
BITOP BITOP operation destkey key [key ...] operation 可选位运算 AND , OR , XOR , NOT ,将一个或多个二进制位串执行的操作结果存到 destkey 中

相关演示代码如下:

// 执行字符串类型字符串相关操作
func executeStringOperation(conn redis.Conn) {
// 删除原有值
handleResult(redis.Int(conn.Do("DEL", "string")))
// 追加串,返回当前字符串长度 -> 6,值变为 -> append
handleResult(redis.Int(conn.Do("APPEND", "string", "append")))
// 获取子串,返回 -> en
handleResult(redis.String(conn.Do("GETRANGE", "string", 3, 4)))
// 设置子串,返回当前字符串长度 -> 6,值变为 -> appled
handleResult(redis.Int(conn.Do("SETRANGE", "string", 3, "le")))
// 设置子串,返回当前字符串长度 -> 11,值变为 -> application
handleResult(redis.Int(conn.Do("SETRANGE", "string", 3, "lication")))
// 获取二进制位,返回 -> 1
// (获取第 7/8 个字符 a 在二进制下第 7%8 位上的二进制位,即 0110 0001 的第 7 位 1)
handleResult(redis.Int(conn.Do("GETBIT", "string", 7)))
// 设置二进制位,返回原来的二进制位 -> 0,值变为 -> cpplication
// (设置第 6/8 个字符 a 在二进制下第 6%8 位上的二进制位为1,即 0110 0001 变为 0110 0011)
handleResult(redis.Int(conn.Do("SETBIT", "string", 6, 1)))
// 统计二进制位,返回 -> 7
// (统计 [0, 1] 范围内子串 cp 在二进制下 0110 0011 0111 0000 二进制位为 1 的数量)
handleResult(redis.Int(conn.Do("BITCOUNT", "string", 0, 1))) handleResult(redis.String(conn.Do("SET", "aKey", "aa")))
handleResult(redis.String(conn.Do("SET", "bKey", "b")))
// 对 aa(0110 0001 0110 0001) 和 b(0110 0010 0000 0000) 进行 按位或,结果存储到 cKey 中
// 返回字符串长度 -> 2,值为 ca(0110 0011 0110 0001),
handleResult(redis.Int(conn.Do("BITOP", "OR", "cKey", "aKey", "bKey")))
}

Redis 可以通过使用子串操作和二进制位操作,配合 WATCHMULTIEXEC 命令(后面会初步介绍,以后将深入讲解),构建任何想要的数据结构。

列表 P42

一些常用的列表命令 P42
命令 格式 描述
RPUSH RPUSH key value [value ...] 依次将一个或多个 value 从列表右端插入
LPUSH LPUSH key value [value ...] 依次将一个或多个 value 从列表左端插入
RPOP RPOP key 移除并返回列表最右端的元素
LPOP LPOP key 移除并返回列表最左端的元素
LINDEX LINDEX key offset 返回列表左端开始偏移量为 offset 的元素
LRANGE LRANGE key start end 返回列表左端开始 [start, end] 范围内的所有元素
LTRIM LTRIM key start end 移除列表左端开始 [start, end] 范围外的所有元素

相关演示代码如下:

// 执行列表类型相关操作
func executeListOperation(conn redis.Conn) {
// 删除原有值
handleResult(redis.Int(conn.Do("DEL", "list")))
// 右端插入一次插入 a, b, c,返回当前列表长度 -> 3,列表变为 -> a b c
handleResult(redis.Int(conn.Do("RPUSH", "list", "a", "b", "c")))
// 左端插入一次插入 d, e, f,返回当前列表长度 -> 6,列表变为 -> f e d a b c
handleResult(redis.Int(conn.Do("LPUSH", "list", "d", "e", "f")))
// 弹出并返回列表最右端的值,返回 -> c,列表变为 -> f e d a b
handleResult(redis.String(conn.Do("RPOP", "list")))
// 弹出并返回列表最左端的值,返回 -> f,列表变为 -> e d a b
handleResult(redis.String(conn.Do("LPOP", "list")))
// 返回左端开始下标偏移量为 offset 的值,返回 -> d
handleResult(redis.String(conn.Do("LINDEX", "list", 1)))
// 移除列表左端开始 [1, 2] 范围外的所有元素,列表变为 -> d a
handleResult(redis.String(conn.Do("LTRIM", "list", 1, 2)))
}

利用 LTRIM 命令可以原子地弹出多个元素。 P43

阻塞式的列表弹出命令以及在列表之间移动元素的命令 P43
命令 格式 描述
BLPOP BLPOP key [key ...] timeout 从第一个非空列表中弹出最左端的元素,或者在 timeout 秒内阻塞并等待可弹出的元素出现,返回被弹出的列表名及元素, timeout 为 0 表示无限等待
BRPOP BRPOP key [key ...] timeout 从第一个非空列表中弹出最右端的元素,或者在 timeout 秒内阻塞并等待可弹出的元素出现,返回被弹出的列表名及元素, timeout 为 0 表示无限等待
RPOPLPUSH RPOPLPUSH source destination 从 source 列表中弹出最右端的元素,然后将这个元素退出 destination 列表的最左端,并返回这个元素
BRPOPLPUSH BRPOPLPUSH source destination timeout 从 source 列表中弹出最右端的元素,然后将这个元素退出 destination 列表的最左端,并返回这个元素;如果 source 列表为空,则在 timeout 秒内阻塞并等待可弹出元素出现

相关演示代码如下:

// 执行列表类型阻塞相关操作
func executeListBlockOperation(conn redis.Conn) {
// 删除原有值
handleResult(redis.Int(conn.Do("DEL", "source", "destination")))
// 从第一个非空列表中弹出并返回列表最左端的值,最多等待 1秒,输出 -> ERROR: redigo: nil returned
handleResult(redis.Strings(conn.Do("BLPOP", "source", "destination", 1))) // 初始化
handleResult(redis.Int(conn.Do("RPUSH", "source", "a", "b", "c")))
handleResult(redis.Int(conn.Do("RPUSH", "destination", "d", "e", "f")))
// 从第一个非空列表中弹出并返回列表最左端的值,无限等待,返回 -> a,source 变为 -> b c,destination 变为 -> d e f
handleResult(redis.Strings(conn.Do("BLPOP", "source", "destination", 0)))
// 从第一个非空列表中弹出并返回列表最右端的值,无限等待,返回 -> f,source 变为 -> b c,destination 变为 -> d e
handleResult(redis.Strings(conn.Do("BRPOP", "destination", "source", 0))) // 从 source 弹出最右端元素,然后推入到 destination 最左端,并返回这个元素
// 返回 -> c,source 变为 -> b,destination 变为 -> c d e
handleResult(redis.String(conn.Do("RPOPLPUSH", "source", "destination")))
// 从 source 弹出最右端元素,然后推入到 destination 最左端,并返回这个元素,无限等待
// 返回 -> b,source 变为 -> <nil>,destination 变为 -> b c d e
handleResult(redis.String(conn.Do("BRPOPLPUSH", "source", "destination", 0)))
// 从 source 弹出最右端元素,然后推入到 destination 最左端,并返回这个元素,最多等待 1秒
// 输出 -> ERROR: redigo: nil returned,source 变为 -> <nil>,destination 变为 -> b c d e
handleResult(redis.String(conn.Do("BRPOPLPUSH", "source", "destination", 1)))
}

对于阻塞弹出命令和弹出并推入命令,最常见的用例就是消息传递(messaging)和任务队列(task queue),将在以后对这两个主题进行介绍。 P44

练习题:通过列表来降低内存占用 P44

上篇文章中,我们使用了有序集合来记录用户最近浏览过的商品,并把用户浏览这些商品时的时间戳设置为分值,从而使得程序可以在清理旧会话的过程中或是在执行完购买操作后,进行相应的数据分析。但由于保存时间戳需要占用相应的空间,所以如果分析操作并不需要用到时间戳的话,那么就没有必要使用有序集合来保存用户最近浏览过的商品了。为此,请在保证语义不变的情况下,将 UpdateToken 函数里面是用的有序集合替换成列表。

提示:如果在解答这个问题时遇上困难的话,可以到 6.1.1 节中找找灵感。

  • 由于列表是有序的,所有最新访问的一定在列表的左端,所以每次操作时先删除列表中这个访问记录,再推入列表左端,最后修剪列表为长度为 25 即可。由于每次需要遍历整个列表,所以时间复杂度较高,但是列表长度总共只有 25 ,时间上相差不大,但是空间可以节省很多。

    // 更新最近商品访问列表
    func UpdateLatestViewedItem(conn redis.Conn, itemId int) {
    // 移除列表中所有值为 itemId 的元素
    _ = conn.Send("LREM", "latestViewedItem", 0, itemId)
    // 将最近访问的商品推入列表最左端
    _ = conn.Send("LPUSH", "latestViewedItem", itemId)
    // 修剪列表,保留最近访问的 25 个
    _ = conn.Send("LTRIM", "latestViewedItem", 0, 24)
    // 执行上述命令
    _ = conn.Flush()
    }

集合 P44

一些常用的集合命令 P45
命令 格式 描述
SADD SADD key member [member ...] 将一个或多个元素添加到集合中,返回添加到集合中的新元素的数量(不包括已存在的元素)
SREM SREM keymember [member ...] 将一个或多个元素从集合中删除,返回成功从集合中删除的元素(不包括不存在的元素)
SISMEMBER SISMEMBER key member 判断元素 member 是否在集合 key 中
SCARD SCARD key 返回结合中元素的数量
SMEMBERS SMEMBERS key 返回集合的所有元素
SRANDMEMBER SRANDMEMBER key [count] 随机返回集合中一个或多个元素。count 为正数时,返回 count 个各不相同的元素(最多返回整个集合);count 为负数时,返回 |count| 个可能会重复的元素,无最长限制。
SPOP SPOP key 随机移除并返回集合中的一个元素
SMOVE SMOVE source destination member 将元素 member 从集合 source 移动到集合 destination 中

相关演示代码如下:

// 执行集合类型相关操作
func executeSetOperation(conn redis.Conn) {
// 删除原有值
handleResult(redis.Int(conn.Do("DEL", "source", "destination")))
// 集合中添加三个元素,输出 -> 6,source 变为 -> 1 2 3 4 5 6 7
handleResult(redis.Int(conn.Do("SADD", "source", 1, 2, 3, 4, 5, 6, 7, 1)))
// 从集合中删除两个元素: 1 2,输出 -> 2,source 变为 -> 3 4 5 6 7
handleResult(redis.Int(conn.Do("SREM", "source", 1, 2)))
// 判断集合是否含有元素 3,输出 -> 1
handleResult(redis.Int(conn.Do("SISMEMBER", "source", 3)))
// 返回集合的元素个数,输出 -> 5
handleResult(redis.Int(conn.Do("SCARD", "source")))
// 返回集合的所有元素,输出 -> [3 4 5 6 7]
handleResult(redis.Ints(conn.Do("SMEMBERS", "source")))
// 随机返回集合中不同的 3 个元素,输出 -> [6 5 3] (随机结果可能存在不同,以实际为准)
handleResult(redis.Ints(conn.Do("SRANDMEMBER", "source", 3)))
// 随机返回集合中可重复的 6 个元素,输出 -> [7 5 6 3 7 6] (随机结果可能存在不同,以实际为准)
handleResult(redis.Ints(conn.Do("SRANDMEMBER", "source", -6)))
// 随机删除集合中的 1 个元素,输出 -> 3 ,source 变为 -> 4 5 6 7(随机结果可能存在不同,以实际为准)
handleResult(redis.Int(conn.Do("SPOP", "source")))
// 移动 source 集合中的元素 7 到 destination 集合中(由于前面存在随机,结果可能存在不同,以实际为准)
// 输出 -> 1 ,source 变为 -> 4 5 6 ,destination 变为 -> 7
handleResult(redis.Int(conn.Do("SMOVE", "source", "destination", 7)))
}
用于组合和处理多个集合的命令 P45
命令 格式 描述
SDIFF SDIFF key [key ...] 返回存在于第一个集合,而不存在于其他集合的元素(差集)
SDIFFSTORE SDIFFSTORE destination key [key ...] 将存在于第一个集合,而不存在于其他集合的元素(差集)存储到 destination 中,返回差集大小
SINTER SINTER key [key ...] 返回同时存在于所有集合中的元素(交集)
SINTERSTORE SINTERSTORE destination key [key ...] 将同时存在于所有集合中的元素(交集)存储到 destination 中,返回交集大小
SUNION SUNIONkey [key ...] 返回至少存在于一个集合中的元素(并集)
SUNIONSTORE SUNIONSTORE destination key [key ...] 将至少存在于一个集合中的元素(并集)存储到 destination 中,返回并集大小

相关演示代码如下:

// 执行集合类型多个集合相关操作
func executeSetMutiOperation(conn redis.Conn) {
// 删除原有值
handleResult(redis.Int(conn.Do("DEL", "source_1", "source_2", "source_3", "destination")))
// 初始化
handleResult(redis.Int(conn.Do("SADD", "source_1", 1, 2, 4, 8)))
handleResult(redis.Int(conn.Do("SADD", "source_2", 2, 3, 4, 5)))
handleResult(redis.Int(conn.Do("SADD", "source_3", 5, 6, 7, 8)))
// 返回三个集合的差集,输出 -> [1]
handleResult(redis.Ints(conn.Do("SDIFF", "source_1", "source_2", "source_3")))
// 将三个集合的差集存储到 destination 中,输出 -> 1,destination 变为 -> 1
handleResult(redis.Int(conn.Do("SDIFFSTORE", "destination", "source_1", "source_2", "source_3")))
// 返回两个集合的交集,输出 -> [2 4]
handleResult(redis.Ints(conn.Do("SINTER", "source_1", "source_2")))
// 将两个集合的交集存储到 destination 中,输出 -> 2,destination 变为 -> 2 4
handleResult(redis.Int(conn.Do("SINTERSTORE", "destination", "source_1", "source_2")))
// 返回三个集合的并集,输出 -> [1 2 3 4 5 6 7 8]
handleResult(redis.Ints(conn.Do("SUNION", "source_1", "source_2", "source_3")))
// 将三个集合的并集存储到 destination 中,输出 -> 8,destination 变为 -> 1 2 3 4 5 6 7 8
handleResult(redis.Int(conn.Do("SUNIONSTORE", "destination", "source_1", "source_2", "source_3")))
}

哈希表 P46

用于添加和删除键值对的散列操作 P47
命令 格式 描述
HMGET HMGET key field [field ...] 从哈希表中获取一个或多个 field 的值
HMSET HMSET key field value [field value ...] 向哈希表中设置一个或多个 field 的值
HDEL HDEL key field [field ...] 从哈希表中删除一个或多个 field 的值
HLEN HLEN key 返回哈希表中包含的 field 的数量

相关演示代码如下:

// 执行哈希表类型相关操作
func executeHashOperation(conn redis.Conn) {
// 删除原有值
handleResult(redis.Int(conn.Do("DEL", "hash")))
// 向哈希表中设置一个或多个 field 的值,输出 -> OK,hash 变为 -> {field_1: value_1, field_2: value_2, field_3: value_3}
handleResult(redis.String(conn.Do("HMSET", "hash", "field_1", "value_1", "field_2", "value_2", "field_3", "value_3")))
// 从哈希表中获取一个或多个 field 的值,输出 -> [value_1 value_3 value_2]
handleResult(redis.Strings(conn.Do("HMGET", "hash", "field_1", "field_3", "field_2")))
// 从哈希表中删除一个或多个 field 的值,输出 -> 2,hash 变为 -> field_2: value_2}
handleResult(redis.Int(conn.Do("HDEL", "hash", "field_1", "field_3")))
// 返回哈希表中包含的 field 的数量,输出 -> 1
handleResult(redis.Int(conn.Do("HLEN", "hash")))
}
哈希表的更高级特性 P47
命令 格式 描述
HEXISTS HEXISTS key field 判断 field 是否存在于哈希表中
HKEYS HKEYS key 返回哈希表中所有的 field
HVALS HVALS key 返回哈希表中所有 field 的值
HGETALL HGETALL key 返回哈希表中所有的 field 及其值
HINCRBY HINCRBY key field increment 将哈希表中 field 的值增加整数 increment
HINCRBYFLOAT HINCRBYFLOAT key field increment 将哈希表中 field 的值增加浮点数 increment

相关演示代码如下:

// 执行哈希表类型高级特性相关操作
func executeHashFeatureOperation(conn redis.Conn) {
// 删除原有值
handleResult(redis.Int(conn.Do("DEL", "hash")))
// 初始化
handleResult(redis.String(conn.Do("HMSET", "hash", "field_1", "value_1", "field_2", "value_2", "field_3", "3")))
// 判断 field 是否存在于哈希表中,输出 -> 1
handleResult(redis.Int(conn.Do("HEXISTS", "hash", "field_1")))
// 返回哈希表中所有的 field,输出 -> [field_1 field_2 3]
handleResult(redis.Strings(conn.Do("HKEYS", "hash")))
// 返回哈希表中所有 field 的值,输出 -> [value_1 value_2 value_3]
handleResult(redis.Strings(conn.Do("HVALS", "hash")))
// 返回哈希表中所有的 field 及其值,输出 -> map[field_1:value_1 field_2:value_2 field_3:3]
handleResult(redis.StringMap(conn.Do("HGETALL", "hash")))
// 将哈希表中 field 的值增加 1,输出 -> 4,field_3 的值变为 -> 4
handleResult(redis.Int(conn.Do("HINCRBY", "hash", "field_3", 1)))
// 将哈希表中 field 的值增加 -1.5,输出 -> 2.5,field_3 的值变为 -> 2.5
handleResult(redis.Float64(conn.Do("HINCRBYFLOAT", "hash", "field_3", -1.5)))
}

如果哈希表包含的值非常大,可以先使用 HKEYS 取出所有的 field,然后再使用 HGET 取出值,防止一次取出多个大体积的值而导致服务器阻塞。 P48

有序集合 P48

一些常用的有序集合命令 P49
命令 格式 描述
ZADD ZADD key socre member [score member ...] 向有序集合中添加一个或多个元素及其分值
ZREM ZREM key member [member ...] 从有序集合中删除一个或多个元素及其分值
ZCARD ZCARD key 返回有序集合中元素的个数
ZINCRBY ZINCRBY key increment member 给有序集合中的元素的分值增加 increment
ZCOUNT ZCOUNT key min max 返回分值在 [min, max] 范围内的元素的数量
ZRANK ZRANK key member 返回元素的升序排名(升序,从 0 开始)
ZREVRANK ZREVRANK key member 返回元素的降序排名(降序,从 0 开始)
ZSCORE ZSCORE key member 返回元素的排名的分值
ZRANGE ZRANGE key start stop [WITHSCORES] 返回升序排名在 [start, stop] 范围内的元素,WITHSCORES 选项会同时在相应的元素后返回分值
ZRANRANGE ZRANGE key start stop [WITHSCORES] 返回降序排名在 [start, stop] 范围内的元素,WITHSCORES 选项会同时在相应的元素后返回分值

相关演示代码如下:

// 执行有序集合相关操作
func executeZsetOperation(conn redis.Conn) {
// 删除原有值
handleResult(redis.Int(conn.Do("DEL", "zset")))
// 有序集合中添加 5 个元素及其分值,输出 -> 5,zset 变为 -> ["a":1, "b":2, "c":3, "d":4, "e":5]
handleResult(redis.Int(conn.Do("ZADD", "zset", 1, "a", 2, "b", 3, "c", 4, "d", 5, "e")))
// 有序集合中删除 3 个元素及其分值,输出 -> 2,zset 变为 -> ["a":1, "b":2, "c":3]
handleResult(redis.Int(conn.Do("ZREM", "zset", "d", "e", "f")))
// 返回有序集合的元素个数,输出 -> 3
handleResult(redis.Int(conn.Do("ZCARD", "zset")))
// 给有序集合中的元素的分值增加 0.5,输出 -> 1.5,a 的值变为 -> 1.5
handleResult(redis.Int(conn.Do("ZINCRBY", "zset", 1, "a")))
// 给有序集合中的元素的分值增加 -1.5,输出 -> 0.5,a 的值变为 -> 0.5
handleResult(redis.Float64(conn.Do("ZINCRBY", "zset", -1.5, "a")))
// 返回分值在 [1, 3] 范围内的元素的数量,输出 -> 2
handleResult(redis.Int(conn.Do("ZCOUNT", "zset", 1, 3)))
// 返回元素的升序排名(升序,从 0 开始),输出 -> 0
handleResult(redis.Int(conn.Do("ZRANK", "zset", "a")))
// 返回元素的降序排名(降序,从 0 开始),输出 -> 2
handleResult(redis.Int(conn.Do("ZREVRANK", "zset", "a")))
// 返回元素的排名的分值,输出 -> 0.5
handleResult(redis.Float64(conn.Do("ZSCORE", "zset", "a")))
// 返回升序排名在 [1, 2] 范围内的元素,并且返回分值,输出 -> map[b:2 c:3]
handleResult(redis.StringMap(conn.Do("ZRANGE", "zset", "1", "2", "WITHSCORES")))
// 返回降序排名在 [1, 2] 范围内的元素,并且返回分值,输出 -> map[a:0.5 b:2]
handleResult(redis.StringMap(conn.Do("ZREVRANGE", "zset", "1", "2", "WITHSCORES")))
}
有序集合的范围性命令及并交集命令 P50
命令 格式 描述
ZRANGEBYSCORE ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count] 返回升序分值在 [min, max] 范围内的元素,WITHSCORES 选项会同时在相应的元素后返回分值
ZREVRANGEBYSCORE ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count] 返回降序分值在 [max, min] 范围内的元素,WITHSCORES 选项会同时在相应的元素后返回分值
ZREMRANGEBYRANK ZREMRANGEBYRANK key start stop 移除升序排名在 [start, stop] 范围内的元素
ZREMRANGEBYSCORE ZREMRANGEBYSCORE key min max 移除升序分值在 [min, max] 范围内的元素
ZINTERSTORE ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]]  [AGGREGATE SUM|MIN|MAX] 求一个或多个(有序)集合的交集,并存储到 destination 中,WEIGHTS 权重存在时,weight 数量必须等于 numkeys(集合默认分值为 1)
ZUNIONSTORE ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]]  [AGGREGATE SUM|MIN|MAX] 求一个或多个(有序)集合的并集,并存储到 destination 中,WEIGHTS 权重存在时,weight 数量必须等于 numkeys(集合默认分值为 1)

相关演示代码如下:

// 执行有序集合范围及交并集相关操作
func executeZsetMutiOperation(conn redis.Conn) {
// 删除原有值
handleResult(redis.Int(conn.Do("DEL", "zset_1", "zset_2", "destination")))
// 初始化
handleResult(redis.Int(conn.Do("ZADD", "zset_1", 1, "a", 2, "b", 3, "c")))
handleResult(redis.Int(conn.Do("ZADD", "zset_2", 2, "b", 3, "c", 4, "d")))
// 返回升序分值在 [1, 2] 范围内的元素,并且返回分值,输出 -> map[a:1 b:2]
handleResult(redis.StringMap(conn.Do("ZRANGEBYSCORE", "zset_1", "1", "2", "WITHSCORES")))
// 返回降序分值在 [4, 3] 范围内的元素,并且返回分值,输出 -> map[c:3 d:4]
handleResult(redis.StringMap(conn.Do("ZREVRANGEBYSCORE", "zset_2", "4", "3", "WITHSCORES")))
// 移除升序排名在 [1, 1] 范围内的元素,输出 -> 1,zset_1 变为 -> ["b":2, "c":3]
handleResult(redis.Int(conn.Do("ZREMRANGEBYRANK", "zset_1", "1", "1")))
// 移除降序排名在 [2, 2] 范围内的元素,输出 -> 1,zset_2 变为 -> ["c":3, "d":4]
handleResult(redis.Int(conn.Do("ZREMRANGEBYSCORE", "zset_2", "2", "2")))
// 求 2 个有序集合的交集,权重分别为 2, 3,分值默认采用加法
// 并存储到 destination 中,输出 -> 1,destination 变为 ->
handleResult(redis.Int(conn.Do("ZINTERSTORE", "destination", 2, "zset_1", "zset_2", "WEIGHTS", 2, 3)))
// 求 2 个有序集合的并集,权重分别为 2, 3,分值指定采用最大值
// 并存储到 destination 中,输出 -> 3,destination 变为 -> ["a":2, "c":9, "d":12]
handleResult(redis.Int(conn.Do("ZUNIONSTORE", "destination", 2, "zset_1", "zset_2", "WEIGHTS", 2, 3, "AGGREGATE", "MAX")))
}

所思所想

  • 这一章又是比较枯燥的命令介绍,不过还是坚持看下来了,发现还是挺有用的,有很多平常没接触的命令,也没想到 Redis 竟然这么强大。

  • 即使时比较精细地阅读,也不需要全部阅读,可以快速浏览已经知道的基础,重点还是要放在不知道的地方,带着思考去阅读,先想然后用实践验证。

本文首发于公众号:满赋诸机(点击查看原文) 开源在 GitHub :reading-notes/redis-in-action

Redis 实战 —— 04. Redis 数据结构常用命令简介的更多相关文章

  1. Redis启动服务和String常用命令

    Redis启动服务和String常用命令 1. 启动Redis服务 E:\redis>redis-server.exe redis.windows.conf _._ _.-``__ ''-._ ...

  2. Redis实战之Redis + Jedis

    用Memcached,对于缓存对象大小有要求,单个对象不得大于1MB,且不支持复杂的数据类型,譬如SET 等.基于这些限制,有必要考虑Redis! 相关链接: Redis实战 Redis实战之Redi ...

  3. Redis实战之Redis + Jedis[转]

    http://blog.csdn.net/it_man/article/details/9730605 2013-08-03 11:01 1786人阅读 评论(0) 收藏 举报   目录(?)[-] ...

  4. 第18章 Redis数据结构常用命令

    18-1 字符串的一些基本命令 18-1 :配置Spring关于Redis字符串的运行环境 <bean id="poolConfig" class="redis.c ...

  5. Redis各数据结构常用命令

    redis 通用API keys * 遍历所有key 一般不在生产环境中使用 redis单线程,容易阻塞其他命令执行 O(n) dbsize 计算key的总数 O(1)exists 检查key是否存在 ...

  6. Redis入门,Jedis和常用命令

    一.Redis简介 1.关于关系型数据库和nosql数据库 关系型数据库是基于关系表的数据库,最终会将数据持久化到磁盘上,而nosql数据     库是基于特殊的结构,并将数据存储到内存的数据库.从性 ...

  7. redis五种数据类型和常用命令及适用场景

    一.redis的5种数据类型: 1.基础理解: string 字符串(可以为整形.浮点型和字符串,统称为元素) list 列表(实现队列,元素不唯一,先入先出原则) set 集合(各不相同的元素) h ...

  8. Redis实战之Redis命令

    阅读目录 1. 字符串命令 2. 列表命令 3. 集合命令 4. 散列命令 5. 有序集合命令 6. 发布与订阅命令 7. 小试牛刀 Redis可以存储键与5种不同数据结构类型之间的映射,这5种数据结 ...

  9. Redis笔记,安装和常用命令

    转载于:http://www.itxuexiwang.com/a/shujukujishu/redis/2016/0216/96.html?1455870708 一.redis简单介绍 redis是N ...

  10. java redis client jedis 测试及常用命令

    package cn.byref.demo1; import java.util.HashMap;import java.util.List;import java.util.Map;import j ...

随机推荐

  1. 使用vlc进行二次开发做自己的播放器

    可参考: 使用vlc播放器做rtsp服务器 使用vlc播放器播放rtsp视频 web网页中使用vlc插件播放相机rtsp流视频 使用 https://github.com/ZeBobo5/Vlc.Do ...

  2. 【GOF23设计模式】责任链模式

    来源:http://www.bjsxt.com/ 一.[GOF23设计模式]_责任链模式.公文审批.供应链系统的采购审批.异常链.过滤器和拦截器调用过程 package com.test.chainO ...

  3. PHP学习笔记(1) - 开发环境搭建

    运行环境:phpstudy 它基本包括运行php应用需要的一切,php. apache.mysql,一键傻瓜安装 装好之后只需要配置虚拟主机和修改host文件就可以支持多站点 下载: http://w ...

  4. Document字段发生变化后,报的错

    2016-10-11 15:27:47,828 [ERROR] [main] SpringApplication:838 - Application startup failedorg.springf ...

  5. MediaPlayer 音频播放 示例

    状态机.流程图.生命周期 对播放音频/视频文件和流的控制是通过一个状态机来管理的.下图显示一个MediaPlayer对象被支持的播放控制操作驱动的生命周期和状态. 椭圆代表MediaPlayer对象可 ...

  6. C++ 3D物理引擎库BulletPhysics基本使用

    前言:最近在接触OpenGl和DX11的时候,顺便学习了Bullet这个3D物理引擎的基本使用,记录一下. |BulletPhysics介绍 BulletPhysics是一个跨平台的开源物理引擎,也是 ...

  7. day11-mysql中的mysql数据库不见了

    mysql中的mysql数据库不见了 昨天刚刚在vmware虚拟机的linux上安装mysql,今天登上就发现一个问题.通过网上漫长的寻找,终于解决了.所以我在这把我解决的步骤跟大家分享一下. 问题就 ...

  8. Windows下如何查看某个端口被谁占用

    开发时经常遇到端口被占用的情况,这个时候总是很令人抓狂,知道被哪个进程占用还好,结束就是了,要是不知道我们该怎么办呢? 我告诉大家一个方法,^_^. 1. 开始—->运行—->cmd,或者 ...

  9. NameNode内存溢出和DataNode请求超时异常处理

    问题背景 春节假期间,接连收到监控程序发出的数据异常问题,赶忙连接上跳板机检查各服务间的状态,发现Datanode在第二台.第三台从节点都掉线了,通过查看Datanode和Namenode运行日志,发 ...

  10. ElastAlert规则

    elastalert 是一款基于elasticsearch的开源告警产品(官方说明文档).相信许多人都会使用ELK做日志收集系统,但是产生一个基于日志的“优秀”的安全告警确是一个难题.告警规则难编写, ...