https://github.com/antirez/redis
安装很简单的。

https://redisdoc.com/

key

EXISTS key

检查给定key是否存在，存在返回1，否则返回0

KEYS pattern

pattern是正则匹配模式。
查找所有符合给定模式pattern的key。
KEYS *匹配数据库中所有key 。
KEYS h?llo 匹配hello ， hallo和 hxllo 等。
KEYS h*llo 匹配 hllo和heeeeello等。
KEYS h[ae]llo匹配 hello和hallo，但不匹配hillo 。

MOVE key db

将当前数据库的key移动到给定的数据库db当中。如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定 key，或者key不存在于当前数据库，那么MOVE没有任何效果。因此，可以利用这一特性，将MOVE当作锁(locking)原语(primitive)。移动成功返回1，失败则返回0。

# key 存在于当前数据库
redis> SELECT 0      # redis默认使用数据库 0，为了清晰起见，这里再显式指定一次。
OK
redis> SET song "secret base - Zone"
OK
redis> MOVE song 1                          # 将 song 移动到数据库 1
(integer) 1
redis> EXISTS song                          # song 已经被移走
(integer) 0
redis> SELECT 1                             # 使用数据库 1
OK
redis:1> EXISTS song                        # 证实 song 被移到了数据库 1 (注意命令提示符变成了"redis:1"，表明正在使用数据库 1)
(integer) 1
# 当 key 不存在的时候
redis:1> EXISTS fake_key
(integer) 0
redis:1> MOVE fake_key 0                    # 试图从数据库 1 移动一个不存在的 key 到数据库 0，失败
(integer) 0
redis:1> select 0                           # 使用数据库0
OK
redis> EXISTS fake_key                      # 证实 fake_key 不存在
(integer) 0
# 当源数据库和目标数据库有相同的 key 时
redis> SELECT 0                             # 使用数据库0
OK
redis> SET favorite_fruit "banana"
OK
redis> SELECT 1                             # 使用数据库1
OK
redis:1> SET favorite_fruit "apple"
OK
redis:1> SELECT 0                           # 使用数据库0，并试图将 favorite_fruit 移动到数据库 1
OK
redis> MOVE favorite_fruit 1                # 因为两个数据库有相同的 key，MOVE 失败
(integer) 0
redis> GET favorite_fruit                   # 数据库 0 的 favorite_fruit 没变
"banana"
redis> SELECT 1
OK
redis:1> GET favorite_fruit                 # 数据库 1 的 favorite_fruit 也是
"apple"

EXPIRE key seconds、PERSIST key、TTL key

EXPIRE为给定key设置/更新生存时间，当key过期时(生存时间为0)，它会被自动删除。

redis> SET cache_page "www.google.com"
OK
redis> EXPIRE cache_page 30  # 设置过期时间为 30 秒
(integer) 1
redis> TTL cache_page    # 查看剩余生存时间
(integer) 23
redis> EXPIRE cache_page 30000   # 更新过期时间
(integer) 1
redis> TTL cache_page
(integer) 29996

PERSIST移除给定key的生存时间，使得key永久有效。
TTL查看给定key的生存时间。

DEL key [key …]

删除给定的一个或多个key。不存在的key会被忽略，返回被删除key的数量。

# 删除单个 key
redis> SET name huangz
OK
redis> DEL name
(integer) 1
# 删除一个不存在的 key
redis> EXISTS phone
(integer) 0
redis> DEL phone # 失败，没有 key 被删除
(integer) 0
# 同时删除多个 key
redis> SET name "redis"
OK
redis> SET type "key-value store"
OK
redis> SET website "redis.com"
OK
redis> DEL name type website
(integer) 3

TYPE key

返回key所储存的值的类型。返回值为none (key不存在)、string (字符串)、list (列表)、set (集合)、zset (有序集)、hash (哈希表)。

String字符串

String（字符串），string是redis最基本的类型，你可以理解成与Memcached一模一样的类型，一个key对应一个value，string类型是二进制安全的。意思是redis的string可以包含任何数据。比如jpg图片或者序列化的对象，string类型是Redis最基本的数据类型，一个redis中字符串value最多可以是512M。是一个key单Value。

