1. 安装redis

1.1 安装

• 1.进入/opt目录下
  cd /opt
• 2.安装

wget http://download.redis.io/releases/redis-5.0.2.tar.gz
tar xzf redis-5.0.2.tar.gz
cd redis-5.0.2
make

1.2 备份redis的配置文件

> 进入opt目录
    cd /opt
> 新建一个myredisconf文件夹
    mkdir myredisconf
> 进入redis的安装目录
    cd /opt/redis-5.0.2
>复制配置文件到myredisconf文件加
    cp ./redis.conf ../myredisconf

1.3 修改redis备份后的配置文件

vim /opt/myredisconf/redis.conf

将下面的daemonize no改为yes
################################ GENERAL #####################################
# By default Redis does not run as a daemon. Use 'yes' if you need it.
# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
daemonize yes

1.4 启动redis的服务端

进入到redis的src目录下
cd /opt/redis-5.0.2/src
使用备份的配置文件启动redis服务端
./redis-server /opt/myredisconf/redis.conf

看到类似如下提示说明启动成功
8347:C 11 Dec 2018 16:36:52.716 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
8347:C 11 Dec 2018 16:36:52.716 # Redis version=5.0.2, bits=64, commit=00000000, modified=0, pid=8347, just started
8347:C 11 Dec 2018 16:36:52.716 # Configuration loaded

接着启动redis的客户端，默认端口号是6379，参数-p
./redis-cli -p 6379
出现下面提示便进入到了redis的客户端
127.0.0.1:6379> 
测试连接
输入：ping
redis回答PONG说明连接成功
测试存储
set k1 helloworld
get k1
看到
“helloworld”
使用select 库号 可以切换库

1.5 redis性能测试

启动redis服务器，切换到redis安装目录下，运行redis-benchmark即可看到测试读写速度

2. redis启动后杂项基础知识

• dbsize

查看当前库的key数量

• keys pattern （如：keys *,keys k?)

列出当前库所有键，keys支持正则查询，例如：keys k?会查询首字母带k的键

keys [0-9]* 会查询出首字母是数字的所有key

• flushall

清空所有库（不要用！）

• flushdb

清空当前库（不要用！）

redis统一密码管理，16个库密码要么不用，要么都相同

3. redis五大数据类型

Redis is an open source (BSD licensed), in-memory data structure store, used as a database, cache and message broker. It supports data structures such as strings, hashes, lists, sets, sorted sets with range queries, bitmaps, hyperloglogs, geospatial indexes with radius queries and streams. Redis has built-in replication, Lua scripting, LRU eviction, transactions and different levels of on-disk persistence, and provides high availability via Redis Sentinel and automatic partitioning with Redis Cluster.

redis是一个内存数据结构存储器，可以用来作为数据库、缓存和消息代理。他支持的数据类型有

• String
• hash
• list
• set
• sorted set
• bitmap
• 超级日志
• 具有半径查询和流地理空间索引

3.0 redis 键操作（key)

• keys *
• exists key名：判断某个key是否存在
• move key db：将key记录移动到其他库
• expire key 秒数：为给定的key设置过期时间
• ttl key：查看还有多少秒过期，-1表示永不过期，-2表示已过期，过期后记录不存在
• type key：查看key的类型

如果存储时键已经存在则内容覆盖

其他命令查文档

redis命令参考网址：http://redisdoc.com/

3.1 String型

String是redis最基本的类型，可以理解为与memcache一模一样的类型，一个key对应一个value。

String类型二进制安全的，意思是redis的String可以包含任何数据。比如jpg的图片或者序列化的对象，一个redis中字符串value最多可以是512M。

字符串操作指令：

• strlen key：

获取键长度

• append key:

追加

• 对于键是纯数值的：

incr key：单步递增
decr key：单步递减
incrby key：设置步长递增
decrby key：设置步长递减

• getrange

获取指定区间范围内的值，相当于字符串截取如：
getrange k1 0 3

• setex(set with expire)键秒值

将键 key 的值设置为 value ， 并将键 key 的生存时间设置为 seconds 秒钟。
如果键 key 已经存在， 那么 SETEX 命令将覆盖已有的值。
SETEX 命令的效果和以下两个命令的效果类似：
SET key value
EXPIRE key seconds  # 设置生存时间

