Redis概述及数据类型

旧城等待， 2023-10-01 10:54 4阅读 0赞

### Redis概述及数据类型 ###

### Redis是什么？ ###

Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。

*  是一个高性能的key-value数据库。  
    redis的出现，很大程度补偿了memcached这类key/value存储的不足，在部 分场合可以对关系数据库起到很好的补充作用。它提供了Java，C/C++，C\#，PHP，JavaScript，Perl，Object-C，Python，Ruby，Erlang等客户端，使用很方便
 *  支持主从同步。  
    数据可以从主服务器向任意数量的从服务器上同步，从服务器可以是关联其他从服务器的主服务器。

**支持语言**  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAd2VpeGluXzQwNzUwNjMz_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]

### 能干什么？ ###

1、内存存储持久化，内存中是断电即失所以说持久化很重要(rdb、aof)  
2、效率高，可以用于高速缓存  
3、发布订阅  
4、地图信息分析  
5、计器、计数器(浏览量!)  
6、。。。。。。。

### 特性 ###

*  多样的数据类型
 *  持久化
 *  集群
 *  事务

官网：[https://redis.io/][https_redis.io]  
中文网：[http://www.redis.cn/][http_www.redis.cn]  
更多命令：[https://redis.io/commands][https_redis.io_commands]

### 基础知识 ###

redis默认有16个数据库  
![在这里插入图片描述][2e21af2f0a584442b301639a273d5203.png_pic_center]  
默认使用的是第0个  
使用select切换数据库  
示例：

127.0.0.1:6379> select 3  #切换数据库
    OK
    127.0.0.1:6379[3]> DBSIZE  #查看DB大小
    (integer)0
    127.0.0.1:6379[3]> set name zhangsan
    OK
    127.0.0.1:6379[3]>DBSIZE
    (integer)1
    127.0.0.1:6379[3]> get name 
    "zhangsan"

*  查看数据库所有的key

127.0.0.1:6379[3]> keys * 
    1)"name"

*  清楚当前数据库`flushdb`

127.0.0.1:6379[3]> flushdb 
    OK
    127.0.0.1:6379[3]> keys * 
    (empty list or set)

*  清楚全部数据库的内容`flushall`

127.0.0.1:6379[3]> flushall 
    OK
    127.0.0.1:6379[3]> keys * 
    (empty list or set)
    127.0.0.1:6379[3]>select 0
    OK
    127.0.0.1:6379[3]> keys * 
    (empty list or set)

### 数据类型 ###

Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。

*  支持多种类型的数据结构，如 字符串（strings）， 散列（hashes）， 列表（lists）， 集合（sets）， 有序集合（sorted sets） 与范围查询， bitmaps， hyperloglogs 和 地理空间（geospatial） 索引半径查询。
 *  Redis 内置了 复制（replication），LUA脚本（Lua scripting）， LRU驱动事件（LRU eviction），事务（transactions） 和不同级别的 磁盘持久化（persistence）， 并通过 Redis哨兵（Sentinel）和自动 分区（Cluster）提供高可用性（high availability）。

#### Redis 键(key) ####

Redis 键命令用于管理 redis 的键。  
示例：

127.0.0.1:6379[3]> set name zhangsan
    OK
    127.0.0.1:6379[3]> keys *  #查看所有的key
    1)"name"
    127.0.0.1:6379[3]> EXISTS name  #判断当前的key是否存在
    (integer)1
    127.0.0.1:6379[3]> move name 1  #移除当前的key
    (integer)1
    127.0.0.1:6379[3]> set name zhangsan
    OK
    127.0.0.1:6379[3]> expire name 10  #设置key的过期时间，单位是秒
    (integer)1
    127.0.0.1:6379[3]> ttl name   #查看当前可以的剩余时间
    (integer)4
    127.0.0.1:6379[3]> type name  #查看当前key的类型
    string

> Redis 键相关的基本命令：

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th align="left">命令及描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td align="left">DEL key <br> 该命令用于在 key 存在时删除 key。</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td align="left">DUMP key <br> 序列化给定 key ，并返回被序列化的值。</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td align="left">EXISTS key <br> 检查给定 key 是否存在。</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td align="left">EXPIRE key seconds <br> 为给定 key 设置过期时间，以秒计。</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td align="left">EXPIREAT key timestamp <br> EXPIREAT 的作用和 EXPIRE 类似，都用于为 key 设置过期时间。 不同在于 EXPIREAT 命令接受的时间参数是 UNIX 时间戳(unix timestamp)。</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td align="left">PEXPIRE key milliseconds <br> 设置 key 的过期时间以毫秒计。</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td align="left">PEXPIREAT key milliseconds-timestamp <br> 设置 key 过期时间的时间戳(unix timestamp) 以毫秒计</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td align="left">KEYS pattern <br> 查找所有符合给定模式( pattern)的 key 。</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td align="left">MOVE key db <br> 将当前数据库的 key 移动到给定的数据库 db 当中。</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td align="left">PERSIST key <br> 移除 key 的过期时间，key 将持久保持。</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td align="left">PTTL key <br> 以毫秒为单位返回 key 的剩余的过期时间。</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td align="left">TTL key <br> 以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td align="left">RANDOMKEY <br> 从当前数据库中随机返回一个 key 。</td> 
  </tr> 
  <tr> 
   <td>14</td> 
   <td align="left">RENAME key newkey <br> 修改 key 的名称</td> 
  </tr> 
  <tr> 
   <td>15</td> 
   <td align="left">RENAMENX key newkey <br> 仅当 newkey 不存在时，将 key 改名为 newkey 。</td> 
  </tr> 
  <tr> 
   <td>16</td> 
   <td align="left">SCAN cursor [MATCH pattern] [COUNT count] <br> 迭代数据库中的数据库键。</td> 
  </tr> 
  <tr> 
   <td>17</td> 
   <td align="left">TYPE key <br> 返回 key 所储存的值的类型。</td> 
  </tr> 
 </tbody> 
</table>

#### 字符串(String) ####

String类型是 Redis 最基本的数据类型。

示例：

127.0.0.1:6379[3]> set key1 vl
    OK
    127.0.0.1:6379[3]> append name "hello"
    (integer) 7
    127.0.0.1:6379[3]> gettkey1
    "vlhello"
    127.0.0.1:6379[3]> strlen key1
    (integer) 7

*  浏览量

#i++
    #步长 i+=
    127.0.0.1:6379 > set views 0 #初始浏览量为0
    OK
    127.0.0.1:6379 > get views 
    "0"
    127.0.0.1:6379 > incrviews   #自增1 浏览量为1
    (integer)1
    127.0.0.1:6379 > incr views 
    (integer)2
    127.0.0.1:6379 > get views
    "2"
    127.0.0.1:6379 > decr views   #自减 浏览量-1
    (integer)1
    127.0.0.1:6379 >decr views
    (integer)0
    127.0.0.1:6379 > decr views
    (integer)-1
    127.0.0.1:6379 > get views
    "-1"
    127.0.0.1:6379 >INCRBY views 10 #可以设置步长，指定增量1
    (integer)9

*  setex /setnx

# setex (set with expire) # 设留过期时间 
    # setnx (set if not exist) "不都在在设(在分有式领中会常常使用!)
    127.0.0.1:6379 > setex key3 30 "hello" #设置key3的值he11030秒后过用
    OK
    127.0.0.1:6379 > tt1 key3
    (integer) 26
    127.0.0.1:6379 > get key3
    "hello"
    127.0.0.1:6379 > setnx mykey "redis" #如果mykey 不存在。创建mykey (integer) 1
    127.0.0.1:6379 > keys * 
    1)"key2"
    2)"mykey "
    3)"key1"
    127.0.0.1:6379 > tt1 key3
    (integer) -2
    127.0.0.1:6379 > setnx mykey "MongoDB" #如果mykey存在，创建失败! (integer) 0
    127.0.0.1:6379 > get mykey
    "redis"