set、get、del、append、strlen、mset、mget、msetnx

1、SET key value [EX seconds] [PX milliseconds] [NX|XX]

将字符串值value关联到key。如果key已经持有其他值，SET就全部覆写旧值包括属性（过期时间等），
EX过期时间为second秒。PX设置键的过期时间为millisecond毫秒。
NX ：只在键不存在时，才对键进行设置操作。
XX ：只在键已经存在时，才对键进行设置操作。

2、GET key
返回key所关联的字符串值。如果key不存在那么返回特殊值nil。假如key储存的值不是字符串类型，返回一个错误，因为GET只能用于处理字符串值。

3、APPEND key value
如果key已经存在并且是一个字符串， APPEND命令将value追加到key原来的值的末尾。如果key不存在，APPEND就简单地将给定key设为value，就像执行SET key value一样。
4、strlen
返回key所储存的字符串值的长度。当key储存的不是字符串值时，返回一个错误。

5、MSET key value [key value …]
同时设置一个或多个key-value对。
如果某个给定key已经存在，那么MSET会用新值覆盖原来的旧值，如果这不是你所希望的效果，请考虑使用MSETNX命令：它只会在所有给定key都不存在的情况下进行设置操作。
MSET是一个原子性(atomic)操作，所有给定key都会在同一时间内被设置，某些给定 key被更新而另一些给定key没有改变的情况，不可能发生。

redis> MSET date "2012.3.30" time "11:00 a.m." weather "sunny"
OK
redis> MGET date time weather
1) "2012.3.30"
2) "11:00 a.m."
3) "sunny"
# MSET 覆盖旧值例子
redis> SET google "google.hk"
OK
redis> MSET google "google.com"
OK
redis> GET google
"google.com"

6、MGET key [key …]
返回所有(一个或多个)给定key的值。如果给定的key里面，有某个key不存在，那么这个key返回特殊值nil 。因此，该命令永不失败。

redis> SET redis redis.com
OK
redis> SET mongodb mongodb.org
OK
redis> MGET redis mongodb
1) "redis.com"
2) "mongodb.org"
redis> MGET redis mongodb mysql     #不存在的 mysql 返回 nil
1) "redis.com"
2) "mongodb.org"
3) (nil)

setrange、getrange

1、SETRANGE key offset value
用value参数覆写(overwrite)给定key所储存的字符串值，从偏移量offset开始。不存在的key当作空白字符串处理。该命令会确保字符串足够长以便将value设置在指定的偏移量上，如果给定key原来储存的字符串长度比偏移量小(比如字符串只有5个字符长，但你设置的offset是10)，那么原字符和偏移量之间的空白将用零字节(zerobytes, “\x00” )来填充。
注意你能使用的最大偏移量是 2^29-1(536870911) ，因为Redis字符串的大小被限制在512兆(megabytes)以内。如果你需要使用比这更大的空间，你可以使用多个key。

# 对非空字符串进行 SETRANGE
redis> SET greeting "hello world"
OK
redis> SETRANGE greeting 6 "Redis"
(integer) 11
redis> GET greeting
"hello Redis"
# 对空字符串/不存在的 key 进行 SETRANGE
redis> EXISTS empty_string
(integer) 0
redis> SETRANGE empty_string 5 "Redis!"   # 对不存在的 key 使用 SETRANGE
(integer) 11
redis> GET empty_string                   # 空白处被"\x00"填充
"\x00\x00\x00\x00\x00Redis!"

2、GETRANGE key start end
返回key中字符串值的子字符串，字符串的截取范围由start和end两个偏移量决定(包括start和end在内)。负数偏移量表示从字符串最后开始计数， -1表示最后一个字符， -2表示倒数第二个，以此类推。
GETRANGE通过保证子字符串的值域(range)不超过实际字符串的值域来处理超出范围的值域请求。

