Redis之数据类型及使用场景

淡淡的烟草味﹌ 2022-05-08 02:16 270阅读 0赞

Redis的key的数据类型为String，而value则支持多种不同的数据类型

常见的数据类型有：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)。

不常见的数据类型有：bitmap，geo，HyperLogLog。

# **一、String（字符串）** #

string是redis最基本的类型，一个key对应一个value。

string类型是二进制安全的。意思是redis的string可以包含任何数据。比如jpg图片或者序列化的对象 。

string类型是Redis最基本的数据类型，一个键最大能存储512MB。

**语法**

redis 127.0.0.1:6379> COMMAND KEY_NAME

**实例**

> redis 127.0.0.1:6379> SET w3ckey redis
> 
> OK
> 
> redis 127.0.0.1:6379> GET w3ckey "redis"

在以上实例中我们使用了 **SET** 和 **GET** 命令，键为 w3ckey。

**常用命令**

<table> 
 <tbody> 
  <tr> 
   <th>序号</th> 
   <th>命令及描述</th> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td><a href="https://www.w3cschool.cn/redis/strings-set.html" rel="nofollow">SET key value</a><br> 设置指定 key 的值</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><a href="https://www.w3cschool.cn/redis/strings-get.html" rel="nofollow">GET key</a><br> 获取指定 key 的值。</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><a href="https://www.w3cschool.cn/redis/strings-getrange.html" rel="nofollow">GETRANGE key start end</a><br> 返回 key 中字符串值的子字符</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td><a href="https://www.w3cschool.cn/redis/strings-getset.html" rel="nofollow">GETSET key value</a><br> 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td><a href="https://www.w3cschool.cn/redis/strings-getbit.html" rel="nofollow">GETBIT key offset</a><br> 对 key 所储存的字符串值，获取指定偏移量上的位(bit)。</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td><a href="https://www.w3cschool.cn/redis/strings-mget.html" rel="nofollow">MGET key1 [key2..]</a><br> 获取所有(一个或多个)给定 key 的值。</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td><a href="https://www.w3cschool.cn/redis/strings-setbit.html" rel="nofollow">SETBIT key offset value</a><br> 对 key 所储存的字符串值，设置或清除指定偏移量上的位(bit)。</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td><a href="https://www.w3cschool.cn/redis/strings-setex.html" rel="nofollow">SETEX key seconds value</a><br> 将值 value 关联到 key ，并将 key 的过期时间设为 seconds (以秒为单位)。</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td><a href="https://www.w3cschool.cn/redis/strings-setnx.html" rel="nofollow">SETNX key value</a><br> 只有在 key 不存在时设置 key 的值。</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td><a href="https://www.w3cschool.cn/redis/strings-setrange.html" rel="nofollow">SETRANGE key offset value</a><br> 用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始。</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td><a href="https://www.w3cschool.cn/redis/strings-strlen.html" rel="nofollow">STRLEN key</a><br> 返回 key 所储存的字符串值的长度。</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td><a href="https://www.w3cschool.cn/redis/strings-mset.html" rel="nofollow">MSET key value [key value ...]</a><br> 同时设置一个或多个 key-value 对。</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td><a href="https://www.w3cschool.cn/redis/strings-msetnx.html" rel="nofollow">MSETNX key value [key value ...]</a><br> 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在。</td> 
  </tr> 
  <tr> 
   <td>14</td> 
   <td><a href="https://www.w3cschool.cn/redis/strings-psetex.html" rel="nofollow">PSETEX key milliseconds value</a><br> 这个命令和 SETEX 命令相似，但它以毫秒为单位设置 key 的生存时间，而不是像 SETEX 命令那样，以秒为单位。</td> 
  </tr> 
  <tr> 
   <td>15</td> 
   <td><a href="https://www.w3cschool.cn/redis/strings-incr.html" rel="nofollow">INCR key</a><br> 将 key 中储存的数字值增一。</td> 
  </tr> 
  <tr> 
   <td>16</td> 
   <td><a href="https://www.w3cschool.cn/redis/strings-incrby.html" rel="nofollow">INCRBY key increment</a><br> 将 key 所储存的值加上给定的增量值（increment） 。</td> 
  </tr> 
  <tr> 
   <td>17</td> 
   <td><a href="https://www.w3cschool.cn/redis/strings-incrbyfloat.html" rel="nofollow">INCRBYFLOAT key increment</a><br> 将 key 所储存的值加上给定的浮点增量值（increment） 。</td> 
  </tr> 
  <tr> 
   <td>18</td> 
   <td><a href="https://www.w3cschool.cn/redis/strings-decr.html" rel="nofollow">DECR key</a><br> 将 key 中储存的数字值减一。</td> 
  </tr> 
  <tr> 
   <td>19</td> 
   <td><a href="https://www.w3cschool.cn/redis/strings-decrby.html" rel="nofollow">DECRBY key decrement</a><br> key 所储存的值减去给定的减量值（decrement） 。</td> 
  </tr> 
  <tr> 
   <td>20</td> 
   <td><a href="https://www.w3cschool.cn/redis/strings-append.html" rel="nofollow">APPEND key value</a><br> 如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。</td> 
  </tr> 
 </tbody> 
</table>

使用场景：

*  缓存功能：String字符串是最常用的数据类型，不仅仅是Redis，各个语言都是最基本类型，因此，利用Redis作为缓存，配合其它数据库作为存储层，利用Redis支持高并发的特点，可以大大加快系统的读写速度、以及降低后端数据库的压力。
 *  计数器：许多系统都会使用Redis作为系统的实时计数器，可以快速实现计数和查询的功能。而且最终的数据结果可以按照特定的时间落地到数据库或者其它存储介质当中进行永久保存。
 *  共享用户Session：用户重新刷新一次界面，可能需要访问一下数据进行重新登录，或者访问页面缓存Cookie，但是可以利用Redis将用户的Session集中管理，在这种模式只需要保证Redis的高可用，每次用户Session的更新和获取都可以快速完成。大大提高效率。
 *  分布式锁
 *  分布式系统全局序列号

# **二、Hash（哈希）** #