*  mset/mget 同时设置/获取多个值

mset mget
    
    127.0.0.1:6379 > mset k1 v1 k2 v2 k3 v3   # 同时设置多个值
    OK
    127.0.0.1:6379 > keys *
    1)"k1"
    2)"k2"
    3)"k3"
    127.0.0.1:6379 > mget k1 k2k3    # 同时获取多个值
    1)"v1"
    2)"v2"
    3)"v3"
    127.0.0.1:6379 > msetnx k1 v1 k4 v4 #msetnx是一个原子性的操作，要么一起成功，要么一起失败! 
    (integer) 0
    127.0.0.1:6379 > get k4
    (nil)
    
    
    #对象
    set user:1 {
        name:zhangsan,age:3}   #设置一个user:1对象，值为json字符来保存一个对象
    #这里的key是一个巧妙地设计，user:{id}:{field}
    127.0.0.1:6379 > mset user:1:name zhangsan user:1:age 2
    OK
    127.0.0.1:6379 > mget user:1:name user:1:age 
    1)"zhangsan "
    2)"2"

*  getset组合命令

127.0.0.1:6379 > getset db redis  #如果不存在值，则返回nil
    (nil)
    127.0.0.1:6379 > get db 
    "redis"
    127.0.0.1:6379 > getset db mongodb #如果存在值，则设置新的值
    "redis"
    127.0.0.1:6379 > get db 
    "mongodb"