redis> SET greeting "hello, my friend"
OK
redis> GETRANGE greeting 0 4          # 返回索引0-4的字符，包括4。
"hello"
redis> GETRANGE greeting -1 -5        # 不支持回绕操作
""
redis> GETRANGE greeting -3 -1        # 负数索引
"end"
redis> GETRANGE greeting 0 -1         # 从第一个到最后一个
"hello, my friend"
redis> GETRANGE greeting 0 1008611    # 值域范围不超过实际字符串，超过部分自动被符略
"hello, my friend"

incr、decr、incr by、decr by

redis的递增必定是原子了，因为内部操作键值的时候，必须会加锁处理。因此，这种操作比在本地简单多了，本地还需要同步处理，这里redis内部已经帮助我们同步了很简单。
1、可以使用自增记录文章访问量统计，很简单，来了，直接往redis数据库里面自增即可，快速又简单。键的命名可以使用对象：对象类型：对象属性命令。
2、可以为每篇文章自动生成ID。每个对象使用名为count的键来存储文章数目。增加对象则自增1即可。比传统的关系型数据库涉及简单多了。
3、存储文章数据，将文章序列化成字符串，然后存储到redis之中。

list（列表）

列表内部使用双向链表实现，因此头部和尾部插入是O(1)。一个列表最多容纳2^32-1个元素。列表比较适合用来做记录日志，例如新鲜事几千万，最新的也就100条数据。直接从头部返回即可。以下指令全部是对链表进行操作的方法。

lpush lpushx rpush rpushx lrange

1、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 存在但不是列表类型时，返回一个错误。
LPUSHX(exist) key value：将值value插入到列表key的表头，当且仅当key存在并且是一个列表。和LPUSH命令相反，当key不存在时，LPUSHX命令什么也不做。

# 加入单个元素
redis> LPUSH languages python
(integer) 1
# 加入重复元素
redis> LPUSH languages python
(integer) 2
redis> LRANGE languages 0 -1     # 列表允许重复元素
1) "python"
2) "python"
# 加入多个元素
redis> LPUSH mylist a b c
(integer) 3
redis> LRANGE mylist 0 -1
1) "c"
2) "b"
3) "a"

2、LPUSH 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命令相反，当key不存在时， RPUSHX命令什么也不做。

3、LRANGE key start stop
返回列表key中指定区间内的元素，区间以偏移量start和stop指定。
下标(index)参数start和stop都以0为底，也就是说，以0表示列表的第一个元素，以1 表示列表的第二个元素，以此类推。你也可以使用负数下标，以-1表示列表的最后一个元素，-2表示列表的倒数第二个元素，以此类推。

redis> RPUSH fp-language lisp
(integer) 1
redis> LRANGE fp-language 0 0
1) "lisp"
redis> RPUSH fp-language scheme
(integer) 2
redis> LRANGE fp-language 0 1
1) "lisp"
2) "scheme"

lpop、rpop

1、LPOP key
移除并返回列表key的头元素。
2、RPOP key
移除并返回列表key的尾元素。

直接可以使用这几个push和pop命令，当做栈和队列使用。并且这个队列是天然不需要加锁的，非常容易使用。根本不同考虑竞争问题。

lindex llen lrem ltrim

1、LLEN key
返回key列表中元素的数目。
llen类似于SQL中的select count(*) from tablename;，但是llen时间复杂度是O(1)，redis会直接读取现成的值。不会和InnoDB一样遍历表。

2、LREM key count value
根据参数count的值，移除列表中与参数value相等的元素。
count 的值可以是以下几种：

• count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count
• count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。
• count = 0 : 移除表中所有与 value 相等的值。

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

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

rpoplpush lset linsert

1、RPOPLPUSH source destination

命令RPOPLPUSH在一个原子时间内，执行以下两个动作：
将列表source中的最后一个元素(尾元素)弹出，并返回给客户端。
将source弹出的元素插入到列表destination，作为destination列表的的头元素。

2、LSET key index value
将列表key下标为index的元素的值设置为value。

3、LINSERT key BEFORE|AFTER pivot value

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

实践

1、存储文章ID列表，可以通过LRANGE显示每页的文章。
2、存储每篇文章的评论列表，将一条评论元素序列化后通过列表存储。

Set（集合）