SETEX 和这两个命令的不同之处在于 SETEX 是一个原子（atomic）操作， 它可以在同一时间内完成设置值和设置过期时间这两个操作， 因此 SETEX 命令在储存缓存的时候非常实用。

• setnx(set if not exist)

SETEX 和这两个命令的不同之处在于 `SETEX` 是一个原子（atomic）操作， 它可以在同一时间内完成设置值和设置过期时间这两个操作， 因此 `SETEX` 命令在储存缓存的时候非常实用。

返回值
命令在设置成功时返回 1 ， 设置失败时返回 0 。

示例：
redis> EXISTS job                # job 不存在
(integer) 0

redis> SETNX job "programmer"    # job 设置成功
(integer) 1

• MSET key value [key value …]

同时为多个键设置值。

如果某个给定键已经存在， 那么 MSET 将使用新值去覆盖旧值， 如果这不是你所希望的效果， 请考虑使用 MSETNX 命令， 这个命令只会在所有给定键都不存在的情况下进行设置。

MSET 命令总是返回 OK 。

示例：
redis> MSET date "2012.3.30" time "11:00 a.m." weather "sunny"
OK

• MGET key [key …]

返回给定的一个或多个字符串键的值。

如果给定的字符串键里面， 有某个键不存在， 那么这个键的值将以特殊值 nil 表示。

返回值：
MGET 命令将返回一个列表， 列表中包含了所有给定键的值。

示例：
redis> MGET redis mongodb
1) "redis.com"
2) "mongodb.org"

• MSETNX key value [key value …]

当且仅当所有给定键都不存在时， 为所有给定键设置值。

即使只有一个给定键已经存在， MSETNX 命令也会拒绝执行对所有键的设置操作。

MSETNX 是一个原子性(atomic)操作， 所有给定键要么就全部都被设置， 要么就全部都不设置， 不可能出现第三种状态。

返回值：
当所有给定键都设置成功时， 命令返回 1 ； 如果因为某个给定键已经存在而导致设置未能成功执行， 那么命令返回 0 。

示例：
对不存在的键执行 MSETNX 命令：
MSETNX k1 "MySQL" k2 "MongoDB" k3 "redis"
对某个已经存在的键进行设置：
redis> MSETNX rmdbs "Sqlite" language "python"  # rmdbs 键已经存在，操作失败
(integer) 0

3.2 List列表

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

• LPUSH key value [value …]

作用：将一个或多个值 value 插入到列表 key 的表头

描述：如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表头： 比如说，对空列表 mylist 执行命令 LPUSH mylist a b c ，列表的值将是 c b a ，这等同于原子性地执行 LPUSH mylist a 、 LPUSH mylist b 和 LPUSH mylist c 三个命令。
如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。
当 key 存在但不是列表类型时，返回一个错误。

返回值：
执行 LPUSH 命令后，列表的长度。

示例：
redis> lpush mylist a b c d a # 列表允许重复元素
redis> LRANGE mylist 0 -1 
“a”
"b"
"c"
"d"
"a"

• LPUSHX key value

作用：将值 value 插入到列表 key 的表头，当且仅当 key 存在并且是一个列表。相当于对已存在的列表执行追加操作。
和 LPUSH key value [value …] 命令相反，当 key 不存在时， LPUSHX 命令什么也不做。

示例：
# 对空列表执行 LPUSHX
redis> LPUSHX greet "hello"      # 尝试 LPUSHX，失败，因为列表为空
(integer) 0
# 对非空列表执行 LPUSHX
redis> LPUSHX greet "good morning"      # 这次 LPUSHX 执行成功
(integer) 2

• RPUSH key value [value …]

作用：将一个或多个值 value 插入到列表 key 的表尾(最右边)。

描述：如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表尾：比如对一个空列表 mylist 执行 RPUSH mylist a b c ，得出的结果列表为 a b c ，等同于执行命令 RPUSH mylist a 、 RPUSH mylist b 、 RPUSH mylist c 。

如果 key 不存在，一个空列表会被创建并执行 RPUSH 操作
当 key 存在但不是列表类型时，返回一个错误。

返回值：
执行 RPUSH 操作后，表的长度。

示例：
redis> RPUSH mylist a b c
(integer) 3

redis> LRANGE mylist 0 -1
1) "a"
2) "b"
3) "c"

• LPOP key

作用：移除并返回列表 key 的头元素

返回值：
列表的头元素。 当 key 不存在时，返回 nil 。

