数据类型

1. String 字符串
   二进制安全的。意思是redis的string可以包含任何数据。比如jpg图片或者序列化的对象 。
2. Hash 哈希
   string 类型的 field 和 value 的映射表，hash 特别适合用于存储对象。
3. List 列表
   简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）。
4. Set 集合
   string类型的无序集合。
   集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。
5. Sorted Set 有序集合
   和 set 一样也是string类型元素的集合,且不允许重复的成员。
   不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。
   zset的成员是唯一的,但分数(score)却可以重复。

String 字符串

SET key value / GET key

设置/获取指定 key 的值

redis 127.0.0.1:6379> SET name "hongxi"
OK
redis 127.0.0.1:6379> GET name
"hongxi"

GETRANGE key start end

获取存储在指定 key 中字符串的子字符串，字符串的截取范围由 start 和 end 两个偏移量决定(包括 start 和 end 在内)。

redis 127.0.0.1:6379> SET title "hello world"
OK
redis 127.0.0.1:6379> GETRANGE title 0 3
"hell"
redis 127.0.0.1:6379> GETRANGE mykey 0 -1
"hello world"
127.0.0.1:6379> getrange title 0 -3
"hello wor"

GETSET key value

设置指定 key 的值，并返回 key 的旧值。

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

redis> GET db
"mongodb"

redis> GETSET db redis      # 返回旧值 mongodb
"mongodb"

redis> GET db
"redis"

MSET key1 value1 key2 value2 .. keyN valueN

同时设置一个或多个 key-value 对

redis 127.0.0.1:6379> MSET key1 "Hello" key2 "World"
OK

MSETNX key1 value1 key2 value2 .. keyN valueN

原子性操作,用于所有给定 key 都不存在时，同时设置一个或多个 key-value 对。

MGET key1 key2 .. keyn

*返回所有(一个或多个)给定 key 的值。 如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 nil *

SETEX key timeout value

为指定的 key 设置值及其过期时间。如果 key 已经存在， SETEX 命令将会替换旧的值。（单位为秒）

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

PSETEX key1 EXPIRY_IN_MILLISECONDS value1

以毫秒为单位设置 key 的生存时间。

SETNX key value

（SET if Not eXists） 命令在指定的 key 不存在时，为 key 设置指定的值。

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

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

redis> SETNX job "code-farmer"   # 尝试覆盖 job ，失败
(integer) 0

redis> GET job                   # 没有被覆盖
"programmer"

SETRANGE key offset value

用指定的字符串覆盖给定 key 所储存的字符串值，覆盖的位置从偏移量 offset 开始。

redis 127.0.0.1:6379> SET key1 "Hello World"
OK
redis 127.0.0.1:6379> SETRANGE key1 6 "Redis"
(integer) 11
redis 127.0.0.1:6379> GET key1
"Hello Redis"

APPEND key value

为指定的 key 追加值。
如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。
如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。

# 对不存在的 key 执行 APPEND

redis> EXISTS myphone               # 确保 myphone 不存在
(integer) 0

redis> APPEND myphone "nokia"       # 对不存在的 key 进行 APPEND ，等同于 SET myphone "nokia"
(integer) 5                         # 字符长度


# 对已存在的字符串进行 APPEND

redis> APPEND myphone " - 1110"     # 长度从 5 个字符增加到 12 个字符
(integer) 12

redis> GET myphone
"nokia - 1110"

STRLEN key

用于获取指定 key 所储存的字符串值的长度。当 key 不存在时，返回 0。当 key 储存的不是字符串值时，返回一个错误。

INCR key & DECR key

将 key 中储存的数字值增/减一。如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR/DECR 操作。也就是变成1/-1

127.0.0.1:6379> INCR count
(integer) 1
127.0.0.1:6379> GET count
"1"
127.0.0.1:6379>

INCRBY key incr_amount & DECRBY key decr_amount

将 key 中储存的数字加上/减掉指定的增量值。

redis> SET rank 50
OK

redis> INCRBY rank 20
(integer) 70

redis> GET rank
"70"

INCRBYFLOAT key incr_amount

为 key 中所储存的值加上指定的浮点数增量值。

# 值和增量都不是指数符号

redis> SET mykey 10.50
OK

redis> INCRBYFLOAT mykey 0.1
"10.6"


# 值和增量都是指数符号

redis> SET mykey 314e-2
OK

redis> GET mykey                # 用 SET 设置的值可以是指数符号
"314e-2"

redis> INCRBYFLOAT mykey 0      # 但执行 INCRBYFLOAT 之后格式会被改成非指数符号
"3.14"


# 可以对整数类型执行

redis> SET mykey 3
OK

redis> INCRBYFLOAT mykey 1.1
"4.1"


# 后跟的 0 会被移除

redis> SET mykey 3.0
OK

redis> GET mykey                                    # SET 设置的值小数部分可以是 0
"3.0"