Redis的Set是String类型的无序集合，里面不允许有重复元素，是键值中值为空的hashtable。它是通过HashTable实现的，于是对于集合之间的并集、交集、差集都很快。于是这个用户就很明显了。

sadd smembers sismember

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

#添加单个元素
redis> SADD bbs "discuz.net"
(integer) 1
#添加重复元素
redis> SADD bbs "discuz.net"
(integer) 0
#添加多个元素
redis> SADD bbs "tianya.cn" "groups.google.com"
(integer) 2
redis> SMEMBERS bbs
1) "discuz.net"
2) "groups.google.com"
3) "tianya.cn"

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

3、SISMEMBER key member
判断member元素是否集合key的成员
如果member元素是集合的成员，返回1，如果member元素不是集合的成员，或key不存在，返回 0 。

scard srem

1、SCARD key
返回集合key的基数(集合中元素的数量)。

2、SREM key member [member ...]
移除集合key中的一个或多个member元素，不存在的member元素会被忽略。

#测试数据
redis> SMEMBERS languages
1) "c"
2) "lisp"
3) "python"
4) "ruby"
#移除单个元素
redis> SREM languages ruby
(integer) 1
#移除不存在元素
redis> SREM languages non-exists-language
(integer) 0
# 移除多个元素
redis> SREM languages lisp python c
(integer) 3
redis> SMEMBERS languages
(empty list or set)

srandmember spop smove

1、SRANDMEMBER key [count]
如果命令执行时，只提供了key参数，那么返回集合中的一个随机元素。
从Redis 2.6版本开始，SRANDMEMBER命令接受可选的count参数：

• 如果count为正数，且小于集合基数，那么命令返回一个包含count个元素的数组，数组中的元素各不相同。如果count大于等于集合基数，那么返回整个集合。

• 如果count为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为count的绝对值。
  该操作和SPOP相似，但SPOP将随机元素从集合中移除并返回，而SRANDMEMBER则仅仅返回随机元素，而不对集合进行任何改动。

  添加元素

  redis> SADD fruit apple banana cherry
  (integer) 3

  只给定 key 参数，返回一个随机元素

  redis> SRANDMEMBER fruit
  “cherry”

  redis> SRANDMEMBER fruit
  “apple”

  给定 3 为 count 参数，返回 3 个随机元素

  每个随机元素都不相同

  redis> SRANDMEMBER fruit 3
  1) “apple”
  2) “banana”
  3) “cherry”

  给定 -3 为 count 参数，返回 3 个随机元素

  元素可能会重复出现多次

  redis> SRANDMEMBER fruit -3
  1) “banana”
  2) “cherry”
  3) “apple”

  redis> SRANDMEMBER fruit -3
  1) “apple”
  2) “apple”
  3) “cherry”

  如果 count 是整数，且大于等于集合基数，那么返回整个集合

  redis> SRANDMEMBER fruit 10
  1) “apple”
  2) “banana”
  3) “cherry”

  如果 count 是负数，且 count 的绝对值大于集合的基数

  那么返回的数组的长度为 count 的绝对值

  redis> SRANDMEMBER fruit -10
  1) “banana”
  2) “apple”
  3) “banana”
  4) “cherry”
  5) “apple”
  6) “apple”
  7) “cherry”
  8) “apple”
  9) “apple”
  10) “banana”

  SRANDMEMBER 并不会修改集合内容

  redis> SMEMBERS fruit
  1) “apple”
  2) “cherry”
  3) “banana”

  集合为空时返回 nil 或者空数组

  redis> SRANDMEMBER not-exists
  (nil)

  redis> SRANDMEMBER not-eixsts 10
  (empty list or set)

2、SPOP key
移除并返回集合中的一个随机元素。如果只想获取一个随机元素，但不想该元素从集合中被移除的话，可以使用SRANDMEMBER命令。

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

sdiff sinter sunion

1、SDIFF key [key ...]
返回所有给定集合之间的差集。不存在的key被视为空集。
A并B=属于A或属于B。
A交B=属于A且属于B。
A差B=属于A不属于B。

redis> SMEMBERS peter's_movies 1) "bet man" 2) "start war" 3) "2012" redis> SMEMBERS joe's_movies
1) "hi, lady"
2) "Fast Five"
3) "2012"
redis> SDIFF peter's_movies joe's_movies
1) "bet man"
2) "start war"