String类似的使用场景：

*  计数器
 *  统计多单位的数量
 *  粉丝数
 *  对象缓存存储

> redis 字符串命令：

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

#### 列表(List) ####

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

所有的list命令都是以L开头，不区分大小写命令

示例：

*  LPUSH

--------------------------------LPUSH  --------------------------------
    127.0.0.1:6379 > LPUSH  list one  #将一个或多个值插入到列表头部(左)
    (integer) 1
    127.0.0.1:6379 > LPUSH  list two
    (integer) 2
    127.0.0.1:6379 > LPUSH  list three
    (integer) 3
    127.0.0.1:6379 > LRANGE  list 0 -1  #获取list中的值
    1)"three"
    2)"two"
    3)"one"
    127.0.0.1:6379 > RPUSH list right  #将一个或多个值插入到列表头部(右)
    (integer) 4
    127.0.0.1:6379 > LRANGE  list 0 -1
    1)"three"
    2)"two"
    3)"one"
    4)"right"

*  LPOP/RPOP

--------------------------------LPOP/RPOP  --------------------------------
    127.0.0.1:6379 > LPOP list   #移除列表的第一个元素
    "three"
    127.0.0.1:6379 > RPOP  list #移除列表的最后一个元素
    "right"

*  Lindex / Llen / Lrem

--------------------------------Lindex  --------------------------------
    127.0.0.1:6379 > Lindex   list 1 #通过下标获取list某一个值
    "one"
    --------------------------------Llen  --------------------------------
    127.0.0.1:6379 > Llen   list  #获取列表的长度
    (integer) 3
    --------------------------------Lrem  --------------------------------
    127.0.0.1:6379 > LPUSH  list three
    (integer) 4
    127.0.0.1:6379 > Lrem  list 1 one  #移除列表集合中指定个数的value，精确匹配
    (integer) 1
    127.0.0.1:6379 > LRANGE  list 0 -1
    1)"three"
    2)"two"
    3)"right"
    127.0.0.1:6379 > Lrem  list 2 three
    (integer) 2

*  trim

#trim修剪，1ist截断
    127.0.0.1:6379 > keys *
    (empty 1ist or set)
    127.0.0.1:6379 > Rpush mylist "he11o"
    (integer)1
    127.0.0.1:6379 > Rpush mylist"he11o1"
    (integer)2
    127.0.0.1:6379 > Rpush mylist "he11o2"
    (integer)3
    127.0.0.1:6379 > Rpush my1ist "he11o3"
    (integer)4
    127.0.0.1:6379 > Ltrim my1ist 1 2  #通过下标截取定的长度，这个list已经被改变了，截断了只剩下截取的元素!
    OK
    127.0.01:6379 >LRANGE mylist 0 -1
    1)"he11o1"
    2)"he11o2"

*  rpoplpush

