Redis自学整理

叁歲伎倆 2022-12-16 14:26 116阅读 0赞

# Redis #

###### Redis介绍 ######

开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、key-value数据库，并提供多种语言的API。  
通常被称为数据结构服务器，因为值可以是字符串（String）、哈希（hash）、列表（list）、集合（set）、有序集合（sorted sets）。  
非关系型数据库。

###### Redis优势 ######

1、高性能：读速度是110000次/s，写速度是81000次/s。  
2、数据类型丰富：键要求必须是String类型，但是值可以是String、List、Hash、Set、Sorted set。  
3、原子性操作：redis的所有操作都是原子性的，就是说一个操作要么成功执行要么失败完全不执行。单个操作是原子性的。多个操作也支持事务，即原子性。  
4、丰富的特性：可用于缓存、消息、按key设置过期时间，过期后将自动删除。  
5、可以持久化数据：可以将数据从内存中持久化到磁盘中。  
两种持久化策略：  
一种是RDB：就是快照的方式定时去持久化数据，写入到一个文件中，但是安全性比较低。  
一种是AOF：每执行一次redis命令就往aof文件中记录一次。

###### Redis与其他key-value存储有什么不同 ######

1、redis有着更为复杂的数据结构并且提供对他们的原子性操作,这是一个不同于其他数据库的进化路径。redis的数据类型都是基于基本数据结构的同时对程序员透明，无需进行额外的抽象。  
2、redis运行在内存中但是可以持久化到磁盘，所以在对不同数据集进行高速读写时需要权衡内存，因为数据量不能大于硬件内存。  
在内存数据库方面：相比在磁盘上相同复杂度的数据结构，在内存中操作起来非常简单，这样redis可以做很多内部复杂性很强的事情。  
在磁盘格式方面：是紧凑的以追加的方式产生的，因为他们并不需要进行随机访问。

###### Redis淘汰策略 ######

Redis内存数据集大小上升到一定大小的时候，就会实行数据淘汰策略。  
1、voltile-lru:从已设置过期时间的数据集中挑选最近最少使用的数据淘汰。  
2、voltile-ttl:从已设置过期时间的数据集中挑选将要过期的数据淘汰。  
3、voltile-random:从已设置过期时间的数据集中任意选择数据淘汰。  
4、allkeys-lru:从数据集中挑选最近最少使用的数据淘汰。  
5、allkeys-random:从数据集中任意选择数据淘汰。  
6、no-enviction:禁止驱逐数据。

## Redis适用场景 ##

###### 1、会话缓存（Session Cache） ######

最常用的一种场景。  
用Redis缓存会话比其他存储（如Memcached）的优势在于：Redis提供持久化。

###### 2、全页缓存（FPC） ######

除基本的会话token之外，Redis还提供很简便的FPC平台。拿一致性问题来说，即使重启了Redis实例，因为有磁盘的持久化，用户也不会看到页面加载速度的下降，类似PHP本地FPC。

###### 3、队列 ######

Redis在内存存储引擎领域的一大优点是提供list和set操作，使得Redis能作为一个很好的消息队列平台使用。

###### 4、计数器/排行榜 ######

Redis在内存中对数字进行递增或递减的操作实现的非常好。

###### 5、发布/订阅 ######

这个使用场景非常多。社交网络连接中，像聊天系统。

## Redis数据类型详述 ##

### 1、String（字符串） ###

String是Redis最基本的类型。一个key对应一个value。  
String类型是二进制安全的。意思是Redis的String可以包含任何数据。  
String类型的值最多能存储512MB。

##### 字符串命令 #####

1、set key value：设置指定key的值。  
2、get key：获取指定key的值。

redis 127.0.0.1:6379> SET key "value"
    OK
    redis 127.0.0.1:6379> GET key
    "value"

3、getrange key start end：返回key中字符串值的子字符。

redis 127.0.0.1:6379> SET mykey "This is my test key"
    OK
    redis 127.0.0.1:6379> GETRANGE mykey 0 3
    "This"
    redis 127.0.0.1:6379> GETRANGE mykey 0 -1
    "This is my test key"

4、getset key value：将给定key的值设为value，并返回key的旧值（old value）。

redis> GETSET db mongodb    # 没有旧值，返回 nil
    (nil)
    redis> GET db
    "mongodb"
    redis> GETSET db redis      # 返回旧值 mongodb
    "mongodb"
    redis> GET db
    "redis"

5、 mget key1 \[key2…\]：获取所有(一个或多个)给定 key 的值。

redis 127.0.0.1:6379> SET key1 "hello"
    OK
    redis 127.0.0.1:6379> SET key2 "world"
    OK
    redis 127.0.0.1:6379> MGET key1 key2 someOtherKey
    1) "Hello"
    2) "World"
    3) (nil)

6、setex key seconds value：将值value关联到key，并将key的过期时间设为seconds（以秒为单位）。

redis 127.0.0.1:6379> SETEX mykey 60 redis
    OK
    redis 127.0.0.1:6379> TTL mykey
    60
    redis 127.0.0.1:6379> GET mykey
    "redis

### 2、Hash（哈希） ###

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

##### hash命令 #####

1、hdel key field1 \[field2\]：删除一个或多个哈希表字段。

redis 127.0.0.1:6379> HSET myhash field1 "foo"
    (integer) 1
    redis 127.0.0.1:6379> HDEL myhash field1
    (integer) 1
    redis 127.0.0.1:6379> HDEL myhash field2
    (integer) 0

2、hexists key field：查看哈希表key中，指定的字段是否存在。