Redis hash 是一个string类型的field和value的映射表，hash特别适合用于存储对象。

Redis 中每个 hash 可以存储 2^32- 1 键值对（40多亿）。

**实例**

> `redis 127.0.0.1:6379> HMSET w3ckey name "redis tutorial" description "redis basic commands for caching" likes 20 visitors 23000 OK redis 127.0.0.1:6379> HGETALL w3ckey 1) "name" 2) "redis tutorial" 3) "description" 4) "redis basic commands for caching" 5) "likes" 6) "20" 7) "visitors" 8) "23000"`

在以上实例中，我们设置了 redis 的一些描述信息(name, description, likes, visitors) 到哈希表的 w3ckey 中。

每个 hash 可以存储 2^32- 1 键值对（40多亿）。

**常用命令**

<table> 
 <tbody> 
  <tr> 
   <th>序号</th> 
   <th>命令及描述</th> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td><a href="https://www.w3cschool.cn/redis/hashes-hdel.html" rel="nofollow">HDEL key field2 [field2]</a><br> 删除一个或多个哈希表字段</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><a href="https://www.w3cschool.cn/redis/hashes-hexists.html" rel="nofollow">HEXISTS key field</a><br> 查看哈希表 key 中，指定的字段是否存在。</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><a href="https://www.w3cschool.cn/redis/hashes-hget.html" rel="nofollow">HGET key field</a><br> 获取存储在哈希表中指定字段的值</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td><a href="https://www.w3cschool.cn/redis/hashes-hgetall.html" rel="nofollow">HGETALL key</a><br> 获取在哈希表中指定 key 的所有字段和值</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td><a href="https://www.w3cschool.cn/redis/hashes-hincrby.html" rel="nofollow">HINCRBY key field increment</a><br> 为哈希表 key 中的指定字段的整数值加上增量 increment 。</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td><a href="https://www.w3cschool.cn/redis/hashes-hincrbyfloat.html" rel="nofollow">HINCRBYFLOAT key field increment</a><br> 为哈希表 key 中的指定字段的浮点数值加上增量 increment 。</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td><a href="https://www.w3cschool.cn/redis/hashes-hkeys.html" rel="nofollow">HKEYS key</a><br> 获取所有哈希表中的字段</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td><a href="https://www.w3cschool.cn/redis/hashes-hlen.html" rel="nofollow">HLEN key</a><br> 获取哈希表中字段的数量</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td><a href="https://www.w3cschool.cn/redis/hashes-hmget.html" rel="nofollow">HMGET key field1 [field2]</a><br> 获取所有给定字段的值</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td><a href="https://www.w3cschool.cn/redis/hashes-hmset.html" rel="nofollow">HMSET key field1 value1 [field2 value2 ]</a><br> 同时将多个 field-value (域-值)对设置到哈希表 key 中。</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td><a href="https://www.w3cschool.cn/redis/hashes-hset.html" rel="nofollow">HSET key field value</a><br> 将哈希表 key 中的字段 field 的值设为 value 。</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td><a href="https://www.w3cschool.cn/redis/hashes-hsetnx.html" rel="nofollow">HSETNX key field value</a><br> 只有在字段 field 不存在时，设置哈希表字段的值。</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td><a href="https://www.w3cschool.cn/redis/hashes-hvals.html" rel="nofollow">HVALS key</a><br> 获取哈希表中所有值</td> 
  </tr> 
  <tr> 
   <td>14</td> 
   <td>HSCAN key cursor [MATCH pattern] [COUNT count]<br> 迭代哈希表中的键值对。</td> 
  </tr> 
 </tbody> 
</table>

使用场景：

*  适用于存储对象，比如把用户的信息存到hash里，以用户id为key，用户的详细信息为value。
 *  电商购物车，以用户ID为key，商品ID为field，商品数量为value。

# **三、List（列表）** #

Redis列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素导列表的头部（左边）或者尾部（右边）

一个列表最多可以包含 2^32- 1 个元素 (4294967295, 每个列表超过40亿个元素)。

**实例**

> `redis 127.0.0.1:6379> LPUSH w3ckey redis (integer) 1 redis 127.0.0.1:6379> LPUSH w3ckey mongodb (integer) 2 redis 127.0.0.1:6379> LPUSH w3ckey mysql (integer) 3 redis 127.0.0.1:6379> LRANGE w3ckey 0 10 1) "mysql" 2) "mongodb" 3) "redis"`

在以上实例中我们使用了 **LPUSH** 将三个值插入了名为 w3ckey 的列表当中。