rpop1push#移除列表的最后一个元素，将他移动到新的列表中!
    
    127.0.0.1:6379 >rpush mylist"he11o"
    (integer)1
    127.0.0.1:6379 >rpush mylist"he71o1"
    (integer)2
    127.0.0.1:6379 >rpush my1ist "he11o2"
    (integer)3
    127.0.0.1:6379 > rpop1push mylist myotherlist #移除列表的最后一个元素，将他移动到新的列表中!
    "he11o2"
    127.0.0.1:6379 >lrange my1ist 0 -1 #查看原来的列表
    1)"he11o"
    2)"he11o1"
    127.0.0.1:6379 > lrange myother1ist 0 -1 #查看目标列表中，确实存在改值
    1)"he11o2"

*  lset

1set将列表中指定下标的值替换为另外一个值，更新操作
    127.0.01:6379 >EXISTS 1ist #判断这个列表是否存在(integer)0
    127001:6379 > lset 1ist 0 item #如果不存在列表我们去更新就会报错 
    (error) ERR no such key
    127.0.0.1:6379 > lpush 1ist valuel
    (integer)1
    127.0.0.1:6379 >LRANGE 1ist 0 0
    1)"value1"
    127.0.0.1:6379 > 1set 1ist 0 item #如果存在，更新当前下标的值 
    OK
    127.0.01:6379>LRANGE 1ist 0 0
    1)"item"
    127.0.0.1:6379 > lset 1ist 1 other # 如果不存在，则会报错! 
    (error)ERR indexout of range

*  linsert

linsert#将某个具体的value插入到列把你中某个元素的前面或者后面
    
    127.0.0.1:6379 > Rpush mylist "he11o"
    (integer)1
    127.0.0.1:6379 > Rpush mylist "world"
    (integer)2
    127.0.0.1:6379 > LINSERT mylist before "world" "other"
    (integer)3
    127.0.0.1:6379 >LRANGE my1ist 0 -1
    1)"he11o"
    2)"other"
    3)"world"
    1270.0.1:6379 > LINSERT mylist after world new
    (integer)4
    127.0.01:6379 >LRANGE my1ist 0 -1
    1)"he11o"
    2)"other"
    3)"wor1d"
    4)"new"

> 列表相关的基本命令：

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

> 小结

*  实际上是一个链表，before Node after,left,right都可以插入值
 *  如果key不存在，创建新的链表
 *  如果key存在，新增内容
 *  如果移除了所有的值，空链表，也代表不存在
 *  在两边插入或者改动值，效率最高；中间元素，效率低一点

#### 集合(Set) ####

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

集合对象的编码可以是 intset 或者 hashtable。  
Redis 中集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是 O(1)。

示例：

127.0.0.1:6379 > sadd myset "hello"
    (integer) 1
    127.0.0.1:6379 > sadd myset "zhangsan"
    (integer) 1
    127.0.0.1:6379 > SMEMBERS myset   #查看指定set的所有值
    1)"hello"
    2)"zhangsan"
    127.0.0.1:6379 >SISMEMBER  myset hello   #判断某一个值是不是在set集合中
    (integer) 1
    127.0.0.1:6379 >SCARD myset   #获取set集合中的内容元素个数
    (integer) 2
    ---------------------------------------------------------------------
    微博，B站，共同关注（并集）
    数字集合类：差集SDIFF ,交集SINTER ，并集SUNION 
    127.0.0.1:6379 > sadd key1 a
    (integer) 1
    127.0.0.1:6379 > sadd key1 b
    (integer) 1
    127.0.0.1:6379 > sadd key1 c
    (integer) 1
    127.0.0.1:6379 > sadd key2 c
    (integer) 1
    127.0.0.1:6379 > sadd key2 d
    (integer) 1
    127.0.0.1:6379 > sadd key2 e
    (integer) 1
    127.0.0.1:6379 > SDIFF  key1 key2 #差集
    1)"b"
    2)"a"
    127.0.0.1:6379 > SINTER key1 key2  #交集
    1)"c"
    127.0.0.1:6379 > SUNION key1 key2 #并集
    1)"b"
    2)"C"
    1)"E"
    2)"a"
    1)"D"