redis 127.0.0.1:6379> HSET myhash field1 "foo"
    (integer) 1
    redis 127.0.0.1:6379> HEXISTS myhash field1
    (integer) 1
    redis 127.0.0.1:6379> HEXISTS myhash field2
    (integer) 0

3、hget key field：获取存储在哈希表中指定字段的值。

# 字段存在
    redis> HSET site redis redis.com
    (integer) 1
    redis> HGET site redis
    "redis.com"
    # 字段不存在
    redis> HGET site mysql
    (nil)

4、hgetall key：获取在哈希表中指定key的所有字段和值。

redis> HSET myhash field1 "Hello"
    (integer) 1
    redis> HSET myhash field2 "World"
    (integer) 1
    redis> HGETALL myhash
    1) "field1"
    2) "Hello"
    3) "field2"
    4) "World"
    redis>

5、hkeys key：获取所有哈希表中的字段。

redis 127.0.0.1:6379> HSET myhash field1 "foo"
    (integer) 1
    redis 127.0.0.1:6379> HSET myhash field2 "bar"
    (integer) 1
    redis 127.0.0.1:6379> HKEYS myhash
    1) "field1"
    2) "field2"

6、hlen key：获取哈希表中字段的数量。

redis 127.0.0.1:6379> HSET myhash field1 "foo"
    (integer) 1
    redis 127.0.0.1:6379> HSET myhash field2 "bar"
    (integer) 1
    redis 127.0.0.1:6379> HLEN myhash
    (integer) 2

7、hmget key filed1 \[field2\]：获取指定key中所有给定字段的值。

redis 127.0.0.1:6379> HSET myhash field1 "foo"
    (integer) 1
    redis 127.0.0.1:6379> HSET myhash field2 "bar"
    (integer) 1
    redis 127.0.0.1:6379> HMGET myhash field1 field2 nofield
    1) "foo"
    2) "bar"
    3) (nil)

8、hmset key field1 value1 \[field2 value2\]：同时将多个field-value（域-值）对设置到哈希表key中。

redis 127.0.0.1:6379> HMSET myhash field1 "Hello" field2 "World"
    OK
    redis 127.0.0.1:6379> HGET myhash field1
    "Hello"
    redis 127.0.0.1:6379> HGET myhash field2
    "World"

9、hset key field value：将哈希表key中的字段field的值设为value。

redis 127.0.0.1:6379> HSET myhash field1 "foo"
    OK
    redis 127.0.0.1:6379> HGET myhash field1
    "foo"
    redis 127.0.0.1:6379> HSET website google "www.g.cn"       # 设置一个新域
    (integer) 1
    redis 127.0.0.1:6379>HSET website google "www.google.com" # 覆盖一个旧域
    (integer) 0

10、hsetnx key field value：只有在字段field不存在时，设置哈希表字段的值。

redis 127.0.0.1:6379> HSETNX nosql key-value-store redis
    (integer) 1
    redis 127.0.0.1:6379> HSETNX nosql key-value-store redis       # 操作无效， key-value-store 已存在
    (integer) 0

11、hvals key：获取哈希表中所有值。

redis 127.0.0.1:6379> HSET myhash field1 "foo"
    (integer) 1
    redis 127.0.0.1:6379> HSET myhash field2 "bar"
    (integer) 1
    redis 127.0.0.1:6379> HVALS myhash
    1) "foo"
    2) "bar"
    # 空哈希表/不存在的key
    redis 127.0.0.1:6379> EXISTS not_exists
    (integer) 0
    redis 127.0.0.1:6379> HVALS not_exists
    (empty list or set)

###### 3、List(列表） ######

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

##### 列表命令 #####

1、lpush key value1 \[value2\]：将一个或多个值插入到列表头部。  
2、lpushx key value：将一个值插入到已存在的列表的头部。  
3、lindex key index：通过索引获取列表中的元素。  
4、llen key：获取列表的长度。  
5、lrange key start stop：获取列表指定范围内的元素。  
6、lrem key count value：一处列表元素。  
7、lset key index value：通过索引设置列表元素的值。  
8、rpop key：一处列表的最后一个元素，返回值为移除的元素。

###### 4、Set（集合） ######

Redis的Set是String类型的无序集合。  
集合是通过哈希表实现的，所以添加、删除  
查找的复杂度都是O（1）。  
添加一个string元素到key对应的set集合中，成功返回1，若元素已经在集合中返回0并不作添加。

##### 集合命令 #####

1、sadd key member1 \[member2\]：向集合添加一个或多个成员。（重复添加只显示一个）

redis 127.0.0.1:6379> SADD myset "hello"
    (integer) 1
    redis 127.0.0.1:6379> SADD myset "foo"
    (integer) 1
    redis 127.0.0.1:6379> SADD myset "hello"
    (integer) 0
    redis 127.0.0.1:6379> SMEMBERS myset
    1) "hello"
    2) "foo"

2、scard key：获取集合的成员数。

3、sdiff key1 \[key2\]：返回第一个集合与其他集合之间的差异。

redis> SADD key1 "a"
    (integer) 1
    redis> SADD key1 "b"
    (integer) 1
    redis> SADD key1 "c"
    (integer) 1
    redis> SADD key2 "c"
    (integer) 1
    redis> SADD key2 "d"
    (integer) 1
    redis> SADD key2 "e"
    (integer) 1
    redis> SDIFF key1 key2
    1) "a"
    2) "b"
    redis>

4、SDIFFSTORE destination key1 \[key2\] ：返回给定所有集合的差集并存储在 destination 中。