<table> 
 <tbody> 
  <tr> 
   <th>序号</th> 
   <th>命令及描述</th> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td><a href="https://www.w3cschool.cn/redis/lists-blpop.html" rel="nofollow">BLPOP key1 [key2 ] timeout</a><br> 移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><a href="https://www.w3cschool.cn/redis/lists-brpop.html" rel="nofollow">BRPOP key1 [key2 ] timeout</a><br> 移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><a href="https://www.w3cschool.cn/redis/lists-brpoplpush.html" rel="nofollow">BRPOPLPUSH source destination timeout</a><br> 从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它； 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td><a href="https://www.w3cschool.cn/redis/lists-lindex.html" rel="nofollow">LINDEX key index</a><br> 通过索引获取列表中的元素</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td><a href="https://www.w3cschool.cn/redis/lists-linsert.html" rel="nofollow">LINSERT key BEFORE|AFTER pivot value</a><br> 在列表的元素前或者后插入元素</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td><a href="https://www.w3cschool.cn/redis/lists-llen.html" rel="nofollow">LLEN key</a><br> 获取列表长度</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td><a href="https://www.w3cschool.cn/redis/lists-lpop.html" rel="nofollow">LPOP key</a><br> 移出并获取列表的第一个元素</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td><a href="https://www.w3cschool.cn/redis/lists-lpush.html" rel="nofollow">LPUSH key value1 [value2]</a><br> 将一个或多个值插入到列表头部</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td><a href="https://www.w3cschool.cn/redis/lists-lpushx.html" rel="nofollow">LPUSHX key value</a><br> 将一个或多个值插入到已存在的列表头部</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td><a href="https://www.w3cschool.cn/redis/lists-lrange.html" rel="nofollow">LRANGE key start stop</a><br> 获取列表指定范围内的元素</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td><a href="https://www.w3cschool.cn/redis/lists-lrem.html" rel="nofollow">LREM key count value</a><br> 移除列表元素</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td><a href="https://www.w3cschool.cn/redis/lists-lset.html" rel="nofollow">LSET key index value</a><br> 通过索引设置列表元素的值</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td><a href="https://www.w3cschool.cn/redis/lists-ltrim.html" rel="nofollow">LTRIM key start stop</a><br> 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。</td> 
  </tr> 
  <tr> 
   <td>14</td> 
   <td><a href="https://www.w3cschool.cn/redis/lists-rpop.html" rel="nofollow">RPOP key</a><br> 移除并获取列表最后一个元素</td> 
  </tr> 
  <tr> 
   <td>15</td> 
   <td><a href="https://www.w3cschool.cn/redis/lists-rpoplpush.html" rel="nofollow">RPOPLPUSH source destination</a><br> 移除列表的最后一个元素，并将该元素添加到另一个列表并返回</td> 
  </tr> 
  <tr> 
   <td>16</td> 
   <td><a href="https://www.w3cschool.cn/redis/lists-rpush.html" rel="nofollow">RPUSH key value1 [value2]</a><br> 在列表中添加一个或多个值</td> 
  </tr> 
  <tr> 
   <td>17</td> 
   <td><a href="https://www.w3cschool.cn/redis/lists-rpushx.html" rel="nofollow">RPUSHX key value</a><br> 为已存在的列表添加值</td> 
  </tr> 
 </tbody> 
</table>

使用场景：

*  Stack栈：LPUSH+LPOP
 *  Queue队列：LPUSH+RPOP
 *  Blocking MQ阻塞队列：LPUSH+BRPOP
 *  最新列表，List 类型的 lpush 命令和 lrange 命令能实现最新列表的功能，每次通过 lpush 命令往列表里插入新的元素，然后通过 lrange 命令读取最新的元素列表，如朋友圈的点赞列表、评论列表：

1、A关注了B，C等大V

2、B发微博了，消息ID为1001：LPUSH msg：\{A的ID\}  1001

3、C发微博了，消息ID为1002：LPUSH msg：\{A的ID\}  1002

4、A查看最新的5条微博消息：LRANGE msg：\{A的ID\}  0 5

# **四、Set（集合）** #

Redis的Set是string类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。

Redis 中 集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。

集合中最大的成员数为 2^32- 1 (4294967295, 每个集合可存储40多亿个成员)。

**实例**

> `redis 127.0.0.1:6379> SADD w3ckey redis (integer) 1 redis 127.0.0.1:6379> SADD w3ckey mongodb (integer) 1 redis 127.0.0.1:6379> SADD w3ckey mysql (integer) 1 redis 127.0.0.1:6379> SADD w3ckey mysql (integer) 0 redis 127.0.0.1:6379> SMEMBERS w3ckey 1) "mysql" 2) "mongodb" 3) "redis"`

在以上实例中我们通过 **SADD** 命令向名为 w3ckey 的集合插入的三个元素。

**常用命令**

<table> 
 <tbody> 
  <tr> 
   <th>序号</th> 
   <th>命令及描述</th> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td><a href="https://www.w3cschool.cn/redis/sets-sadd.html" rel="nofollow">SADD key member1 [member2]</a><br> 向集合添加一个或多个成员</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><a href="https://www.w3cschool.cn/redis/sets-scard.html" rel="nofollow">SCARD key</a><br> 获取集合的成员数</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><a href="https://www.w3cschool.cn/redis/sets-sdiff.html" rel="nofollow">SDIFF key1 [key2]</a><br> 返回给定所有集合的差集</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td><a href="https://www.w3cschool.cn/redis/sets-sdiffstore.html" rel="nofollow">SDIFFSTORE destination key1 [key2]</a><br> 返回给定所有集合的差集并存储在 destination 中</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td><a href="https://www.w3cschool.cn/redis/sets-sinter.html" rel="nofollow">SINTER key1 [key2]</a><br> 返回给定所有集合的交集</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td><a href="https://www.w3cschool.cn/redis/sets-sinterstore.html" rel="nofollow">SINTERSTORE destination key1 [key2]</a><br> 返回给定所有集合的交集并存储在 destination 中</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td><a href="https://www.w3cschool.cn/redis/sets-sismember.html" rel="nofollow">SISMEMBER key member</a><br> 判断 member 元素是否是集合 key 的成员</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td><a href="https://www.w3cschool.cn/redis/sets-smembers.html" rel="nofollow">SMEMBERS key</a><br> 返回集合中的所有成员</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td><a href="https://www.w3cschool.cn/redis/sets-smove.html" rel="nofollow">SMOVE source destination member</a><br> 将 member 元素从 source 集合移动到 destination 集合</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td><a href="https://www.w3cschool.cn/redis/sets-spop.html" rel="nofollow">SPOP key</a><br> 移除并返回集合中的一个随机元素</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td><a href="https://www.w3cschool.cn/redis/sets-srandmember.html" rel="nofollow">SRANDMEMBER key [count]</a><br> 返回集合中一个或多个随机数</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td><a href="https://www.w3cschool.cn/redis/sets-srem.html" rel="nofollow">SREM key member1 [member2]</a><br> 移除集合中一个或多个成员</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td><a href="https://www.w3cschool.cn/redis/sets-sunion.html" rel="nofollow">SUNION key1 [key2]</a><br> 返回所有给定集合的并集</td> 
  </tr> 
  <tr> 
   <td>14</td> 
   <td><a href="https://www.w3cschool.cn/redis/sets-sunionstore.html" rel="nofollow">SUNIONSTORE destination key1 [key2]</a><br> 所有给定集合的并集存储在 destination 集合中</td> 
  </tr> 
  <tr> 
   <td>15</td> 
   <td><a href="https://www.w3cschool.cn/redis/sets-sscan.html" rel="nofollow">SSCAN key cursor [MATCH pattern] [COUNT count]</a><br> 迭代集合中的元素</td> 
  </tr> 
 </tbody> 