2、SUNION key [key ...]
返回一个集合的全部成员，该集合是所有给定集合的并集。

3、SINTER key [key ...]
返回一个集合的全部成员，该集合是所有给定集合的交集。

实践

1、文章的标签，都是不同的并且对排序并没有要求，因此可以使用集合类型存储文章标签。
2、通过标签搜索文章。redis使用起来就非常简单，如果是传统关系数据库，则需要联合几张表进行处理。每篇文章对应一个标签集合，并且每个标签中记录一个文章ID集合。这样，直接求几个文章ID的交集即可。这样可以直接在redis数据库中将所以的操作全部用来处理。

zset（有序集合）

在集合类型的基础上有序集合类型为集合中的每个元素都关联了一个分数，这使得我们不仅可以完成插入、删除和判断元素是否存在等集合类型支持的操作，还能够获得分数最高(或最低）的前N个元素、获得指定分数范围内的元素等与分数有关的操作。虽然集合中每个元素都是不同的，但是它们的分数却可以相同。（内部通过分数排序了，hash很容易实现）。
有序集合可以直接实现文章访问量排序的功能，最适合做有排名的鬼东西，这样可以减轻客户端处理的任务，直接让数据库处理了，很机智，很聪明。
列表和有序集合二者都是有序，且可以获取某一范围的元素，区别如下：

• 列表类型是通过链表实现的，获取靠近两端的数据速度极快，而当元素增多后，
  访问中间数据的速度会较慢，所以它更加适合实现如”新鲜事 ” 或”日志”这样很少访 问中间元素的应用。
• 有序集合类型是使用散列表和跳跃表(Skip list)实现的，所以即使读取位于中间
  部分的数据速度也很快(时间复杂度是O(log(N)) )。
• 列表中不能简单地调整某个元素的位置，但是有序集合可以(通过更改这个元素
  的分数)。
• 有序集合要比列表类型更耗费内存。

zadd zrange

1、ZADD key score member [[score member] [score member] ...]
将一个或多个member及其score加入key中。

# 添加单个元素
redis> ZADD page_rank 10 google.com
(integer) 1
# 添加多个元素
redis> ZADD page_rank 9 baidu.com 8 bing.com
(integer) 2
redis> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"
# 添加已存在元素，且 score 值不变
redis> ZADD page_rank 10 google.com
(integer) 0
redis> ZRANGE page_rank 0 -1 WITHSCORES  # 没有改变
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"
# 添加已存在元素，但是改变 score 值
redis> ZADD page_rank 6 bing.com
(integer) 0
redis> ZRANGE page_rank 0 -1 WITHSCORES  # bing.com 元素的 score 值被改变
1) "bing.com"
2) "6"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"

2、ZRANGE key start stop [WITHSCORES]
返回有序集key中，指定区间内的成员。其中成员的位置按score值递增(从小到大)来排序。具有相同score值的成员按字典序(lexicographical order )来排列。可以通过使用WITHSCORES选项，来让成员和它的score值一并返回。

redis > ZRANGE salary 0 -1 WITHSCORES             # 显示整个有序集成员
1) "jack"
2) "3500"
3) "tom"
4) "5000"
5) "boss"
6) "10086"
redis > ZRANGE salary 1 2 WITHSCORES              # 显示有序集下标区间 1 至 2 的成员
1) "tom"
2) "5000"
3) "boss"
4) "10086"
redis > 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)

zrangebyscore

1、ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]
返回有序集key中，所有score值介于min和max之间(包括等于min或max)的成员。有序集成员按score值递增(从小到大)次序排列。
具有相同score值的成员按字典序(lexicographical order)来排列。
可选的LIMIT参数指定返回结果的数量及区间(就像SQL中的SELECT LIMIT offset, count)。

zrem zcard zcount zrank

1、ZREM key member [member ...]
移除有序集key中的一个或多个成员，不存在的成员将被忽略。
2、ZCARD key
返回有序集合中成员的数量。