redis 127.0.0.1:6379> SADD myset "hello"
    (integer) 1
    redis 127.0.0.1:6379> SADD myset "foo"
    (integer) 1
    redis 127.0.0.1:6379> SADD myset "bar"
    (integer) 1
    redis 127.0.0.1:6379> SADD myset2 "hello"
    (integer) 1
    redis 127.0.0.1:6379> SADD myset2 "world"
    (integer) 1
    redis 127.0.0.1:6379> SDIFFSTORE destset myset myset2
    (integer) 2
    redis 127.0.0.1:6379> SMEMBERS destset
    1) "foo"
    2) "bar"

5、SINTER key1 \[key2\] ：返回给定所有集合的交集。

6、SINTERSTORE destination key1 \[key2\]  
返回给定所有集合的交集并存储在 destination 中

redis 127.0.0.1:6379> SADD myset1 "hello"
    (integer) 1
    redis 127.0.0.1:6379> SADD myset1 "foo"
    (integer) 1
    redis 127.0.0.1:6379> SADD myset1 "bar"
    (integer) 1
    redis 127.0.0.1:6379> SADD myset2 "hello"
    (integer) 1
    redis 127.0.0.1:6379> SADD myset2 "world"
    (integer) 1
    redis 127.0.0.1:6379> SINTERSTORE myset myset1 myset2
    (integer) 1
    redis 127.0.0.1:6379> SMEMBERS myset
    1) "hello"

7、SISMEMBER key member  
判断 member 元素是否是集合 key 的成员

redis 127.0.0.1:6379> SADD myset1 "hello"
    (integer) 1
    redis 127.0.0.1:6379> SISMEMBER myset1 "hello"
    (integer) 1
    redis 127.0.0.1:6379> SISMEMBER myset1 "world"
    (integer) 0

8、SMEMBERS key  
返回集合中的所有成员

redis 127.0.0.1:6379> SADD myset1 "hello"
    (integer) 1
    redis 127.0.0.1:6379> SADD myset1 "world"
    (integer) 1
    redis 127.0.0.1:6379> SMEMBERS myset1
    1) "World"
    2) "Hello"

9、SMOVE source destination member  
将 member 元素从 source 集合移动到 destination 集合

redis 127.0.0.1:6379> SADD myset1 "hello"
    (integer) 1
    redis 127.0.0.1:6379> SADD myset1 "world"
    (integer) 1
    redis 127.0.0.1:6379> SADD myset1 "bar"
    (integer) 1
    redis 127.0.0.1:6379> SADD myset2 "foo"
    (integer) 1
    redis 127.0.0.1:6379> SMOVE myset1 myset2 "bar"
    (integer) 1
    redis 127.0.0.1:6379> SMEMBERS myset1
    1) "World"
    2) "Hello"
    redis 127.0.0.1:6379> SMEMBERS myset2
    1) "foo"
    2) "bar"

10、SPOP key  
移除并返回集合中的一个随机元素

redis> SADD myset "one"
    (integer) 1
    redis> SADD myset "two"
    (integer) 1
    redis> SADD myset "three"
    (integer) 1
    redis> SPOP myset
    "one"
    redis> SMEMBERS myset
    1) "three"
    2) "two"
    redis> SADD myset "four"
    (integer) 1
    redis> SADD myset "five"
    (integer) 1
    redis> SPOP myset 3
    1) "five"
    2) "four"
    3) "two"
    redis> SMEMBERS myset
    1) "three"
    redis>

11、SRANDMEMBER key \[count\]  
返回集合中一个或多个随机数

12、SREM key member1 \[member2\]  
移除集合中一个或多个成员

redis 127.0.0.1:6379> SADD myset1 "hello"
    (integer) 1
    redis 127.0.0.1:6379> SADD myset1 "world"
    (integer) 1
    redis 127.0.0.1:6379> SADD myset1 "bar"
    (integer) 1
    redis 127.0.0.1:6379> SREM myset1 "hello"
    (integer) 1
    redis 127.0.0.1:6379> SREM myset1 "foo"
    (integer) 0
    redis 127.0.0.1:6379> SMEMBERS myset1
    1) "bar"
    2) "world"

13、SUNION key1 \[key2\]  
返回所有给定集合的并集

14、SUNIONSTORE destination key1 \[key2\]  
所有给定集合的并集存储在 destination 集合中

15、SSCAN key cursor \[MATCH pattern\] \[COUNT count\]  
迭代集合中的元素

redis 127.0.0.1:6379> SADD myset1 "hello"
    (integer) 1
    redis 127.0.0.1:6379> SADD myset1 "hi"
    (integer) 1
    redis 127.0.0.1:6379> SADD myset1 "bar"
    (integer) 1
    redis 127.0.0.1:6379> sscan myset1 0 match h*
    1) "0"
    2) 1) "hello"
       2) "h1"

###### 5、Zset（Sorted set：有序集合） ######

Redis的Zset和set一样，也是string类型的元素集合，且不允许重复的成员。  
每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。  
Zset的成员是唯一的，但分数（score）却可以重复。  
成功添加元素返回1，元素已存在返回0并不作添加。

##### 有序集合命令 #####

1、ZADD key score1 member1 \[score2 member2\] ：向有序集合添加一个或多个成员，或者更新已存在成员的分数