> Redis 集合基本命令：

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th align="left">命令及描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td align="left">SADD key member1 [member2] <br> 向集合添加一个或多个成员</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td align="left">SCARD key <br> 获取集合的成员数</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td align="left">SDIFF key1 [key2] <br> 返回第一个集合与其他集合之间的差异。</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td align="left">SDIFFSTORE destination key1 [key2 <br> 返回给定所有集合的差集并存储在</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td align="left">SINTER key1 [key2] <br> 返回给定所有集合的交集</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td align="left">SINTERSTORE destination key1 [key2] <br> 返回给定所有集合的交集并存储</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td align="left">SISMEMBER key member <br> 判断 member 元素是否是集合 key 的成员</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td align="left">SMEMBERS key <br> 返回集合中的所有成员</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td align="left">SMOVE source destination member <br> 将 member 元素从 source 集合移动</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td align="left">SPOP key <br> 移除并返回集合中的一个随机元素</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td align="left">SRANDMEMBER key [count] <br> 返回集合中一个或多个随机数</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td align="left">SREM key member1 [member2] <br> 移除集合中一个或多个成员</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td align="left">SUNION key1 [key2] <br> 返回所有给定集合的并集</td> 
  </tr> 
  <tr> 
   <td>14</td> 
   <td align="left">SUNIONSTORE destination key1 [key2] <br> 所有给定集合的并集存储在 de</td> 
  </tr> 
  <tr> 
   <td>15</td> 
   <td align="left">SSCAN key cursor [MATCH pattern] [COUNT count] <br> 迭代集合中的元素</td> 
  </tr> 
 </tbody> 
</table>

#### 哈希(Hash) ####

Redis hash 是一个键值(key=>value)对集合。  
Redis hash 是一个 string 类型的 field 和 value 的映射表，hash 特别适合用于存储对象。

Map集合，key-map,这个值是一个map集合。本质和String类型没有太大区别，还是一个简单的key-value。  
示例：

127.0.0.1:6379 > hset myhash field1 zhangsan  #set一个具体的key-value
    (integer) 1
    127.0.0.1:6379 > hget myhash field1 
    "zhangsan"
    127.0.0.1:6379 > hmset myhash field1 hello field12 world #set多个key-value
    OK
    127.0.0.1:6379 > hmget myhash field1 field12 #获取多个字段值
    1)"hello "
    2)"world"
    127.0.0.1:6379 > hgetall myhash  #获取全部的数据
    1)"field1"
    2)"hello "
    3)"field12"
    4)"world"
    127.0.0.1:6379 > hdel myset field1  #删除hash指令的key字段，对应的value值也消失
    (integer) 1
    127.0.0.1:6379 > hgetall myhash
    1)"field12"
    2)"world"
    ------------------------------------------------------------------
    127.0.0.1:6379 > hlen myhash   #获取hash表的字段数量
    (integer) 1
    127.0.0.1:6379 > HEXISTS myhash field1  #判断hash中指定的字段是否存在
    (integer) 1
    127.0.0.1:6379 >hkeys myhash  #获取所有的field
    1)"field2"
    2)"field11"
    127.0.0.1:6379 >hvals myhash #获取所有的value
    1)"world"
    2)"hello"
    --------------------------------------------------------------
    127.0.0.1:6379 > hset myhash field3 5   #指定增量
    (integer) 1
    127.0.0.1:6379 > HINCRBY myhash field3 1
    (integer) 6
    127.0.0.1:6379 > HINCRBY myhash field3 -1
    (integer) 5
    127.0.0.1:6379 > HSETNX myhash field4 hello #如果不存在，则可以设置
    (integer) 1
    127.0.0.1:6379 > HSETNX myhash field4 world #如果存在，则不可以设置
    (integer) 0

hash 更适合于对象的存储，String更加适合字符串存储。

> redis hash 基本的相关命令：

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

#### Zset有序集合(sorted set) ####

zset 和 set 一样也是string类型元素的集合,且不允许重复的成员。  
不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。

zset的成员是唯一的,但分数(score)却可以重复。

示例：