示例：类似队列,先进先出
redis> RPUSH mylist a b c
(integer) 3
redis>lpop mylist
"a"

• RPOP key

作用：移除并返回列表 key 的尾元素。

返回值：
列表的尾元素。 当 key 不存在时，返回 nil 。

示例：类似栈，先进后出
redis> RPUSH mylist a b c d
(integer) 3
redis>rpop mylist
"d"

• LINDEX key index

作用：返回列表 key 中，下标为 index 的元素。

描述：下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。如果 key 不是列表类型，返回一个错误。

返回值：列表中下标为 index 的元素。 如果 index 参数的值不在列表的区间范围内(out of range)，返回 nil 

示例：
redis> lpush mylist 1 2 3 4 5
redis> lrange mylist 0 -1
1) "5"
2) "4"
3) "3"
4) "2"
5) "1"
redis> lindex mylist 1
"4"

• LLEN key

作用：返回列表 key 的长度。

描述：如果 key 不存在，则 key 被解释为一个空列表，返回 0
如果 key 不是列表类型，返回一个错误。

返回值：列表 key 的长度。

示例：
redis> llen mylist
(integer) 5

• LREM key count value

作用：根据参数 count 的值，移除列表中与参数 value 相等的元素。

描述：count 的值可以是以下几种：
count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。
count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。
count = 0 : 移除表中所有与 value 相等的值。

返回值：被移除元素的数量。 因为不存在的 key 被视作空表(empty list)，所以当 key 不存在时， LREM 命令总是返回 0 。

示例：
redis> lrange mylist 0 -1
1) "3"
2) "2"
3) "2"
4) "2"
5) "5"
6) "4"
7) "3"
8) "2"
9) "1"
redis> lrem mylist 2 2 #移除2个mylist中的2
(integer) 2
redis> lrange mylist 0 -1
1) "3"
2) "2"
3) "5"
4) "4"
5) "3"
6) "2"
7) "1"

• LTRIM key start stop

作用：对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。

描述：举个例子，执行命令 LTRIM list 0 2 ，表示只保留列表 list 的前三个元素，其余元素全部删除。下标(index)参数 start 和 stop 都以 0 为底。也可以使用负数下标，以 -1 表示列表的最后一个元素，-2 表示列表的倒数第二个元素。

返回值：
当 key 不是列表类型时，返回一个错误
命令执行成功时，返回 ok 。

注意：
超出范围的下标值不会引起错误。
如果 start 下标比列表的最大下标 end ( LLEN list 减去 1 )还要大，或者 start > stop ， LTRIM 返回一个空列表(因为 LTRIM 已经将整个列表清空)。
如果 stop 下标比 end 下标还要大，Redis将 stop 的值设置为 end 。

示例：
redis> lpush mylist 1 2 3 4 5 6
redis> lrange mylist 0 -1
1) "8"
2) "7"
3) "6"
4) "5"
5) "4"
6) "3"
7) "2"
8) "1"
redis> LTRIM mylist 0 4 #截取0-4的元素
OK
redis> lrange mylist 0 -1
1) "8"
2) "7"
3) "6"
4) "5"
5) "4"

redis> ltrim mylist 0 10086 #如果 stop下标比end下标还要大，则stop=end 。
redis> lrange mylist 0 -1 #所以一个也没有被丢弃
1) "8"
2) "7"
3) "6"
4) "5"
5) "4"

redis> ltrim mylist 10086 4 #start > end 则列表被清空
redis> lrange mylist 0 -1
(empty list or set)

• RPOPLPUSH source destination

作用：
将列表 source 中的最后一个元素(尾元素)弹出，并返回给客户端。
将 source 弹出的元素插入到列表 destination ，作为 destination 列表的的头元素

描述：
如果 source 不存在，值 nil 被返回，并且不执行其他动作。
如果 source 和 destination 相同，则列表中的表尾元素被移动到表头，并返回该元素，可以把这种特殊情况视作列表的旋转(rotation)操作。

返回值：被弹出的元素。

示例：
redis> lpush mylist 1 2 3 4 5
redis> lrange mylist 0 -1
1) "5"
2) "4"
3) "3"
4) "2"
5) "1"
redis> rpoplpush mylist deslist #将mylist的尾元素添加到deslist的头部
1) "1"

redis> lrange deslist 0 -1
1) "1"

• LSET key index value