redis> ZADD myzset 1 "one"
    (integer) 1
    redis> ZADD myzset 1 "uno"
    (integer) 1
    redis> ZADD myzset 2 "two" 3 "three"
    (integer) 2
    redis> ZRANGE myzset 0 -1 WITHSCORES
    1) "one"
    2) "1"
    3) "uno"
    4) "1"
    5) "two"
    6) "2"
    7) "three"
    8) "3"
    redis>

2、ZCARD key ：获取有序集合的成员数

redis> ZADD myzset 1 "one"
    (integer) 1
    redis> ZADD myzset 2 "two"
    (integer) 1
    redis> ZCARD myzset
    (integer) 2
    redis>

3、ZCOUNT key min max  
计算在有序集合中指定区间分数的成员数

redis 127.0.0.1:6379> ZADD myzset 1 "hello"
    (integer) 1
    redis 127.0.0.1:6379> ZADD myzset 1 "foo"
    (integer) 1
    redis 127.0.0.1:6379> ZADD myzset 2 "world" 3 "bar"
    (integer) 2
    redis 127.0.0.1:6379> ZCOUNT myzset 1 3
    (integer) 4

4、ZINCRBY key increment member  
有序集合中对指定成员的分数加上增量 increment

redis> ZADD myzset 1 "one"
    (integer) 1
    redis> ZADD myzset 2 "two"
    (integer) 1
    redis> ZINCRBY myzset 2 "one"
    "3"
    redis> ZRANGE myzset 0 -1 WITHSCORES
    1) "two"
    2) "2"
    3) "one"
    4) "3"
    redis>

5、ZINTERSTORE destination numkeys key \[key …\]  
计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 destination 中

# 有序集 mid_test
    redis 127.0.0.1:6379> ZADD mid_test 70 "Li Lei"
    (integer) 1
    redis 127.0.0.1:6379> ZADD mid_test 70 "Han Meimei"
    (integer) 1
    redis 127.0.0.1:6379> ZADD mid_test 99.5 "Tom"
    (integer) 1
    # 另一个有序集 fin_test
    redis 127.0.0.1:6379> ZADD fin_test 88 "Li Lei"
    (integer) 1
    redis 127.0.0.1:6379> ZADD fin_test 75 "Han Meimei"
    (integer) 1
    redis 127.0.0.1:6379> ZADD fin_test 99.5 "Tom"
    (integer) 1
    # 交集
    redis 127.0.0.1:6379> ZINTERSTORE sum_point 2 mid_test fin_test
    (integer) 3
    # 显示有序集内所有成员及其分数值
    redis 127.0.0.1:6379> ZRANGE sum_point 0 -1 WITHSCORES     
    1) "Han Meimei"
    2) "145"
    3) "Li Lei"
    4) "158"
    5) "Tom"
    6) "199"

6、ZLEXCOUNT key min max  
在有序集合中计算指定字典区间内成员数量

redis 127.0.0.1:6379> ZADD myzset 0 a 0 b 0 c 0 d 0 e
    (integer) 5
    redis 127.0.0.1:6379> ZADD myzset 0 f 0 g
    (integer) 2
    redis 127.0.0.1:6379> ZLEXCOUNT myzset - +
    (integer) 7
    redis 127.0.0.1:6379> ZLEXCOUNT myzset [b [f
    (integer) 5

7、ZRANGE key start stop \[WITHSCORES\]  
通过索引区间返回有序集合指定区间内的成员

redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES             # 显示整个有序集成员
    1) "jack"
    2) "3500"
    3) "tom"
    4) "5000"
    5) "boss"
    6) "10086"
    redis 127.0.0.1:6379> ZRANGE salary 1 2 WITHSCORES              # 显示有序集下标区间 1 至 2 的成员
    1) "tom"
    2) "5000"
    3) "boss"
    4) "10086"
    redis 127.0.0.1:6379> ZRANGE salary 0 200000 WITHSCORES         # 测试 end 下标超出最大下标时的情况
    1) "jack"
    2) "3500"
    3) "tom"
    4) "5000"
    5) "boss"
    6) "10086"
    redis > ZRANGE salary 200000 3000000 WITHSCORES                  # 测试当给定区间不存在于有序集时的情况
    (empty list or set)

8、ZRANGEBYLEX key min max \[LIMIT offset count\]  
通过字典区间返回有序集合的成员

redis 127.0.0.1:6379> ZADD myzset 0 a 0 b 0 c 0 d 0 e 0 f 0 g
    (integer) 7
    redis 127.0.0.1:6379> ZRANGEBYLEX myzset - [c
    1) "a"
    2) "b"
    3) "c"
    redis 127.0.0.1:6379> ZRANGEBYLEX myzset - (c
    1) "a"
    2) "b"
    redis 127.0.0.1:6379> ZRANGEBYLEX myzset [aaa (g
    1) "b"
    2) "c"
    3) "d"
    4) "e"
    5) "f"
    redis>

9、ZRANGEBYSCORE key min max \[WITHSCORES\] \[LIMIT\]  
通过分数返回有序集合指定区间内的成员

redis 127.0.0.1:6379> ZADD salary 2500 jack                        # 测试数据
    (integer) 0
    redis 127.0.0.1:6379> ZADD salary 5000 tom
    (integer) 0
    redis 127.0.0.1:6379> ZADD salary 12000 peter
    (integer) 0
    
    redis 127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf               # 显示整个有序集
    1) "jack"
    2) "tom"
    3) "peter"
    
    redis 127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf WITHSCORES    # 显示整个有序集及成员的 score 值
    1) "jack"
    2) "2500"
    3) "tom"
    4) "5000"
    5) "peter"
    6) "12000"
    
    redis 127.0.0.1:6379> ZRANGEBYSCORE salary -inf 5000 WITHSCORES    # 显示工资 <=5000 的所有成员
    1) "jack"
    2) "2500"
    3) "tom"
    4) "5000"
    
    redis 127.0.0.1:6379> ZRANGEBYSCORE salary (5000 400000            # 显示工资大于 5000 小于等于 400000 的成员
    1) "peter"