</table>

--------------------

使用场景：

*  给用户添加标签，跟我们上面的例子一样。一个人对应多个不同的标签。
 *  好友/关注/粉丝/感兴趣的人集合，可以使用上面的取交集、并集相关的命令。
 *  随机展示，通过 srandmember 随机返回对应的内容，像一些首页获取动态内容可以这么玩。
 *  黑名单/白名单，有业务出于安全性方面的考虑，需要设置用户黑名单、ip 黑名单、设备黑名单等，set 类型适合存储这些黑名单数据，sismember 命令可用于判断用户、ip、设备是否处于黑名单之中。
 *  微信抽奖小程序

1、点击参与抽奖加入集合：SADD item:1001   \{userID\}

2、查看参与抽奖的所有用户：SMEMBERS item:1001

3、抽取3名中奖者：SRANDMEMBER/SPOP item:1001 3   (SRANDMEMBER后，中奖的用户不会从集合中移除，SPOP 后，中奖的用户会从集合中移除)

# **五、zset(sorted set：有序集合)** #

Redis 有序集合和集合一样也是string类型元素的集合,且不允许重复的成员。

不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。

有序集合的成员是唯一的,但分数(score)却可以重复。

集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。 集合中最大的成员数为 2^32- 1 (4294967295, 每个集合可存储40多亿个成员)。

**实例**

> `redis 127.0.0.1:6379> ZADD w3ckey 1 redis (integer) 1 redis 127.0.0.1:6379> ZADD w3ckey 2 mongodb (integer) 1 redis 127.0.0.1:6379> ZADD w3ckey 3 mysql (integer) 1 redis 127.0.0.1:6379> ZADD w3ckey 3 mysql (integer) 0 redis 127.0.0.1:6379> ZADD w3ckey 4 mysql (integer) 0 redis 127.0.0.1:6379> ZRANGE w3ckey 0 10 WITHSCORES 1) "redis" 2) "1" 3) "mongodb" 4) "2" 5) "mysql" 6) "4"`

**常用命令**

<table> 
 <tbody> 
  <tr> 
   <th>序号</th> 
   <th>命令及描述</th> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td><a href="https://www.w3cschool.cn/redis/sorted-sets-zadd.html" rel="nofollow">ZADD key score1 member1 [score2 member2]</a><br> 向有序集合添加一个或多个成员，或者更新已存在成员的分数</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><a href="https://www.w3cschool.cn/redis/sorted-sets-zcard.html" rel="nofollow">ZCARD key</a><br> 获取有序集合的成员数</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><a href="https://www.w3cschool.cn/redis/sorted-sets-zcount.html" rel="nofollow">ZCOUNT key min max</a><br> 计算在有序集合中指定区间分数的成员数</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td><a href="https://www.w3cschool.cn/redis/sorted-sets-zincrby.html" rel="nofollow">ZINCRBY key increment member</a><br> 有序集合中对指定成员的分数加上增量 increment</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td><a href="https://www.w3cschool.cn/redis/sorted-sets-zinterstore.html" rel="nofollow">ZINTERSTORE destination numkeys key [key ...]</a><br> 计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td><a href="https://www.w3cschool.cn/redis/sorted-sets-zlexcount.html" rel="nofollow">ZLEXCOUNT key min max</a><br> 在有序集合中计算指定字典区间内成员数量</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td><a href="https://www.w3cschool.cn/redis/sorted-sets-zrange.html" rel="nofollow">ZRANGE key start stop [WITHSCORES]</a><br> 通过索引区间返回有序集合成指定区间内的成员</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td><a href="https://www.w3cschool.cn/redis/sorted-sets-zrangebylex.html" rel="nofollow">ZRANGEBYLEX key min max [LIMIT offset count]</a><br> 通过字典区间返回有序集合的成员</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td><a href="https://www.w3cschool.cn/redis/sorted-sets-zrangebyscore.html" rel="nofollow">ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT]</a><br> 通过分数返回有序集合指定区间内的成员</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td><a href="https://www.w3cschool.cn/redis/sorted-sets-zrank.html" rel="nofollow">ZRANK key member</a><br> 返回有序集合中指定成员的索引</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td><a href="https://www.w3cschool.cn/redis/sorted-sets-zrem.html" rel="nofollow">ZREM key member [member ...]</a><br> 移除有序集合中的一个或多个成员</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td><a href="https://www.w3cschool.cn/redis/sorted-sets-zremrangebylex.html" rel="nofollow">ZREMRANGEBYLEX key min max</a><br> 移除有序集合中给定的字典区间的所有成员</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td><a href="https://www.w3cschool.cn/redis/sorted-sets-zremrangebyrank.html" rel="nofollow">ZREMRANGEBYRANK key start stop</a><br> 移除有序集合中给定的排名区间的所有成员</td> 
  </tr> 
  <tr> 
   <td>14</td> 
   <td><a href="https://www.w3cschool.cn/redis/sorted-sets-zremrangebyscore.html" rel="nofollow">ZREMRANGEBYSCORE key min max</a><br> 移除有序集合中给定的分数区间的所有成员</td> 
  </tr> 
  <tr> 
   <td>15</td> 
   <td><a href="https://www.w3cschool.cn/redis/sorted-sets-zrevrange.html" rel="nofollow">ZREVRANGE key start stop [WITHSCORES]</a><br> 返回有序集中指定区间内的成员，通过索引，分数从高到底</td> 
  </tr> 
  <tr> 
   <td>16</td> 
   <td><a href="https://www.w3cschool.cn/redis/sorted-sets-zrevrangebyscore.html" rel="nofollow">ZREVRANGEBYSCORE key max min [WITHSCORES]</a><br> 返回有序集中指定分数区间内的成员，分数从高到低排序</td> 
  </tr> 
  <tr> 
   <td>17</td> 
   <td><a href="https://www.w3cschool.cn/redis/sorted-sets-zrevrank.html" rel="nofollow">ZREVRANK key member</a><br> 返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序</td> 
  </tr> 
  <tr> 
   <td>18</td> 
   <td><a href="https://www.w3cschool.cn/redis/sorted-sets-zscore.html" rel="nofollow">ZSCORE key member</a><br> 返回有序集中，成员的分数值</td> 
  </tr> 
  <tr> 
   <td>19</td> 
   <td><a href="https://www.w3cschool.cn/redis/sorted-sets-zunionstore.html" rel="nofollow">ZUNIONSTORE destination numkeys key [key ...]</a><br> 计算给定的一个或多个有序集的并集，并存储在新的 key 中</td> 
  </tr> 
  <tr> 
   <td>20</td> 
   <td><a href="https://www.w3cschool.cn/redis/sorted-sets-zscan.html" rel="nofollow">ZSCAN key cursor [MATCH pattern] [COUNT count]</a><br> 迭代有序集合中的元素（包括元素成员和元素分值）</td> 
  </tr> 
 </tbody> 