redis> INCRBYFLOAT mykey 1.000000000000000000000    # 但 INCRBYFLOAT 会将无用的 0 忽略掉，有需要的话，将浮点变为整数
"4"

redis> GET mykey
"4"

2.Hash 哈希

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

HSET key filed value

HMSET key field1 value1 ...filedN valueN

HGET key filed

HKEYS key & HVALS key

获取所有哈希表中的字段/值

HGETALL key

获取在哈希表中指定 key 的所有字段和值

HLEN key

获取哈希表中字段的数量

HEXISTS KEY_NAME FIELD_NAME

查看哈希表 key 中，指定的字段是否存在。

HDEL key filed1.. filedN

删除一个或多个哈希表字段

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"
redis 127.0.0.1:6379> HEXISTS myhash field1
(integer) 1
redis 127.0.0.1:6379> HEXISTS myhash field3
(integer) 0

HINCRBY key filed incr_by_num

如果哈希表的 key 不存在，一个新的哈希表被创建并执行 HINCRBY 命令。
如果指定的字段不存在，那么在执行命令前，字段的值被初始化为 0 。

INCRBYFLOAT key incr_amount

同上, 为 key 中所储存的值加上指定的浮点数增量值。

redis> HSET myhash field 5
(integer) 1
redis> HINCRBY myhash field 1
(integer) 6
redis> HINCRBY myhash field -1
(integer) 5

127.0.0.1:6379> HSET mykey a 10.50
(integer) 1
127.0.0.1:6379> HINCRBYFLOAT mykey a 0.1
"10.6"

HSETNX key field value

只有在字段 field 不存在时，设置哈希表字段的值。

redis 127.0.0.1:6379> HSETNX myhash field1 "foo"
(integer) 1
redis 127.0.0.1:6379> HSETNX myhash field1 "bar"
(integer) 0
redis 127.0.0.1:6379> HGET myhash field1
"foo"

3.List 列表

LPUSH key value1 [value2] & RPUSH key value1 [value2]

将一个或多个值插入到列表头部

127.0.0.1:6379> LPUSH nameList xiaoming xiaohong
(integer) 2

LPUSHX key value1.. valueN & RPUSHX key value1 [value2]

将一个值插入到已存在的列表头部，列表不存在时操作无效。

127.0.0.1:6379> LPUSHX nameList222 xiaofei
(integer) 0

LPOP key && RPOP key

移出并获取列表的第一个元素/移除并获取列表最后一个元素

127.0.0.1:6379> LPUSH mylist a b c d e
(integer) 5
127.0.0.1:6379> LPOP mylist
"e"
127.0.0.1:6379> RPOP mylist
"a"
127.0.0.1:6379> LPOP mylist
"d"

RPOPLPUSH sourceList destinationList

用于移除列表的最后一个元素，并将该元素添加到另一个列表并返回。

BLPOP/BRPOP key1 [key2 ] timeout

移出并获取列表的第一个/最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。

LINDEX key index

用于通过索引获取列表中的元素。你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素

127.0.0.1:6379> LINDEX mylist 1
"b"

LINSERT key BEFORE|AFTER pivot value

用于在列表的元素前或者后插入元素。当指定元素不存在于列表中时，不执行任何操作。

127.0.0.1:6379> LPUSH mylist a b c d e f g
(integer) 7
127.0.0.1:6379> LINSERT mylist BEFORE "b" "666"
(integer) 8
127.0.0.1:6379> LRANGE mylist 0 -1
1) "g"
2) "f"
3) "e"
4) "d"
5) "c"
6) "666"
7) "b"
8) "a"

4.Set 集合

Set 是 String 类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。
Redis 中集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是 O(1)。

1. SADD key value1..valueN
   将一个或多个成员元素加入到集合中，已经存在于集合的成员元素将被忽略。

127.0.0.1:6379> SADD myset "hello"
(integer) 1

2. SCARD key
   返回集合中元素的数量。

127.0.0.1:6379> SADD myset "world"
(integer) 1
127.0.0.1:6379> SCARD myset
(integer) 2

3. SDIFF firstKey otherKey1..otherKeyN
   返回给定集合之间的差集。不存在的集合 key 将视为空集。差集的结果来自前面的 FIRST_KEY ,而不是后面的 OTHER_KEY1，也不是整个 FIRST_KEY OTHER_KEY1..OTHER_KEYN 的差集。

key1 = {a,b,c,d}
key2 = {c}
key3 = {a,c,e}
SDIFF key1 key2 key3 = {b,d}

4. SDIFFSTORE destination key1..keyN
   将给定集合之间的差集存储在指定的集合中。如果指定的集合 key 已存在，则会被覆盖。

myset = {"hello", "foo", "bar"}
myset2 = {"hello", "world"}

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