10、ZRANK key member  
返回有序集合中指定成员的索引

redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES        # 显示所有成员及其 score 值
    1) "peter"
    2) "3500"
    3) "tom"
    4) "4000"
    5) "jack"
    6) "5000"
    
    redis 127.0.0.1:6379> ZRANK salary tom                     # 显示 tom 的薪水排名，第二
    (integer) 1

11、ZREM key member \[member …\]  
移除有序集合中的一个或多个成员

# 测试数据
    
    redis 127.0.0.1:6379> ZRANGE page_rank 0 -1 WITHSCORES
    1) "bing.com"
    2) "8"
    3) "baidu.com"
    4) "9"
    5) "google.com"
    6) "10"
    
    
    # 移除单个元素
    
    redis 127.0.0.1:6379> ZREM page_rank google.com
    (integer) 1
    
    redis 127.0.0.1:6379> ZRANGE page_rank 0 -1 WITHSCORES
    1) "bing.com"
    2) "8"
    3) "baidu.com"
    4) "9"
    
    
    # 移除多个元素
    
    redis 127.0.0.1:6379> ZREM page_rank baidu.com bing.com
    (integer) 2
    
    redis 127.0.0.1:6379> ZRANGE page_rank 0 -1 WITHSCORES
    (empty list or set)
    
    
    # 移除不存在元素
    
    redis 127.0.0.1:6379> ZREM page_rank non-exists-element
    (integer) 0

12、ZREMRANGEBYLEX key min max  
移除有序集合中给定的字典区间的所有成员

redis 127.0.0.1:6379> ZADD myzset 0 aaaa 0 b 0 c 0 d 0 e
    (integer) 5
    redis 127.0.0.1:6379> ZADD myzset 0 foo 0 zap 0 zip 0 ALPHA 0 alpha
    (integer) 5
    redis 127.0.0.1:6379> ZRANGE myzset 0 -1
    1) "ALPHA"
     2) "aaaa"
     3) "alpha"
     4) "b"
     5) "c"
     6) "d"
     7) "e"
     8) "foo"
     9) "zap"
    10) "zip"
    redis 127.0.0.1:6379> ZREMRANGEBYLEX myzset [alpha [omega
    (integer) 6
    redis 127.0.0.1:6379> ZRANGE myzset 0 -1
    1) "ALPHA"
    2) "aaaa"
    3) "zap"
    4) "zip"
    redis>

13、ZREMRANGEBYRANK key start stop  
移除有序集合中给定的排名区间的所有成员

redis 127.0.0.1:6379> ZADD salary 2000 jack
    (integer) 1
    redis 127.0.0.1:6379> ZADD salary 5000 tom
    (integer) 1
    redis 127.0.0.1:6379> ZADD salary 3500 peter
    (integer) 1
    
    redis 127.0.0.1:6379> ZREMRANGEBYRANK salary 0 1       # 移除下标 0 至 1 区间内的成员
    (integer) 2
    
    redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES    # 有序集只剩下一个成员
    1) "tom"
    2) "5000"

14、ZREMRANGEBYSCORE key min max  
移除有序集合中给定的分数区间的所有成员

redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES          # 显示有序集内所有成员及其 score 值
    1) "tom"
    2) "2000"
    3) "peter"
    4) "3500"
    5) "jack"
    6) "5000"
    
    redis 127.0.0.1:6379> ZREMRANGEBYSCORE salary 1500 3500      # 移除所有薪水在 1500 到 3500 内的员工
    (integer) 2
    
    redis> ZRANGE salary 0 -1 WITHSCORES          # 剩下的有序集成员
    1) "jack"
    2) "5000"

15、ZREVRANGE key start stop \[WITHSCORES\]  
返回有序集中指定区间内的成员，通过索引，分数从高到低

redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES        # 递增排列
    1) "peter"
    2) "3500"
    3) "tom"
    4) "4000"
    5) "jack"
    6) "5000"
    
    redis 127.0.0.1:6379> ZREVRANGE salary 0 -1 WITHSCORES     # 递减排列
    1) "jack"
    2) "5000"
    3) "tom"
    4) "4000"
    5) "peter"
    6) "3500"

16、ZREVRANGEBYSCORE key max min \[WITHSCORES\]  
返回有序集中指定分数区间内的成员，分数从高到低排序

redis 127.0.0.1:6379> ZADD salary 10086 jack
    (integer) 1
    redis > ZADD salary 5000 tom
    (integer) 1
    redis 127.0.0.1:6379> ZADD salary 7500 peter
    (integer) 1
    redis 127.0.0.1:6379> ZADD salary 3500 joe
    (integer) 1
    
    redis 127.0.0.1:6379> ZREVRANGEBYSCORE salary +inf -inf   # 逆序排列所有成员
    1) "jack"
    2) "peter"
    3) "tom"
    4) "joe"
    
    redis 127.0.0.1:6379> ZREVRANGEBYSCORE salary 10000 2000  # 逆序排列薪水介于 10000 和 2000 之间的成员
    1) "peter"
    2) "tom"
    3) "joe"

17、ZREVRANK key member  
返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序

redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES     # 测试数据
    1) "jack"
    2) "2000"
    3) "peter"
    4) "3500"
    5) "tom"
    6) "5000"
    
    redis 127.0.0.1:6379> ZREVRANK salary peter     # peter 的工资排第二
    (integer) 1
    
    redis 127.0.0.1:6379> ZREVRANK salary tom       # tom 的工资最高
    (integer) 0

18、ZSCORE key member  
返回有序集中，成员的分数值

redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES    # 测试数据
    1) "tom"
    2) "2000"
    3) "peter"
    4) "3500"
    5) "jack"
    6) "5000"
    
    redis 127.0.0.1:6379> ZSCORE salary peter              # 注意返回值是字符串
    "3500"

19、ZUNIONSTORE destination numkeys key \[key …\]  
计算给定的一个或多个有序集的并集，并存储在新的 key 中

redis 127.0.0.1:6379> ZRANGE programmer 0 -1 WITHSCORES
    1) "peter"
    2) "2000"
    3) "jack"
    4) "3500"
    5) "tom"
    6) "5000"
    
    redis 127.0.0.1:6379> ZRANGE manager 0 -1 WITHSCORES
    1) "herry"
    2) "2000"
    3) "mary"
    4) "3500"
    5) "bob"
    6) "4000"
    
    redis 127.0.0.1:6379> ZUNIONSTORE salary 2 programmer manager WEIGHTS 1 3   # 公司决定加薪。。。除了程序员。。。
    (integer) 6
    
    redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES
    1) "peter"
    2) "2000"
    3) "jack"
    4) "3500"
    5) "tom"
    6) "5000"
    7) "herry"
    8) "6000"
    9) "mary"
    10) "10500"
    11) "bob"
    12) "12000"

20、ZSCAN key cursor \[MATCH pattern\] \[COUNT count\]  
迭代有序集合中的元素（包括元素成员和元素分值）

> ZADD site 1 "Google" 2 "Runoob" 3 "Taobao" 4 "Weibo"
    (integer) 4
    > ZSCAN site 0 match "R*"
    1) "0"
    2) 1) "Runoob"
    2) 2.0

## Redis发布订阅 ##

Redis发布订阅（pub/sub）是一种消息通信模式：发送者（pub）发送消息，订阅者（sub）接收消息。  
Redis客户端可以订阅任意数量的频道。

##### 发布订阅命令 #####

1、PSUBSCRIBE pattern \[pattern …\] ：订阅一个或多个符合给定模式的频道。

redis 127.0.0.1:6379> PSUBSCRIBE mychannel
    Reading messages... (press Ctrl-C to quit)
    1) "psubscribe"
    2) "mychannel"
    3) (integer) 1

2、PUBSUB subcommand \[argument \[argument …\]\]  
查看订阅与发布系统状态。

redis 127.0.0.1:6379> PUBSUB CHANNELS
    (empty list or set)

3、PUBLISH channel message  
将信息发送到指定的频道。

redis 127.0.0.1:6379> PUBLISH mychannel "hello, i m here"
    (integer) 1

4、PUNSUBSCRIBE \[pattern \[pattern …\]\]  
退订所有给定模式的频道。

redis 127.0.0.1:6379> PUNSUBSCRIBE mychannel 
    1) "punsubscribe"
    2) "a"
    3) (integer) 1

5、SUBSCRIBE channel \[channel …\]  
订阅给定的一个或多个频道的信息。

redis 127.0.0.1:6379> SUBSCRIBE mychannel 
    Reading messages... (press Ctrl-C to quit)
    1) "subscribe"
    2) "mychannel"
    3) (integer) 1
    1) "message"
    2) "mychannel"
    3) "a"

6、UNSUBSCRIBE \[channel \[channel …\]\]  
指退订给定的频道。

redis 127.0.0.1:6379> UNSUBSCRIBE mychannel 
    1) "unsubscribe"
    2) "a"
    3) (integer) 0

## Redis事务 ##

Redis事务可以一次执行多个命令，并且带有三个保证：  
1、批量操作在发送EXEC命令前被放入队列缓存。  
2、收到EXEC命令后进入事务执行，事务中任意命令执行失败，其余的命令依然执行。  
3、在事务执行过程，其他客户端提交的命令请求不会插入到事务执行命令序列中。

事务开始执行要经历的三个阶段：  
1、开始事务。  
2、命令入队。  
3、执行事务。

##### 事务命令 #####

1、DISCARD  
取消事务，放弃执行事务块内的所有命令。

redis 127.0.0.1:6379> MULTI
    OK
    
    redis 127.0.0.1:6379> PING
    QUEUED
    
    redis 127.0.0.1:6379> SET greeting "hello"
    QUEUED
    
    redis 127.0.0.1:6379> DISCARD
    OK

2、EXEC  
执行所有事务块内的命令。