3、ZCOUNT key min max
统计有序集合中，score位于min和max之间的成员的数量。

3、ZRANK key member
返回member在key中的排名，这是通过score排名的。

zrevrank zrevrange zrevrangebyscore

1、ZREVRANGE key start stop [WITHSCORES]
区别与ZRANGE，只不过这个score从大到小排列。
2、ZREVRANK key member
倒数第几名。
3、ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]
返回有序集key中， score值介于max和min之间(默认包括等于max或min)的所有的成员。有序集成员按 score 值递减(从大到小)的次序排列。
4、ZINCRBY key increment member
增加某个member的分数。increment是正数，则是增加， 负数则是减少。

实践

文章按访问量排序、或按实现排序，实现起来就很容易了，直接用一个有序集合，然后以文章id作为成员，分数用时间或者点击率即可实现。

hash

散列表适合存储一个对象，在键中可以放多个域名和值对。
hash是一个string类型的field和value的映射表，hash特别适合用于存储对象。
KV模式不变，但是V是一个键值对。

这种hash操作，会比较简单，删除和添加内容都比较好管理。

hset hsetnx hget hmset hmget hgetall hdel

1、HSET key field value
将哈希表key中的域field的值设为value 。
如果key不存在，一个新的哈希表被创建并进行HSET操作。
如果域field已经存在于哈希表中，旧值将被覆盖。

2、HMSET key field value [field value ...]
同时将多个field-value (域-值)对设置到哈希表key中，重复则覆盖

3、HGET key field
获取某个域的值。
4、HMGET key field [field ...]
获取多个域的值。

hlen hexists

1、HLEN key
hlen获取key中域的数量

2、HEXISTS key field
查看key中的某个域是否存在。

hkeys hvals hincrby hincrbyfloat

1、HKEYS key
返回key中所有域
2、HVALS key
返回key中所有域对应的值
3、HINCRBY key field increment
key中域的值增加increment。
4、HINCRBYFLOAT key field increment
增加浮点而已，很简单。

解析配置文件

参数说明
redis.conf 配置项说明如下：

1. Redis默认不是以守护进程的方式运行，可以通过该配置项修改，使用yes启用守护进程
   daemonize no
2. 当Redis以守护进程方式运行时，Redis默认会把pid写入/var/run/redis.pid文件，可以通过pidfile指定
   pidfile /var/run/redis.pid
3. 指定Redis监听端口，默认端口为6379，作者在自己的一篇博文中解释了为什么选用6379作为默认端口，因为6379在手机按键上MERZ对应的号码，而MERZ取自意大利歌女Alessia Merz的名字
   port 6379
4. 绑定的主机地址
   bind 127.0.0.1
   5.当 客户端闲置多长时间后关闭连接，如果指定为0，表示关闭该功能
   timeout 300
5. 指定日志记录级别，Redis总共支持四个级别：debug、verbose、notice、warning，默认为verbose
   loglevel verbose
6. 日志记录方式，默认为标准输出，如果配置Redis为守护进程方式运行，而这里又配置为日志记录方式为标准输出，则日志将会发送给/dev/null
   logfile stdout
7. 设置数据库的数量，默认数据库为0，可以使用SELECT 命令在连接上指定数据库id
   databases 16

8. 指定在多长时间内，有多少次更新操作，就将数据同步到数据文件，可以多个条件配合
   save
   Redis默认配置文件中提供了三个条件：
   save 900 1
   save 300 10
   save 60 10000
   分别表示900秒（15分钟）内有1个更改，300秒（5分钟）内有10个更改以及60秒内有10000个更改。

9. 指定存储至本地数据库时是否压缩数据，默认为yes，Redis采用LZF压缩，如果为了节省CPU时间，可以关闭该选项，但会导致数据库文件变的巨大
   rdbcompression yes

10. 指定本地数据库文件名，默认值为dump.rdb
    dbfilename dump.rdb
11. 指定本地数据库存放目录
    dir ./
12. 设置当本机为slav服务时，设置master服务的IP地址及端口，在Redis启动时，它会自动从master进行数据同步
    slaveof
13. 当master服务设置了密码保护时，slav服务连接master的密码
    masterauth