127.0.0.1:6379 > zadd myset 1 one #添加一个值 
    (inteqer)1
    127.0.0.1:6379 > zadd myset 2 two 3 three # 添加多个值
    (integer)2
    127.0.0.1:6379 > ZRANGE myset 0 -1
    1)"one"
    2)"two"
    3)"three"

*  ZRANGEBYSCORE 排序

127.0.0.1:6379 > zadd salary 2500 xiaohong  #添加三个用户
    (integer)1
    127.0.0.1:6379 > zadd salary 5000 zhangsan
    (integer)1
    127.0.0.1:6379 > zadd salary 500 kaungshen
    (integer)1
    # ZRANGEBYSCORE key min max
    127.0.01:6379 > ZRANGEBYSCORE salary -inf +inf #显示企部的用户,从小到大
    1)"lisi"
    2)"xiaohong"
    3)"zhangsan"
    127.001:6379 > ZRANGEBYSCORE salary 0  -1  #从大到小进行排序
    1)"zhangsan"
    2)"lisi"
    127.0.01:6379 > ZRANGEBYSCORE salary -inf +inf withscores #显示企部的用户,并且附带成绩
    1)"lisi"
    2)"500"
    2)"xiaohong"
    3)"2500"
    4)"zhangsan"
    5)"5000"
    127.0.01:6379 > ZRANGEBYSCORE salary -inf 2500 withscores #显示工资小于2500员工升序排序
    1)"lisi"
    2)"500"
    2)"xiaohong"
    3)"2500"

# 移除rem中的元素
    127.0.0.1:6379 > zrange salary 0 -1
    1)"kaungshen"
    2)"xiaohong"
    3)"zhangsan"
    127.0.0.1:6379 > zrem salary xiaohong   #移除有序集合中的指定元素(integer)1
    127.0.0.1:6379 > zrange salary 0 -1
    1)"kaungshen"
    2)"zhangsan"
    127.0.0.1:6379 >zcard salary   #获取有序集合中的个数
    (integer)2
    ------------------------------------------------------------------
    127.0.01:6379 > zadd myset 1 he110
    (integer) 1
    127.0.0.1:6379 > zadd myset 2 wor1d 3 kuangshen
    (integer) 2
    127.0.0.1:6379 > zcount myset 1 3   #获取指定区间的成员数量!
    (integer) 3
    127.0.0.1:6379 > zcount myset 1 2
    (integer) 2

> redis 有序集合的基本命令:

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th align="left">命令及描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td align="left">ZADD key score1 member1 [score2 member2] <br> 向有序集合添加一个或多个成员，或者更新已存在成员的分数</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td align="left">ZCARD key <br> 获取有序集合的成员数</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td align="left">ZCOUNT key min max <br> 计算在有序集合中指定区间分数的成员数</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td align="left">ZINCRBY key increment member <br> 有序集合中对指定成员的分数加上增量 increment</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td align="left">ZINTERSTORE destination numkeys key [key …] <br> 计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 destination 中</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td align="left">ZLEXCOUNT key min max <br> 在有序集合中计算指定字典区间内成员数量</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td align="left">ZRANGE key start stop [WITHSCORES] <br> 通过索引区间返回有序集合指定区间内的成员</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td align="left">ZRANGEBYLEX key min max [LIMIT offset count] <br> 通过字典区间返回有序集合的成员</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td align="left">ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT] <br> 通过分数返回有序集合指定区间内的成员</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td align="left">ZRANK key member <br> 返回有序集合中指定成员的索引</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td align="left">ZREM key member [member …] <br> 移除有序集合中的一个或多个成员</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td align="left">ZREMRANGEBYLEX key min max <br> 移除有序集合中给定的字典区间的所有成员</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td align="left">ZREMRANGEBYRANK key start stop <br> 移除有序集合中给定的排名区间的所有成员</td> 
  </tr> 
  <tr> 
   <td>14</td> 
   <td align="left">ZREMRANGEBYSCORE key min max <br> 移除有序集合中给定的分数区间的所有成员</td> 
  </tr> 
  <tr> 
   <td>15</td> 
   <td align="left">ZREVRANGE key start stop [WITHSCORES] <br> 返回有序集中指定区间内的成员，通过索引，分数从高到低</td> 
  </tr> 
  <tr> 
   <td>16</td> 
   <td align="left">ZREVRANGEBYSCORE key max min [WITHSCORES] <br> 返回有序集中指定分数区间内的成员，分数从高到低排序</td> 
  </tr> 
  <tr> 
   <td>17</td> 
   <td align="left">ZREVRANK key member <br> 返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序</td> 
  </tr> 
  <tr> 
   <td>18</td> 
   <td align="left">ZSCORE key member <br> 返回有序集中，成员的分数值</td> 
  </tr> 
  <tr> 
   <td>19</td> 
   <td align="left">ZUNIONSTORE destination numkeys key [key …] <br> 计算给定的一个或多个有序集的并集，并存储在新的 key 中</td> 
  </tr> 
  <tr> 
   <td>20</td> 
   <td align="left">ZSCAN key cursor [MATCH pattern] [COUNT count] <br> 迭代有序集合中的元素（包括元素成员和元素分值）</td> 
  </tr> 
 </tbody> 