# 事务被成功执行
    
    redis 127.0.0.1:6379> MULTI
    OK
    
    redis 127.0.0.1:6379> INCR user_id
    QUEUED
    
    redis 127.0.0.1:6379> INCR user_id
    QUEUED
    
    redis 127.0.0.1:6379> INCR user_id
    QUEUED
    
    redis 127.0.0.1:6379> PING
    QUEUED
    
    redis 127.0.0.1:6379> EXEC
    1) (integer) 1
    2) (integer) 2
    3) (integer) 3
    4) PONG
    
    
    # 监视 key ，且事务成功执行
    
    redis 127.0.0.1:6379> WATCH lock lock_times
    OK
    
    redis 127.0.0.1:6379> MULTI
    OK
    
    redis 127.0.0.1:6379> SET lock "huangz"
    QUEUED
    
    redis 127.0.0.1:6379> INCR lock_times
    QUEUED
    
    redis 127.0.0.1:6379> EXEC
    1) OK
    2) (integer) 1
    
    
    # 监视 key ，且事务被打断
    
    redis 127.0.0.1:6379> WATCH lock lock_times
    OK
    
    redis 127.0.0.1:6379> MULTI
    OK
    
    redis 127.0.0.1:6379> SET lock "joe"        # 就在这时，另一个客户端修改了 lock_times 的值
    QUEUED
    
    redis 127.0.0.1:6379> INCR lock_times
    QUEUED
    
    redis 127.0.0.1:6379> EXEC                  # 因为 lock_times 被修改， joe 的事务执行失败
    (nil)

3、MULTI  
标记一个事务块的开始。

redis 127.0.0.1:6379> MULTI            # 标记事务开始
    OK
    
    redis 127.0.0.1:6379> INCR user_id     # 多条命令按顺序入队
    QUEUED
    
    redis 127.0.0.1:6379> INCR user_id
    QUEUED
    
    redis 127.0.0.1:6379> INCR user_id
    QUEUED
    
    redis 127.0.0.1:6379> PING
    QUEUED
    
    redis 127.0.0.1:6379> EXEC             # 执行
    1) (integer) 1
    2) (integer) 2
    3) (integer) 3
    4) PONG

4、UNWATCH  
取消 WATCH 命令对所有 key 的监视。

redis 127.0.0.1:6379> WATCH lock lock_times
    OK
    
    redis 127.0.0.1:6379> UNWATCH
    OK

5、WATCH key \[key …\]  
监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。

redis> WATCH lock lock_times
    OK

## Redis连接 ##

##### 连接命令 #####

1、AUTH password ：验证密码是否正确。  
用于检测给定的密码和配置文件中的密码是否相符。  
密码匹配时返回OK，否则返回一个错误。

redis 127.0.0.1:6379> AUTH PASSWORD
    (error) ERR Client sent AUTH, but no password is set
    redis 127.0.0.1:6379> CONFIG SET requirepass "mypass"
    OK
    redis 127.0.0.1:6379> AUTH mypass
    Ok

2、ECHO message ：打印字符串。

redis 127.0.0.1:6379> ECHO "Hello World"
    "Hello World"

3、PING ：查看服务是否运行。  
连接正常返回pong，否则返回一个连接错误。

# 客户端和服务器连接正常
    redis 127.0.0.1:6379> PING
    PONG
    # 客户端和服务器连接不正常(网络不正常或服务器未能正常运行)
    redis 127.0.0.1:6379> PING
    Could not connect to Redis at 127.0.0.1:6379: Connection refused

4、QUIT ：关闭当前连接。

redis 127.0.0.1:6379> QUIT
    OK

5、SELECT index ：切换到指定的数据库。

redis 127.0.0.1:6379> SET db_number 0         # 默认使用 0 号数据库
    OK
    redis 127.0.0.1:6379> SELECT 1                # 使用 1 号数据库
    OK
    redis 127.0.0.1:6379[1]> GET db_number        # 已经切换到 1 号数据库，注意 Redis 现在的命令提示符多了个 [1]
    (nil)
    redis 127.0.0.1:6379[1]> SET db_number 1
    OK
    redis 127.0.0.1:6379[1]> GET db_number
    "1"
    redis 127.0.0.1:6379[1]> SELECT 3             # 再切换到 3 号数据库
    OK
    redis 127.0.0.1:6379[3]>                      # 提示符从 [1] 改变成了 [3]

## Redis服务 ##

##### 服务器命令 #####

1、BGREWRITEAOF ：异步执行一个 AOF（AppendOnly File） 文件重写操作。  
重写会创建一个当前AOF文件的体积优化版本。  
即使Bgrewriteaof执行失败，也不会有任何数据丢失，因为旧的AOF文件在Bgrewriteaof成功之前不会被修改。  
注意：

从Redis2.4开始，AOF重写由redis自行触发，Bgrewriteaof仅仅用于手动触发重写操作。

实例：

redis 127.0.0.1:6379>
    Background append only file rewriting started

2、BGSAVE ：在后台异步保存当前数据库的数据到磁盘  
bgsave命令执行之后立即返回OK，然后Redis fork出一个新子进程，原来的Redis进程（父进程）继续处理客户端请求，而子进程则负责将数据保存到磁盘，然后退出。

redis> BGSAVE
    Background saving started

3、CLIENT KILL \[ip:port\] \[ID client-id\] ：关闭客户端连接。  
成功关闭，返回OK。

# 列出所有已连接客户端
    
    redis 127.0.0.1:6379> CLIENT LIST
    addr=127.0.0.1:43501 fd=5 age=10 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=0 qbuf-free=32768 obl=0 oll=0 omem=0 events=r cmd=client
    
    # 杀死当前客户端的连接
    
    redis 127.0.0.1:6379> CLIENT KILL 127.0.0.1:43501
    OK
    
    # 之前的连接已经被关闭，CLI 客户端又重新建立了连接
    # 之前的端口是 43501 ，现在是 43504
    
    redis 127.0.0.1:6379> CLIENT LIST
    addr=127.0.0.1:43504 fd=5 age=0 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=0 qbuf-free=32768 obl=0 oll=0 omem=0 events=r cmd=client

4、CLIENT LIST ：获取连接到服务器的客户端连接列表。  
返回值：