14. 设置Redis连接密码，如果配置了连接密码，客户端在连接Redis时需要通过AUTH 命令提供密码，默认关闭
    requirepass foobared
15. 设置同一时间最大客户端连接数，默认无限制，Redis可以同时打开的客户端连接数为Redis进程可以打开的最大文件描述符数，如果设置 maxclients 0，表示不作限制。当客户端连接数到达限制时，Redis会关闭新的连接并向客户端返回max number of clients reached错误信息
    maxclients 128
16. 指定Redis最大内存限制，Redis在启动时会把数据加载到内存中，达到最大内存后，Redis会先尝试清除已到期或即将到期的Key，当此方法处理 后，仍然到达最大内存设置，将无法再进行写入操作，但仍然可以进行读取操作。Redis新的vm机制，会把Key存放内存，Value会存放在swap区
    maxmemory
17. 指定是否在每次更新操作后进行日志记录，Redis在默认情况下是异步的把数据写入磁盘，如果不开启，可能会在断电时导致一段时间内的数据丢失。因为 redis本身同步数据文件是按上面save条件来同步的，所以有的数据会在一段时间内只存在于内存中。默认为no
    appendonly no
18. 指定更新日志文件名，默认为appendonly.aof
    appendfilename appendonly.aof
19. 指定更新日志条件，共有3个可选值：
    no：表示等操作系统进行数据缓存同步到磁盘（快）
    always：表示每次更新操作后手动调用fsync()将数据写到磁盘（慢，安全）
    everysec：表示每秒同步一次（折衷，默认值）
    appendfsync everysec
20. 指定是否启用虚拟内存机制，默认值为no，简单的介绍一下，VM机制将数据分页存放，由Redis将访问量较少的页即冷数据swap到磁盘上，访问多的页面由磁盘自动换出到内存中（在后面的文章我会仔细分析Redis的VM机制）
    vm-enabled no
21. 虚拟内存文件路径，默认值为/tmp/redis.swap，不可多个Redis实例共享
    vm-swap-file /tmp/redis.swap
22. 将所有大于vm-max-memory的数据存入虚拟内存,无论vm-max-memory设置多小,所有索引数据都是内存存储的(Redis的索引数据 就是keys),也就是说,当vm-max-memory设置为0的时候,其实是所有value都存在于磁盘。默认值为0
    vm-max-memory 0
23. Redis swap文件分成了很多的page，一个对象可以保存在多个page上面，但一个page上不能被多个对象共享，vm-page-size是要根据存储的 数据大小来设定的，作者建议如果存储很多小对象，page大小最好设置为32或者64bytes；如果存储很大大对象，则可以使用更大的page，如果不 确定，就使用默认值
    vm-page-size 32
24. 设置swap文件中的page数量，由于页表（一种表示页面空闲或使用的bitmap）是在放在内存中的，，在磁盘上每8个pages将消耗1byte的内存。
    vm-pages 134217728
25. 设置访问swap文件的线程数,最好不要超过机器的核数,如果设置为0,那么所有对swap文件的操作都是串行的，可能会造成比较长时间的延迟。默认值为4
    vm-max-threads 4
26. 设置在向客户端应答时，是否把较小的包合并为一个包发送，默认为开启
    glueoutputbuf yes
27. 指定在超过一定的数量或者最大的元素超过某一临界值时，采用一种特殊的哈希算法
    hash-max-zipmap-entries 64
    hash-max-zipmap-value 512
28. 指定是否激活重置哈希，默认为开启（后面在介绍Redis的哈希算法时具体介绍）
    activerehashing yes
29. 指定包含其它的配置文件，可以在同一主机上多个Redis实例之间使用同一份配置文件，而同时各个实例又拥有自己的特定配置文件include /path/to/local.conf

Redis持久化

Redis事务

事务(transaction)是一组命令的集合。集合中的命令要么全部都执行，要么都不执行，并不能支持执行过程中错误发生之后进行回滚操作。事务的原理是先将属于一个事务的命令发送给Redis，然后再让Redis依次执行这些命令。

Redis发布订阅

Redis主从复制和读写分离和故障恢复