5.SINTER KEY KEY1..KEYN
返回给定所有给定集合的交集。 不存在的集合 key 被视为空集。 当给定集合当中有一个空集时，结果也为空集。

key1 = {a,b,c}
key2 = {a,c}
SINTER key1 key2 = {a, c}

6. SINTERSTORE destination key key1..keyN
   将给定集合之间的交集存储在指定的集合中。如果指定的集合已经存在，则将其覆盖。

127.0.0.1:6379> SINTERSTORE myset myset1 myset2
(integer) 1
127.0.0.1:6379> SMEMBERS myset
1) "hello"

7. SISMEMBER key value
   判断成员元素是否是集合的成员。

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

8. SMEMBERS key
   返回集合中的所有的成员。 不存在的集合 key 被视为空集合。

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

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

myset1 = {"hello", "world", "bar"}
myset2 = {"foo"}

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

10. SPOP key
    移除并返回集合中的一个随机元素
11. SRANDMEMBER KEY [count]
    如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。
    如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。
    该操作和 SPOP 相似，但 SPOP 将随机元素从集合中移除并返回，而 Srandmember 则仅仅返回随机元素，而不对集合进行任何改动。

myset = {a b c d e f}

127.0.0.1:6379> SRANDMEMBER myset 3
1) "b"
2) "e"
3) "a"
127.0.0.1:6379> SRANDMEMBER myset 3
1) "c"
2) "b"
3) "e"
127.0.0.1:6379> SRANDMEMBER myset 10
1) "a"
2) "b"
3) "d"
4) "c"
5) "e"
6) "f"
127.0.0.1:6379> SRANDMEMBER myset -4
1) "c"
2) "c"
3) "d"
4) "a"

12. SREM key member1..memberN
    用于移除集合中的一个或多个成员元素，不存在的成员元素会被忽略。

13. SUNION key key1..keyN
    返回给定集合的并集。不存在的集合 key 被视为空集。

14. SUNIONSTORE destination key key1..keyN
    将给定集合的并集存储在指定的集合 destination 中。如果 destination 已经存在，则将其覆盖。

15. SSCAN key cursor [MATCH pattern] [COUNT count]
    用于迭代集合中键的元素。

127.0.0.1:6379> SADD myset1 hello
(integer) 1
127.0.0.1:6379> SADD myset1 hi
(integer) 1
127.0.0.1:6379> SADD myset1 bar
(integer) 1
127.0.0.1:6379> SSCAN myset1 0 match h*
1) "0"
2) 1) "hello"
   2) "hi"
127.0.0.1:6379> SSCAN myset1 0
1) "0"
2) 1) "hello"
   2) "bar"
   3) "hi"

5.Sorted Set 有序集合

1.ZADD key score1 value1.. scoren valueN
将一个或多个成员元素及其分数值加入到有序集当中。
如果某个成员已经是有序集的成员，那么更新这个成员的分数值，并通过重新插入这个成员元素，来保证该成员在正确的位置上。
分数值可以是整数值或双精度浮点数。
如果有序集合 key 不存在，则创建一个空的有序集并执行 ZADD 操作。

127.0.0.1:6379> ZADD myzset 2 "two" 3 "three"
(integer) 2
127.0.0.1:6379> ZADD myzset 1 "one"
(integer) 1
127.0.0.1:6379> ZRANGE myzset 0 -1 WITHSCORES
1) "one"
2) "1"
3) "two"
4) "2"
5) "three"
6) "3"

2.ZCARD key
计算集合中元素的数量。

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

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
   可以通过传递一个负数值 increment ，让分数减去相应的值，比如 ZINCRBY key -5 member ，就是让 member 的 score 值减去 5 。
   当 key 不存在，或member不是 key 的成员时， ZINCRBY key increment member 等同于 ZADD key increment member 。

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"

5. ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]
   计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，并将该交集(结果集)储存到 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"

如果需要计算平均值则计算SUM后除以numkeys。

6. ZLEXCOUNT key min max
   计算有序集合中指定字典区间内成员数量。即[a (b 之类的

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 / 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"

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"

9. ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]
   指定区间内，带有分数值(可选)的有序集成员的列表。
   ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]
   返回有序集中指定分数区间内的所有的成员。有序集成员按分数值递减(从大到小)的次序排列。

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
    返回有序集中指定成员的排名。其中有序集成员按分数值递增(从小到大)顺序排列。
    ZREVRANK 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 ...]
    用于移除有序集中的一个或多个成员，不存在的成员将被忽略。
    ZREMRANGEBYLEX key min max
    移除有序集合中给定的字典区间的所有成员。

12. ZSCORE key member
    返回有序集中，成员的分数值。 如果成员元素不是有序集 key 的成员，或 key 不存在，返回 nil 。

13. ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]
    计算给定的一个或多个有序集的并集，其中给定 key 的数量必须以 numkeys 参数指定，并将该并集(结果集)储存到 destination 。

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