</table>

### 特殊的数据类型 ###

#### Geospatial地理位置 ####

redis 的Geo在Redis3.2版本就推出了。  
可以推算地理位置的距离，两地之间的距离，方圆几里的人。

> 相关命令：GEOADD、GEODIST、GEOHASH、GEOPOS、GEORADIUS、GEORADIUSBYMEMBER

> GEOADD

127.0.01:6379 > GEOADD key 值（纬度、经度、名称）

有效的经度从-180度到180度。  
有效的纬度从-85.05112878度到85.05112878度。  
当坐标位置超出上述指定范围时，该命令将会返回一个错误。

> GEOPOS

127.0.01:6379 > GEOADD key 值（名称）   #获取指定位置的经度和纬度
    1)"经度"
    2)"纬度"

> GEODIST

指定单位的参数必须是以下单位的其中一个：  
m 表示单位为米。  
km 表示单位为千米。  
mi 表示单位为英里。  
ft 表示单位为英尺。

GEODIST 命令在计算距离时会假设地球为完美的球形， 在极限情况下， 这一假设最大会造成 0.5% 的误差。

127.0.01:6379 > GEODIST key 值1（名称1）值2（名称2）km  #两个给定位置之间的距离

> GEORADIUS 以给定的经纬度为中心， 找出某一半径内的元素

127.0.01:6379 > GEORADIUS key 经度 纬度 1000  km #以某个经纬度为中心，寻找方圆1000km范围内的城市
    127.0.01:6379 > GEORADIUS key 经度 纬度 500 km WITHDIST   #显示到中间距离的位置
    127.0.01:6379 > GEORADIUS key 经度 纬度 500 km  WITHCOORD    #显示他人的定位信息
    127.0.01:6379 > GEORADIUS key 经度 纬度 500 km WITHCOORD WITHDIST count 1  #筛选出指定的结果

WITHDIST: 在返回位置元素的同时， 将位置元素与中心之间的距离也一并返回。 距离的单位和用户给定的范围单位保持一致。  
WITHCOORD: 将位置元素的经度和维度也一并返回。  
WITHHASH: 以 52 位有符号整数的形式， 返回位置元素经过原始 geohash 编码的有序集合分值。 这个选项主要用于底层应用或者调试， 实际中的作用并不大。  
命令默认返回未排序的位置元素。 通过以下两个参数， 用户可以指定被返回位置元素的排序方式：

在默认情况下， GEORADIUS 命令会返回所有匹配的位置元素。 虽然用户可以使用 COUNT 选项去获取前 N 个匹配元素， 但是因为命令在内部可能会需要对所有被匹配的元素进行处理， 所以在对一个非常大的区域进行搜索时， 即使只使用 COUNT 选项去获取少量元素， 命令的执行速度也可能会非常慢。 但是从另一方面来说， 使用 COUNT 选项去减少需要返回的元素数量， 对于减少带宽来说仍然是非常有用的。