</table>

使用场景：

*  标签：比如我们博客网站常常使用到的兴趣标签，把一个个有着相同爱好，关注类似内容的用户利用一个标签把他们进行归并。
 *  共同好友功能，共同喜好，或者可以引申到二度好友之类的扩展应用。
 *  统计网站的独立 IP。利用 set 集合当中元素不唯一性，可以快速实时统计访问网站的独立 IP。
 *  统计用户的点赞/取消点赞
 *  排行榜功能，比如展示获取赞数最多的十个用户
 *  Zset本质就是Set结构上加了个排序的功能，除了添加数据value之外，还提供另一属性score，这一属性在添加修改元素时候可以指定，每次指定后，Zset会自动重新按新的值调整顺序。可以理解为有两列字段的数据表，一列存value,一列存顺序编号。操作中key理解为zset的名字，那么对延时队列又有何用呢？试想如果score代表的是想要执行时间的时间戳，在某个时间将它插入Zset集合中，它变会按照时间戳大小进行排序，也就是对执行时间前后进行排序，这样的话，起一个死循环线程不断地进行取第一个key值，如果当前时间戳大于等于该key值的socre就将它取出来进行消费删除，就可以达到延时执行的目的, 注意不需要遍历整个Zset集合，以免造成性能浪费。

# **六、bitmap** #

按字面意思来拆分一下`bit`和`map`。首先`bit`比特是二进制单位( binary unit)或二进制数字(binary digit)的缩写，是电脑记忆体中最小的单位，在二进位电脑系统中，每一`bit` 可以代表`0` 或 `1`（也就是二进制） 的数位讯号（非黑即白，非 0 即 1）。  
`map`这个的话好哥哥们很熟悉了吧，像`Java`(这不会不知道，世界上最好的语言，没有之一)中的`HashMap`。  
在`Redis`中，`Bitmaps`本身不是一种数据结构，可以把`Bitmaps`想象成一个以`位`为单位的数组，数组的每个单元只能存储`0`和`1`，数组的下标在`Bitmaps`中叫做偏移量。实际上它就是字符串，但是它可以对字符串的位进行操作。

二进制表示字符串

好哥哥就会问了，那要怎么用`bit`来表示一个字符串呢？ 那我就勉为其难的举个栗子，用`bit` 来表示`Dawn`。首先`Dawn`对应字母的`ASCII`码分别是`68`、`97`、`119`、`110`。那`bit`又只能存`0` 或 `1`，所以我们把对应的`ASCII`码转换成二进制得到`01000100`、`01100001`、`01110111`、`01101110`(一个字节`Byte`占八位`bit`)。如下图

![Dawn][]

`ASCII`码表

![ASCII][]

Bitmaps 存储结构

上面我们已经知道`Bitmaps`大概的一些概念，那在 Redis 中它是个什么样子的呢？实际上是差不多的，把对应的二进制字符串存入当成 value，这样是不是就可以对字符串进行做位进制的计算了，如图  
![bitmaps][]

**实例**

背景：将每个独立用户是否访问过网站存放在`Bitmaps`中，将访问的用户 记做`1`，没有访问的用户记做`0`，用偏移量作为用户的 id。

设值

设置键的第`offset`个位的值（从 0 算起），假设现在有 20 个用户， `userid=0，5，11，15，19`的用户对网站进行了访问，那么当前 Bitmaps 初始化结果如下图。  
![bitmaps][bitmaps 1]

## 格式 key:键， offset:下标偏移量， value: 0或1
    setbit key offset value
    ## 具体的操作过程
    127.0.0.1:6379> setbit unique:users:2020-12-13 0 1
    (integer) 0
    127.0.0.1:6379> setbit unique:users:2020-12-13 5 1
    (integer) 0
    127.0.0.1:6379> setbit unique:users:2020-12-13 11 1
    (integer) 0
    127.0.0.1:6379> setbit unique:users:2020-12-13 15 1
    (integer) 0
    127.0.0.1:6379> setbit unique:users:2020-12-13 19 1
    (integer) 0
    复制代码

如果此时有一个`userid=50`的用户访问了网站，那么 Bitmaps 的结构变成如下图，第 20 位~49 位都是 0。

![50][]  
平时我们很多应用的用户`id`以一个指定数字（例如 10000 或者使用雪花算法产生）开头，直接将用户`id`和`Bitmaps`的偏移量对应势必会造成一定的浪费，通常的做法是每次做`setbit`操作时将用户 id 减去这个指定数字。在第一次初始化 Bitmaps 时，假如偏移量非常大，那么整个初始化过程执行会比较慢，可能会造成 Redis 的阻塞。

取值

如果我们需要获取用户 id 为 11 在 2020-12-13 是否有访问过网站，就可以使用以下的命令

## 格式 key:键， offset:下标偏移量
    gitbit key offset
    ## 获取结果就是0或者1，如果offset在key中不存在则返回0
    127.0.0.1:6379> getbit unique:users:2020-12-13 11
    (integer) 1
    复制代码

获取 Bitmaps 指定范围内值为 1 的个数

按天统计访问过网站的用户数量

127.0.0.1:6379> bitcount unique:users:2020-12-13
    (integer) 5
    复制代码