作用：将列表 key 下标为 index 的元素的值设置为 value 。
当 index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误。

返回值：
操作成功返回 ok ，否则返回错误信息。

示例：
redis> lpush mylist 1 2 3 4 5
(integer) 5
redis> lrange mylist 0 -1
1) "5"
2) "4"
3) "3"
4) "2"
5) "1"
redis> lset mylist 2 7 #将下标为2的元素设置为7
OK
redis> lrange mylist 0 -1
1) "5"
2) "4"
3) "7"
4) "2"
5) "1"

• LINSERT key BEFORE|AFTER pivot value

作用：将值 value 插入到列表 key 当中，位于值 pivot 之前或之后。
当 pivot 不存在于列表 key 时，不执行任何操作。
当 key 不存在时， key 被视为空列表，不执行任何操作。
如果 key 不是列表类型，返回一个错误。

返回值：
如果命令执行成功，返回插入操作完成之后，列表的长度。 如果没有找到 pivot ，返回 -1 。 如果 key 不存在或为空列表，返回 0 。

示例：
redis> lpush mylist js is the best language
(integer) 5
redis> lrange mylist 0 -1
1) "language"
2) "best"
3) "the"
4) "is"
5) "js"

redis> linsert mylist before js java #在js之前插入java
(integer) 6
redis> lrange mylist 0 -1
1) "language"
2) "best"
3) "the"
4) "is"
5) "java"
6) "js"

总结：

他是一个字符串列表，left，right都可以插入/添加

如果键不存在，创建心得链表；

如果键已经存在，新增内容；

如果值全部移除，对应得键也就消失了。

链表得操作无论是头还是尾效率都极高，但假如是对中间元素进行操作，效率就很惨淡了。

3.3 Set集合

redis的set是string类型的无需集合。它是通过HashTable实现的。

• SADD key member [member …]

作用：将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。
假如 key 不存在，则创建一个只包含 member 元素作成员的集合。
当 key 不是集合类型时，返回一个错误。

返回值：
被添加到集合中的新元素的数量，不包括被忽略的元素。

示例：
redis> sadd set01 hello world hello 
(integer) 2
redis> smembers set01
1) "world"
2) "hello"

• SMEMBERS key

作用：返回集合 key 中的所有成员。
不存在的 key 被视为空集合。

返回值：
集合中的所有成员。

示例：
redis> SADD language Ruby Python Clojure
(integer) 3

redis> SMEMBERS language
1) "Python"
2) "Ruby"
3) "Clojure"

• SISMEMBER key member

作用：判断 member 元素是否集合 key 的成员。

返回值：
如果 member 元素是集合的成员，返回 1 。 如果 member 元素不是集合的成员，或 key 不存在，返回 0 。

示例：
redis> sismember set01 hello
(integer) 1

• SCARD key

作用：返回集合 key 的基数(集合中元素的数量)。

返回值：
集合的基数。 当 key 不存在时，返回 0 。

示例：
redis> scard set01
(integer) 2

• SREM key member [member …]

作用：移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。
当 key 不是集合类型，返回一个错误。

返回值：被成功移除的元素的数量，不包括被忽略的元素。

示例：
redis> SMEMBERS set01
1) "hello"
2) "world"
redis> srem set01 hello
(integer) 1
redis> SMEMBERS set01
1) "world"

• SRANDMEMBER key [count]

作用：如果命令执行时，只提供了 key 参数，那么返回集合中的一个随机元素。

描述：从 Redis 2.6 版本开始， SRANDMEMBER 命令接受可选的 count 参数：
如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。
如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。
该操作和 SPOP key 相似，但 SPOP key 将随机元素从集合中移除并返回，而 SRANDMEMBER 则仅仅返回随机元素，而不对集合进行任何改动。

返回值：
只提供 key 参数时，返回一个元素；如果集合为空，返回 nil 。 如果提供了 count 参数，那么返回一个数组；如果集合为空，返回空数组。

示例：
127.0.0.1:6379> sadd set02 hello is anybody here me
(integer) 5
redis> SRANDMEMBER set02 3
1) "hello"
2) "me"
3) "anybody"
redis> SRANDMEMBER set02 3
1) "hello"
2) "me"
3) "anybody"
redis> SRANDMEMBER set02 3
1) "is"
2) "me"
3) "anybody"

• SPOP key

作用:移除并返回集合中的一个随机元素。