> GEORADIUSBYMEMBER 找出位于指定范围内的元素，中心点是由给定的位置元素决定

127.0.01:6379 > GEORADIUSBYMEMBER  key 位置 100 km

> GEOHASH 返回一个或多个位置元素的 Geohash 表示

该命令将返回11个字符的Geohash字符串

127.0.01:6379 > GEOHASH key 位置1 位置2   
    #将二维的经纬度转换为以为的字符串，如果两个字符串接近，则距离越近

geo底层的实现原理其实就是zset，可以用zset操作geo.

#### Hyperloglog基数统计 ####

> **什么是基数?**

比如数据集 \{1, 3, 5, 7, 5, 7, 8\}， 那么这个数据集的基数集为 \{1, 3, 5 ,7, 8\}, 基数(不重复元素)为5。 基数估计就是在误差可接受的范围内，快速计算基数。

> **简介**

Redis 在 2.8.9 版本添加了 HyperLogLog 结构。  
Redis HyperLogLog 是用来做基数统计的算法.

HyperLogLog 的优点:

*  在输入元素的数量或者体积非常非常大时，计算基数所需的空间总是固定 的、并且是很小的。
 *  在 Redis 里面，每个 HyperLogLog 键只需要花费 12 KB 内存，就可以计算接近 2^64 个不同元素的基 数.

127.0.0.1:6379 > PFadd mykey a b c d e f g h i j
    (integer)1
    127.0.0.1:6379 > PFCOUNT mykey
    (integer)10
    127.0.0.1:6379 > PFadd mykey2 i j z x c v b n m
    (integer)1
    127.0.0.1:6379 > PFCOUNT mykey2
    (integer)9
    127.0.0.1:6379 > PFMERGE mykey3 mykey mykey2 
    OK
    127.0.0.1:6379 > PFCOUNT mykey3
    (integer)15

> redis HyperLogLog 的基本命令：

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th align="left">命令及描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td align="left">PFADD key element [element …] <br> 添加指定元素到 HyperLogLog 中。</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td align="left">PFCOUNT key [key …] <br> 返回给定 HyperLogLog 的基数估算值。</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td align="left">PFMERGE destkey sourcekey [sourcekey …] <br> 将多个 HyperLogLog 合并为一个 HyperLogLog</td> 
  </tr> 
 </tbody> 
</table>

#### Bilmap位图场景 ####

BitMap，即位图，其实也就是 byte 数组，用二进制表示，只有 0 和 1 两个数字。  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAd2VpeGluXzQwNzUwNjMz_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]  
使用bitmap来记录周一到周日的打卡!  
周一1周二0周三:0周四:1….

127.0.0.1:6379 > setbit sign 0 1
    (integer)0
    127.0.0.1:6379 > setbit sign 1 0
    (integer)0
    127.0.0.1:6379 > setbit sign 2 0
    (integer)0
    127.0.0.1:6379 > setbit sign 3 1
    (integer)0
    127.0.0.1:6379 > setbit sign 4 1
    (integer)0
    127.0.0.1:6379 > setbit sign 5 0
    (integer)0
    127.0.0.1:6379 > setbit sign 6 0
    (integer)0

查看某一天是否有打卡:

127.0.0.1:6379 > getbit sign 3
    (integer) 1

统计打卡的天数：

127.0.0.1:6379 > bitcount sign 
    (integer) 3

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAd2VpeGluXzQwNzUwNjMz_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]: https://img-blog.csdnimg.cn/2859a72d4c2e43ce9a4a8a1394e33a50.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAd2VpeGluXzQwNzUwNjMz,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[https_redis.io]: https://redis.io/
[http_www.redis.cn]: http://www.redis.cn/
[https_redis.io_commands]: https://redis.io/commands
[2e21af2f0a584442b301639a273d5203.png_pic_center]: https://img-blog.csdnimg.cn/2e21af2f0a584442b301639a273d5203.png#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAd2VpeGluXzQwNzUwNjMz_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]: https://img-blog.csdnimg.cn/bf4202d92fe94331af93c0e5d4fa1e65.webp?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAd2VpeGluXzQwNzUwNjMz,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center