如果要计算用户 id 在第 1 个字节（一个字节等于 8 位，0-17offset）到第 3 个字节之间的独立访问用户数，对应的用户 id 是 11，15，19。

## 格式 [start]和[end]代表起始和结束字节数
    bitcount [start][end]
    ## 返回统计结果
    127.0.0.1:6379> bitcount unique:users:2020-12-13 1 3
    (integer) 3
    复制代码

Bitmaps 间的运算

`bitop`是一个复合操作，它可以做多个`Bitmaps`的`and`（交集）、`or`（并集）、`not`（非）、`xor`（异或）操作并将结果保存在`destkey`中。  
举个栗子，假设 2020-12-12 访问网站的 userid 为 1、2、5、9。  
**交集**: 计算出 2020-12-12 和 2020-12-13 两天都访问过网站的用户数量

## 格式 op: 具体操作（and or）,destkey: 结果集
    bitop op destkey key[key....]
    ## 取交集
    127.0.0.1:6379> bitop and unique:users:and:2020-12-12_13 unique:users:2020-12-12
    unique:users:2020-12-13
    (integer) 2
    127.0.0.1:6379> bitcount unique:users:and:2020-12-12_13
    (integer) 2
    复制代码

**并集**: 算出 2020-12-12 和 2020-12-13 任意一天都访问过网站的用户数量（例如月活跃就是类似这种）

## 取并集
    127.0.0.1:6379> bitop or unique:users:or:2020-12-12_13 unique:users:2020-12-12 unique:users:2020-12-13
    (integer) 2
    127.0.0.1:6379> bitcount unique:users:or:2020-12-12_13
    (integer) 6
    复制代码

计算 Bitmaps 中第一个值为 targetBit 的偏移量

例如我们要计算在 2020-12-13 在第 0 个字节到第 1 个字节之间访问网站的最小用户 id

## 格式 targetBit: 0或者1，[start]和[end]代表起始和结束字节数，和上面一样
    bitpos key targetBit [start] [end]
    ## 栗子
    127.0.0.1:6379> bitpos unique:users:2020-12-13 0 0 1
    (integer) 0
    复制代码

**对比**

大数据量和高日活量场景下。假设网站有 1 亿用户，每天独立访问的用户有 5 千万，如果每天用集合类型和 Bitmaps 分别存储活跃用户结果图  
![日活][9b3e3ee0edd91f34268b5e4e72f3d0a8.png]  
看到区别了吗。很明显，这种情况下使用 Bitmaps 能节省很多的内存空间，尤其是随着时间推移节省的内存还是非常可观的  
![统计][1145954680125ddf6af19d9b15445ef0.png]  
但是如果说这个网站的用户量很少，假设只有 10 万，那么使用 Bitmaps（基数太大）就不是很合适了，大量的值都是 0。 ![基数][3262210009ab76880106d0cd2e3f1a6e.png]

使用场景：

1.  统计网站的日/月活量
2.  用户按天签到
3.  统计用户登录、在线等状态
4.  实现布隆过滤器，不熟悉的可以看[布隆过滤器这一篇就够了][Link 1]

**总结**

合理使用`Bitmaps`是能极大的减少内存空间的占用，在某些只有两个状态的统计中，性能也是非常好的。但是在**值存储**状态上来说`Bitmaps`的值实际上只能存`bit`，也就是说只能存 0 或者 1。这也就意味着我们需要统计或者标记的状态不能超过两个，例如男或者女，当某种神秘力量出现第三种其他性别时就无法完成统计或者标记。这也是使用`Bitmaps`的一个局限性。

# **七、geo** #

Redis3.2 版本提供了`GEO`（地理信息定位）功能，`GEO` 主要用于存储地理位置信息，并对存储的信息进行操作，用于实现诸如附近位置、摇一摇这类依赖于地理位置信息的功能，对于需要实现这些功能的开发者来说是一大福音。

命令

增加地理位置信息

Redis 提供`geoadd`命令来添加或者更新地理信息位置，其中`longitude`、`latitude`、`member`分别是该地理位置的经度、纬度、成员。添加如下图的城市经纬度 ![城市经纬度][dc45ebf03186fe322f036a5bf2f9da73.png]

## 格式
    geoadd key longitude latitude member [longitude latitude member ...]
    ## 添加北京，返回结果代表添加成功的个数，假如已经存在了则返回0
    127.0.0.1:6379> geoadd cities:locations 116.28 39.55 beijing
    (integer) 1
    复制代码

获取地理信息位置

## 格式 ，member 成员
    geopos key member [member ...]
    ## 获取天津的地理位置
    127.0.0.1:6379> geopos cities:locations tianjin
    1) 1) "117.12000042200088501"
    2) "39.0800000535766543"
    复制代码

获取两个地理位置的距离

`Redis`提供了`geodist`来获取两个地理位置的距离。其中`unit`代表返回结果的单位，包含以下四种：

1.  m（meters）代表米。
2.  km（kilometers）代表公里。
3.  mi（miles）代表英里。
4.  ft（feet）代表尺。

## 格式
    geodist key member1 member2 [unit]
    ## 计算北京到天津的距离
    127.0.0.1:6379> geodist cities:locations tianjin beijing km
    "89.2061"
    复制代码

获取指定位置范围内的地理信息位置集合

`georadius`和`georadiusbymember`两个命令的作用是一样的，都是以一个地 理位置为中心算出指定半径内的其他地理信息位置，不同的是`georadius`命令 的中心位置给出了具体的经纬度，`georadiusbymember`只需给出成员即可。其 中`radiusm|km|ft|mi`是必需参数，指定了半径（带单位），这两个命令有很多 可选参数，如下：

1.  withcoord：返回结果中包含经纬度。
2.  withdist：返回结果中包含离中心节点位置的距离。
3.  withhash：返回结果中包含 geohash，有关 geohash 后面介绍。
4.  COUNT count：指定返回结果的数量。
5.  asc|desc：返回结果按照离中心节点的距离做升序或者降序。
6.  store key：将返回结果的地理位置信息保存到指定键。
7.  storedist key：将返回结果离中心节点的距离保存到指定键。