返回值：被移除的随机元素。 当 key 不存在或 key 是空集时，返回 nil 。

示例：5.x版本可以指定pop个数
redis> SMEMBERS set02
1) "is"
2) "here"
3) "anybody"
4) "hello"
5) "me"
redis> spop set02
"here"
redis> spop set02 2
1) "anybody"
2) "is"
redis> SMEMBERS set02
1) "hello"
2) "me"

• SMOVE source destination member

作用：将 member 元素从 source 集合移动到 destination 集合。

描述：
如果 source 集合不存在或不包含指定的 member 元素，则 SMOVE 命令不执行任何操作，仅返回 0 。否则， member 元素从 source 集合中被移除，并添加到 destination 集合中去。
当 destination 集合已经包含 member 元素时， SMOVE 命令只是简单地将 source 集合中的 member 元素删除。

返回值：
如果 member 元素被成功移除，返回 1 。 如果 member 元素不是 source 集合的成员，并且没有任何操作对 destination 集合执行，那么返回 0 。

示例：
redis> SMEMBERS set01
1) "are"
2) "you"
3) "world"
redis> SMEMBERS set02
1) "x"
2) "y"
3) "z"
redis>  smove set01 set02 world
(integer) 1
redis> SMEMBERS set02
1) "z"
2) "y"
3) "world"
4) "x"

数学集合类：

• 差集：SDIFF key [key …]

作用：返回一个集合的全部成员，该集合是所有给定集合之间的差集。不存在的 key 被视为空集

返回值：一个包含差集成员的列表。

示例：
redis> sadd set01 1 2 3 4 5 x y 
(integer) 7
redis> sadd set02 1 2 3 4 a b c
(integer) 7
redis> sdiff set01 set02
1) "y"
2) "x"
3) "5"

• 交集：SINTER key [key …]

作用：返回一个集合的全部成员，该集合是所有给定集合的交集。
不存在的 key 被视为空集。
当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)。

返回值：交集成员的列表。

示例：
redis> sadd set01 1 2 3 4 5 x y 
(integer) 7
redis> sadd set02 1 2 3 4 a b c
(integer) 7
redis> sinter set01 set02
1) "2"
2) "3"
3) "1"
4) "4"

• 并集：SUNION key [key …]

作用：返回一个集合的全部成员，该集合是所有给定集合的并集。
不存在的 key 被视为空集。

返回值：并集成员的列表。

示例：
redis> sadd set01 1 2 3 4 5 x y 
(integer) 7
redis> sadd set02 1 2 3 4 a b c
(integer) 7
redis> SUNION set01 set02
 1) "y"
 2) "3"
 3) "1"
 4) "c"
 5) "4"
 6) "x"
 7) "5"
 8) "2"
 9) "a"
10) "b"

3.4 Hash

类似Java里面的Map<String,Object>

• HSET hash field value

作用：将哈希表 hash 中域 field 的值设置为 value 。
如果给定的哈希表并不存在， 那么一个新的哈希表将被创建并执行 HSET 操作。
如果域 field 已经存在于哈希表中， 那么它的旧值将被新值 value 覆盖。

返回值：
当 HSET 命令在哈希表中新创建 field 域并成功为它设置值时， 命令返回 1 ； 如果域 field 已经存在于哈希表， 并且 HSET 命令成功使用新值覆盖了它的旧值， 那么命令返回 0 。

示例：
redis> hset user id 001
(integer) 1
redis> hget user id
"001"

• HGET hash field

作用：返回哈希表中给定域的值。

返回值：
HGET 命令在默认情况下返回给定域的值。
如果给定域不存在于哈希表中， 又或者给定的哈希表并不存在， 那么命令返回 nil 。

示例：
redis> hget user id
"001"

• HSETNX hash field value

作用：当且仅当域 field 尚未存在于哈希表的情况下， 将它的值设置为 value 。
如果给定域已经存在于哈希表当中， 那么命令将放弃执行设置操作。
如果哈希表 hash 不存在， 那么一个新的哈希表将被创建并执行 HSETNX 命令。

返回值：
HSETNX 命令在设置成功时返回 1 ， 在给定域已经存在而放弃执行设置操作时返回 0 。

示例：
#未存在时设置成功
redis> HSETNX database name Redis
(integer) 0
redis> HGET database name
"Redis"

#已存在时值不变
redis> HSETNX database name Riak
(integer) 0
redis> HGET database name
"Redis"

