Redis 实战 —— 04. Redis 数据结构常用命令简介

• 2021 年 1 月 23 日
• 筆記
• Redis, Redis 实战

字符串 P39

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

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

Redis 中的自增命令和自减命令 P39

相关演示代码如下（main 及 handleResult 定义见：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

相关演示代码如下：

// 执行字符串类型字符串相关操作
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 可以通过使用子串操作和二进制位操作，配合 WATCH 、MULTI 和 EXEC 命令（后面会初步介绍，以后将深入讲解），构建任何想要的数据结构。

列表 P42

一些常用的列表命令 P42

相关演示代码如下：

// 执行列表类型相关操作
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

相关演示代码如下：

// 执行列表类型阻塞相关操作
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

相关演示代码如下：

// 执行集合类型相关操作
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

相关演示代码如下：

// 执行集合类型多个集合相关操作
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

相关演示代码如下：

// 执行哈希表类型相关操作
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

相关演示代码如下：

// 执行哈希表类型高级特性相关操作
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

相关演示代码如下：

// 执行有序集合相关操作
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

相关演示代码如下：

// 执行有序集合范围及交并集相关操作
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