## 格式
    georadius key longitude latitude radiusm|km|ft|mi [withcoord] [withdist] [withhash] [COUNT count] [asc|desc] [store key] [storedist key]
    ## 格式
    georadiusbymember key member radiusm|km|ft|mi [withcoord] [withdist]
    [withhash] [COUNT count] [asc|desc] [store key] [storedist key]
    ## 计算五座城市中，距离北京150公里以内的城市
    127.0.0.1:6379> georadiusbymember cities:locations beijing 150 km
    1) "beijing"
    2) "tianjin"
    3) "tangshan"
    4) "baoding"
    复制代码

获取 GeoHash

GeoHash

`GeoHash`本质上是空间索引的一种方式，其基本原理是将地球理解为一个二维平面，将平面递归分解成更小的子块，每个子块在一定经纬度范围内拥有相同的编码。以 GeoHash 方式建立空间索引，可以提高对空间 poi 数据进行经纬度检索的效率。具体可以看[Geohash 原理][Geohash] 使用 `geohash` 将二维经纬度转换为一维字符串，`geohash`有如下特点：

1.  `GEO` 的数据类型为`zset`，Redis 将所有地理位置信息的`geohash`存放在`zset`中。
2.  字符串越长，表示的位置更精确，例如`geohash`长度为 9 时，精度在 2 米左右。如下图
3.  两个字符串越相似，它们之间的距离越近，Redis 利用字符串前缀匹配算法实现相关的命令。
4.  `geohash`编码和经纬度是可以相互转换的。

![长度][f2fef8c09decd02fd75bd54e1ed5132b.png]

## 格式
    geohash key member [member ...]
    ## 计算北京的geohash
    127.0.0.1:6379> geohash cities:locations beijing
    1) "wx4ww02w070"
    复制代码

删除地理位置信息

`GEO`没有提供删除成员的命令，但是因为`GEO`的底层实现是`zset`，所以 可以借用`zrem`命令实现对地理位置信息的删除。

## 格式
    zrem key member
    127.0.0.1:6379> zrem cities:locations beijing
    1
    复制代码

原理

增加地理位置原理

上面有说`GEO`的底层数据结构是`zset(sorted set)`，这个基本的数据结构不了解的话可以看[Redis Sorted Set 运用场景、API 解析][Redis Sorted Set _API]。先看一个`zset`的新增命令`zadd key score member [score member ...]`，好哥哥们发现了吗，是不是很相似。有比较杠的好哥哥就会说了，这哪里相似，`GEO`明显有经纬度两个值，而`zset`只有一个`score`。是的，实际上这个地方是运用了一个算法那就是通过经纬度计算出对应的 52 位（`bit`）的 `GEOHASH`（这个其实也是一个算法，上面有提到过） 值作为元素的 `Score`值。那这样是不是就和`zset`一样了呢。所以其存储的原理和`zset`是一样的，只是多了一个计算`Score`值的过程。

geohash 原理分析

这个实际上上面已经有提到了，如果好哥哥们没有看懂那篇的话猛男我又找了一篇比较好懂的，可以看下[GeoHash 核心原理解析][GeoHash]，如果不想看的话那我总结如下（好哥哥们我都这样了你确定还不点赞加个关注吗）。 理解`GeoHash`需要解决以下两个问题：

1.  如何唯一表示地球上的一块空间？
2.  如何将地球切分成大小近似的区块，并支持不同粒度的表示？

**方案：**

1.  将三维地球变成二维: 地球纬度区间是\[-90,90\],经度区间是\[-180,180\]。 将它展开想象成一个很大的矩形。
2.  将二维再转成一维： 通过第一步的方法，我们能够将地球的表面转换成二维空间的平面。那接下来要将二维转变成一维。如果切割二维空间，可以切割出很多正方形。如何表示这个正方形呢？最简单的方法是在平面上进行遍历。每遍历到一个点，就给它标注一个值，比如 00、01、10、11，随着二进制数字增加，相当于遍历面上不同的位置。当将空间划分为四块时候，编码的顺序分别是左下角 00，左上角 01，右下脚 10，右上角 11，也就是类似于 Z 的曲线。
3.  将一维表示成二进制码存储： `Geohash` 也有几种编码形式，常见的有 2 种，`base 32`和 `base 36`。 会将落到网格中的二进制数据编码成字符串。

使用场景：

这个上面已经提到了，例如附近位置、附件的人、摇一摇这类依赖于地理位置信息的功能都可以使用`GEO`来实现。

总结

这一篇关于地理信息定位`GEO`，没有讲的太深，这个篇幅就已经很长了。主要的一个难点就是在于`GeoHash`的一个计算算法上，要搞懂这个的话好哥哥们还是要看看上面的两篇文章，当然也可以自己去搜索相关的资料，讲道理这个功能还是挺好玩的。后面有机会去踩踩坑，有熟悉的好哥哥可以把坑留着评论区。

# **八、**HyperLogLog #

首先`HyperLogLog` 并不是一个数据结构，而是一种基数1统计算法。通过`HyperLogLog`可以利用极小的内存空间完成独立总数的统计，数据集可以是 IP、Email、ID 等。因为`HyperLogLog` 只会根据输入元素来计算基数，而不会存储输入元素本身，所以 HyperLogLog 不能想集合那样，返回输入的各个元素。

**原理**

在上面有提到说`HyperLogLog` 使用的是概率算法，通过存储元素的`hash`值的第一个 1 的位置，来计算元素数量。举个栗子:  
有一天小明和小红在操场上快乐的玩耍。突然小明红着脸对小红说我们来玩一个玩抛硬币的游戏，我赢的话你就做我女朋友，输了的我话我就做你男朋友，规则是我来负责抛硬币，每次抛到国徽面为一个回合，我可以决定抛几个回合，最后我会告诉你我最长的那个回合抛了多少次，然后你就来猜我一共抛了几个回合。小红红着脸说好呀，但是这不好猜呀，你先抛吧，我要算算这个概率了，于是快速在脑海中绘制了一幅图。

![回合][cbc08cc754b16c1cc6d280e7e6d36763.png]