命令返回多行字符串，这些字符串按以下形式被格式化：
    
    每个已连接客户端对应一行（以 LF 分割）。
    每行字符串由一系列 属性=值 形式的域组成，每个域之间以空格分开。
    
    以下是域的含义：
    addr ： 客户端的地址和端口
    fd ： 套接字所使用的文件描述符
    age ： 以秒计算的已连接时长
    idle ： 以秒计算的空闲时长
    flags ： 客户端 flag
    db ： 该客户端正在使用的数据库 ID
    sub ： 已订阅频道的数量
    psub ： 已订阅模式的数量
    multi ： 在事务中被执行的命令数量
    qbuf ： 查询缓冲区的长度（字节为单位， 0 表示没有分配查询缓冲区）
    qbuf-free ： 查询缓冲区剩余空间的长度（字节为单位， 0 表示没有剩余空间）
    obl ： 输出缓冲区的长度（字节为单位， 0 表示没有分配输出缓冲区）
    oll ： 输出列表包含的对象数量（当输出缓冲区没有剩余空间时，命令回复会以字符串对象的形式被入队到这个队列里）
    omem ： 输出缓冲区和输出列表占用的内存总量
    events ： 文件描述符事件
    cmd ： 最近一次执行的命令
    
    客户端 flag 可以由以下部分组成：
    O ： 客户端是 MONITOR 模式下的附属节点（slave）
    S ： 客户端是一般模式下（normal）的附属节点
    M ： 客户端是主节点（master）
    x ： 客户端正在执行事务
    b ： 客户端正在等待阻塞事件
    i ： 客户端正在等待 VM I/O 操作（已废弃）
    d ： 一个受监视（watched）的键已被修改， EXEC 命令将失败
    c : 在将回复完整地写出之后，关闭链接
    u : 客户端未被阻塞（unblocked）
    A : 尽可能快地关闭连接
    N : 未设置任何 flag
    
    文件描述符事件可以是：
    r : 客户端套接字（在事件 loop 中）是可读的（readable）
    w : 客户端套接字（在事件 loop 中）是可写的（writeable）

实例：

redis 127.0.0.1:6379> CLIENT LIST
    addr=127.0.0.1:43143 fd=6 age=183 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=0 qbuf-free=32768 obl=0 oll=0 omem=0 events=r cmd=client
    addr=127.0.0.1:43163 fd=5 age=35 idle=15 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=0 qbuf-free=0 obl=0 oll=0 omem=0 events=r cmd=ping
    addr=127.0.0.1:43167 fd=7 age=24 idle=6 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=0 qbuf-free=0 obl=0 oll=0 omem=0 events=r cmd=get

5、CLIENT GETNAME ：获取连接的名称。  
如果连接没有设置名字，那么返回空白回复； 如果有设置名字，那么返回名字。

6、CLIENT PAUSE timeout ：在指定时间内终止运行来自客户端的命令。  
7、CLIENT SETNAME connection-name ：设置当前连接的名称。

# 新连接默认没有名字
    redis 127.0.0.1:6379> CLIENT GETNAME
    (nil)
    # 设置名字
    redis 127.0.0.1:6379> CLIENT SETNAME hello-world-connection
    OK
    # 返回名字
    redis 127.0.0.1:6379> CLIENT GETNAME
    "hello-world-connection"
    # 在客户端列表中查看
    redis 127.0.0.1:6379> CLIENT LIST
    addr=127.0.0.1:36851
    fd=5
    name=hello-world-connection     # <- 名字
    age=51
    ...
    # 清除名字
    redis 127.0.0.1:6379> CLIENT SETNAME        # 只用空格是不行的！
    (error) ERR Syntax error, try CLIENT (LIST | KILL ip:port)
    redis 127.0.0.1:6379> CLIENT SETNAME ""     # 必须双引号显示包围
    OK
    redis 127.0.0.1:6379> CLIENT GETNAME        # 清除完毕
    (nil)

8、CLUSTER SLOTS ：获取集群节点的映射数组。

redis 127.0.0.1:6379> cluster slots
    1) 1) (integer) 0
       2) (integer) 4095
       3) 1) "127.0.0.1"
          2) (integer) 7000
       4) 1) "127.0.0.1"
          2) (integer) 7004
    2) 1) (integer) 12288
       2) (integer) 16383
       3) 1) "127.0.0.1"
          2) (integer) 7003
       4) 1) "127.0.0.1"
          2) (integer) 7007
    3) 1) (integer) 4096
       2) (integer) 8191
       3) 1) "127.0.0.1"
          2) (integer) 7001
       4) 1) "127.0.0.1"
          2) (integer) 7005
    4) 1) (integer) 8192
       2) (integer) 12287
       3) 1) "127.0.0.1"
          2) (integer) 7002
       4) 1) "127.0.0.1"
          2) (integer) 7006

9、COMMAND ：获取 Redis 命令详情数组。  
嵌套的Redis命令的详细信息列表。列表顺序是随机的。  
10、COMMAND COUNT ：获取 Redis 命令总数。

redis 127.0.0.1:6379> COMMAND COUNT
    (integer) 163

11、COMMAND GETKEYS ：获取给定命令的所有键。

redis 127.0.0.1:6379> COMMAND GETKEYS MSET a b c d e f 
    1) "a"
    2) "c"
    3) "e"

12、TIME ：返回当前服务器时间。

redis 127.0.0.1:6379> TIME 
    1) "1410856598"
    2) "928370"

## Redis Stream ##

Redis5.0版本新增加的数据结构。