• HMSET key field value [field value …] / HMGET key field [field …]

作用：同时将多个 field-value (域-值)对设置到哈希表 key 中。
此命令会覆盖哈希表中已存在的域。
如果 key 不存在，一个空哈希表被创建并执行 HMSET 操作。

返回值：
如果命令执行成功，返回 OK 。
当 key 不是哈希表(hash)类型时，返回一个错误。

示例：
redis> hmset customer id 01 name zhangsan sex male
OK
redis> hmget customer id name sex
1) "01"
2) "zhangsan"
3) "male"

• HGETALL key

作用：返回哈希表 key 中，所有的域和值。
在返回值里，紧跟每个域名(field name)之后是域的值(value)，所以返回值的长度是哈希表大小的两倍。

返回值：以列表形式返回哈希表的域和域的值。
若 key 不存在，返回空列表。

示例：
redis> hgetall customer
1) "id"
2) "01"
3) "name"
4) "zhangsan"
5) "sex"
6) "male"

• HLEN key

作用：返回哈希表 key 中域的数量。

返回值：哈希表中域的数量。
当 key 不存在时，返回 0 。

示例：
redis> hgetall customer
1) "id"
2) "01"
3) "name"
4) "zhangsan"
5) "sex"
6) "male"
redis> hlen customer
(integer) 3

• HEXISTS hash field

作用：检查给定域 field 是否存在于哈希表 hash 当中。

返回值：
HEXISTS 命令在给定域存在时返回 1 ， 在给定域不存在时返回 0 。

示例：
redis> HEXISTS customer name
(integer) 1

• HKEYS key

作用：返回哈希表 key 中的所有域。

返回值：一个包含哈希表中所有域的表。
当 key 不存在时，返回一个空表。

示例：
redis> hkeys customer
1) "id"
2) "name"
3) "sex"

• HVALS key

作用：返回哈希表 key 中所有域的值。

返回值：
一个包含哈希表中所有值的表。
当 key 不存在时，返回一个空表。

示例：
redis> hvals customer
1) "01"
2) "zhangsan"
3) "male"

• HINCRBY key field increment

作用：为哈希表 key 中的域 field 的值加上增量 increment 。增量也可以为负数，相当于对给定域进行减法操作。如果 key 不存在，一个新的哈希表被创建并执行 HINCRBY 命令。对字符串进行HINCRBY 会报错。

返回值：执行 HINCRBY 命令之后，哈希表 key 中域 field 的值。

示例：
redis> hgetall customer
1) "id"
2) "01"
3) "name"
4) "zhangsan"
5) "sex"
6) "male"
7) "age"
8) "19"
redis> hincrby customer age 1
(integer) 20

• HINCRBYFLOAT key field increment

作用：为哈希表 key 中的域 field 加上浮点数增量 increment 。
如果哈希表中没有域 field ，那么 HINCRBYFLOAT 会先将域 field 的值设为 0 ，然后再执行加法操作。如果键 key 不存在，那么 HINCRBYFLOAT 会先创建一个哈希表，再创建域 field ，最后再执行加法操作。

返回值：执行加法操作之后 field 域的值。

示例：
redis> HINCRBYFLOAT customer age 0.5
"20.5"

3.5 Zset有序集合(sorted set)

redis zset和色图一样也是String类型的元素集合，且不允许重复。

不同的是每个元素都会关联一个double类型的分数。

redis正是通过分数来为集合中的成员进行从小到大的排序。zset的成员是唯一的，但是分数（score）却可以重复

• ZADD key score member [[score member] [score member] …]

作用：将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。
score 值可以是整数值或双精度浮点数。

返回值：
被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员。

示例：
redis> zadd page_rank 20 baidu.com 30 google.com 40 tencent.com
(integer) 3

• ZRANGE key start stop [WITHSCORES]

作用：返回有序集 key 中，指定区间内的成员。
其中成员的位置按 score 值递增(从小到大)来排序。
具有相同 score 值的成员按字典序(lexicographical order )来排列。
下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。 你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。

返回值：指定区间内，带有 score 值(可选)的有序集成员的列表。

示例：
redis> zrange page_rank 0 -1
1) "baidu.com"
2) "google.com"
3) "tencent.com"

redis> zrange page_rank 0 -1 withscores
1) "baidu.com"
2) "20"
3) "google.com"
4) "30"
5) "tencent.com"
6) "40"

• ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]

作用：返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列
> LIMIT 参数指定返回结果的数量及区间(就像SQL中的 SELECT LIMIT offset, count )
> WITHSCORES 参数决定结果集是单单返回有序集的成员，还是将有序集成员及其 score 值一起返回。

区间及无限：
min 和 max 可以是 -inf 和 +inf ，这样一来，你就可以在不知道有序集的最低和最高 score 值的情况下，使用 ZRANGEBYSCORE 这类命令。
默认情况下，区间的取值使用闭区间 (小于等于或大于等于)，你也可以通过给参数前增加 ( 符号来使用可选的开区间 (小于或大于)，如：ZRANGEBYSCORE zset (1 5

返回值:指定区间内，带有 score 值(可选)的有序集成员的列表。

示例：
#显示<=30的网站域名
redis> zrangebyscore page_rank -inf 30 withscores
1) "baidu.com"
2) "20"
3) "google.com"
4) "30"

#显示整个有序集
redis> zrangebyscore page_rank -inf +inf
1) "baidu.com"
2) "google.com"
3) "tencent.com"

#查询>20 <=40的网站域名
27.0.0.1:6379> zrangebyscore page_rank (20 40 withscores
1) "google.com"
2) "30"
3) "tencent.com"
4) "40"

• ZREM key member [member …]

作用：移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。
当 key 存在但不是有序集类型时，返回一个错误。

返回值：被成功移除的成员的数量，不包括被忽略的成员。

示例：
#移除单个元素
redis> zrem page_rank baidu.com
(integer) 1

#移除多个元素
redis> ZREM page_rank baidu.com bing.com
(integer) 2

• ZCARD key

作用：返回有序集 key 的基数。

返回值：
当 key 存在且是有序集类型时，返回有序集的基数。 当 key 不存在时，返回 0 

示例：
redis> zcard page_rank
(integer) 2

• ZCOUNT key min max

作用：返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。

返回值
score 值在 min 和 max 之间的成员的数量。

示例：
redis> zadd zset01 10 hello 20 world 30 im 40 jack 50 haha
(integer) 5
redis> zcount zset01 10 30
(integer) 3

• ZRANK key member

作用：返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。
排名以 0 为底，也就是说， score 值最小的成员排名为 0 。

返回值：
如果 member 是有序集 key 的成员，返回 member 的排名。 如果 member 不是有序集 key 的成员，返回 nil 。

示例：
redis> zrange zset01 0 -1
1) "hello"
2) "world"
3) "im"
4) "jack"
5) "haha"
redis> zrank zset01 jack #下标从0开始
(integer) 3

• ZSCORE key member （递增排列）

作用：返回有序集 key 中，成员 member 的 score 值。
如果 member 元素不是有序集 key 的成员，或 key 不存在，返回 nil 。

返回值：
member 成员的 score 值，以字符串形式表示。

示例：
redis> zrange zset01 0 -1 withscores
 1) "hello"
 2) "10"
 3) "world"
 4) "20"
 5) "im"
 6) "30"
 7) "jack"
 8) "40"
 9) "haha"
10) "50"
redis> zscore zset01 im
"30"

• ZREVRANGE key start stop [WITHSCORES] （递减排列）

作用：返回有序集 key 中，指定区间内的成员。
其中成员的位置按 score 值递减(从大到小)来排列。 具有相同 score 值的成员按字典序的逆序排列。（reverse lexicographical order）

返回值：
指定区间内，带有 score 值(可选)的有序集成员的列表。

示例：
redis> zrevrange zset01 0 -1 withscores
 1) "haha"
 2) "50"
 3) "jack"
 4) "40"
 5) "im"
 6) "30"
 7) "world"
 8) "20"
 9) "hello"
10) "10"

• ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]

作用：返回有序集 key 中， score 值介于 max 和 min 之间(默认包括等于 max 或 min )的所有的成员。有序集成员按 score 值递减(从大到小)的次序排列。
具有相同 score 值的成员按字典序的逆序(reverse lexicographical order )排列。

返回值：
指定区间内，带有 score 值(可选)的有序集成员的列表。

示例：
redis> ZREVRANGEBYSCORE zset01 50 20 withscores
1) "haha"
2) "50"
3) "jack"
4) "40"
5) "im"
6) "30"
7) "world"
8) "20"