`k`是每回合抛到`1`（1 是国徽面，0 是数字面）所用的次数，我们已知的是最大的`k`值，用`kmax`表示，由于每次抛硬币的结果只有`0`和`1`两种情况。所以，kmax 在任意回合出现的概率即为 (1/2)kmax(1/2) ^\{kmax\}(1/2)kmax ，因此可以推测 n = 2kmax2 ^\{kmax\}2kmax 。概率学把这种问题叫做伯努利实验2。  
然后小明已经完成了 n 个回合，并且告诉小红最长的一次抛了 3 次。小红胸有成竹，马上说出他的答案 8，最后的结果是：小明只抛了一回合，小红输了生气的对小明说玩游戏都不让女朋友赢你个渣男，你走吧，我们不可能了（没想到吧，哈哈哈哈）。  
细心的好哥哥能发现上面的的概率算法是存在问题的（导致小红都输了)，[Philippe Flajolet][] 教授针对于于上面的问题引入了桶的概念，计算`m`个桶的加权平均值，这样就能得到比较准确的答案了（实际上还要进行其他修正）。最终的公式如图

![公式][062dbf0446fdae9042a6a63ac2e8e897.png]  
回到 Redis 的`HyperLogLog`，对于一个新插入的字符串，首先得到 64 位的`hash`值，用前 14 位来定位桶的位置（共有 2142 ^\{14\}214，即 16384 个桶）。后面 50 位即为伯努利过程，每个桶有`6bit`，记录第一次出现 1 的位置`count`，如果`count`>`oldcount`，就用`count`替换`oldcount`。

## 命令 ##

在 Redis 中操作`HyperLogLog` 只提供三个命令

1 添加

## 格式，key：键 element: 元素
    pfadd key element [element  … ]
    ## 添加一个元素，添加成功返回1
    127.0.0.1:6379> pfadd 2020-12-14:unique:ids "uuid-1" "uuid-2" "uuid-3" "uuid-4"
    (integer) 1
    复制代码

2 计算基数

`pfcount` 用于计算一个或多个`HyperLogLog`的独立总数

## 格式，key：键
    pfcount key [key  … ]
    ## 返回总个数
    127.0.0.1:6379> pfcount 2020-12-14:unique:ids
    (integer) 4
    复制代码

3 合并

`pfmerge` 可以求出多个`HyperLogLog`的并集并赋值给`destkey`

## 格式，destkey ：结果集key， sourcekey：需要合并的键
    pfmerge destkey sourcekey [sourcekey ...]
    ## 添加2020-12-13号添加元素
    127.0.0.1:6379> pfadd 2020-12-13:unique:ids "uuid-4" "uuid-5" "uuid-6" "uuid-7"
    (integer) 1
    ## 计算2020-12-13和2020-12-14号基数
    127.0.0.1:6379> pfmerge 2020-12_13_14:unique:ids 2020-12_13:unique:ids 2020-12-14:unique:ids
    OK
    127.0.0.1:6379> pfcount 2020-12_13_14:unique:ids
    (integer) 7
    复制代码

**内存使用**

1 初始内存统计

127.0.0.1:6379> info memory
    # 内存统计
    used_memory:835144
    used_memory_human:815.57K
    复制代码

2 插入批量数据

elements=""
    key="020-12-14:unique:ids"
    for i in `seq 1 1000000`
    do
    elements="${elements} uuid-"${i}
    if [[ $((i%1000)) == 0 ]];
    then
    redis-cli pfadd ${key} ${elements}
    elements=""
    fi
    done
    复制代码

3 统计使用内存

执行完添加元素操作内存只增加了 15K 左右

info memory
    # 内存统计
    used_memory:850616
    used_memory_human:830.68K
    复制代码

4 准确率分析

使用`pfcount`的执行结果并不是 100 万

127.0.0.1:6379> pfcount 2016_05_01:unique:ids
    (integer) 1009838
    复制代码

使用场景

`HyperLogLog` 内存占用量非常小，但是存在错误率。所以在使用是需要符合以下两点

1.  只为了计算独立总数，不需要获取单条数据，上面说了只会存计算基数，不会存数据本身。
2.  可以容忍一定误差率， 上面准确率分析也说到了。

[Dawn]: /images/20220508/0ed6641cd84047beafe238e6e9faf5e8.png
[ASCII]: /images/20220508/3ff4b89a9b5d4146a5ae6fc5becfd738.png
[bitmaps]: /images/20220508/1599f32b39fe49e28c59687fde961f05.png
[bitmaps 1]: /images/20220508/1991fcb865054df08180d3930016dc98.png
[50]: /images/20220508/562942af112f4c958b3dfad6766c74e1.png
[9b3e3ee0edd91f34268b5e4e72f3d0a8.png]: /images/20220508/7ca6a9707e6d4d3d826b99e93d42b489.png
[1145954680125ddf6af19d9b15445ef0.png]: /images/20220508/f41570f9fca74e09b4e36f8f0e2a7f64.png
[3262210009ab76880106d0cd2e3f1a6e.png]: /images/20220508/c02626c5f5b744b396360a3edb430db8.png
[Link 1]: https://blog.csdn.net/qq_24313635/article/details/107563893
[dc45ebf03186fe322f036a5bf2f9da73.png]: /images/20220508/a2504eb811604e66b4cafa0416d84e48.png
[Geohash]: https://www.jianshu.com/p/1ecf03293b9a
[f2fef8c09decd02fd75bd54e1ed5132b.png]: /images/20220508/4266fefc73f2459b872a260e5446d036.png
[Redis Sorted Set _API]: https://juejin.cn/post/6904055784426979341
[GeoHash]: https://www.cnblogs.com/LBSer/p/3310455.html
[cbc08cc754b16c1cc6d280e7e6d36763.png]: /images/20220508/cdd06f912547486aadb54a14bd8830e3.png
[Philippe Flajolet]: https://en.wikipedia.org/wiki/Philippe_Flajolet
[062dbf0446fdae9042a6a63ac2e8e897.png]: /images/20220508/9ed70283ba3a4ec694988a16ba93bfb2.png