Redis基础学习--安装、简介、基本数据类型及相应命令

redis安装教程：http://www.runoob.com/redis/redis-install.html

1. Redis简介　　

　　Redis是一个速度非常快的高性能的key-value存储系统。redis的出现，很大程度补偿了memcached这类key/value存储的不足。它通常被称为数据结构服务器，因为值（value）可以是 字符串(String), 哈希(Map), 列表(list), 集合(sets) 和 有序集合(sorted sets)等类型。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。为了保证效率，数据都是缓存在内存中。redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文 件，并且在此基础上实现了master-slave(主从)同步。Redis是基于内存的数据结构存储开源系统，采用C语言编写，数据存在内存里面，运行效率极高。可作为内存数据库、缓存或消息代理中间件，前两种情况实际当中使用更多些。
　　Redis支持的客户端操作语言非常丰富，达到40多种。就Java来说，也有很多访问驱动实现，我们最常用的还是Jedis。 Jedis活跃度很高，能够跟上Redis服务端发布的最新功能，而且使用简单，基本和Redis命令行语法相似。

2. Redis的优点

    1).速度快，因为数据存在内存中，类似于HashMap，HashMap的优势就是查找和操作的时间复杂度都是O(1)
    2).支持丰富数据类型，支持string，list，set，sorted set，hash
    3).支持事务，操作都是原子性，所谓的原子性就是对数据的更改要么全部执行，要么全部不执行
    4).丰富的特性：可用于缓存，消息，按key设置过期时间，过期后将会自动删除

3. Redis与其他一些数据库和缓存服务器的特性与功能的对比如下：

名称	类型	数据存储选项	查询类型	附加功能
Redis	使用内存存储（in-memory）的非关系数据库	字符串、列表、集合、散列表、有序集合	每种数据类型都有自己的专属命令，另外还有批量操作（bulk operation）和不完全（partial）的事务支持	发布与订阅，主从复制（master/slave replication），持久化，脚本（存储过程，stored procedure）
memcached	使用内存存储的键值缓存	键值之间的映射	创建命令、读取命令、更新命令、删除命令以及其他几个命令	为提升性能而设的多线程服务器
MySQL	关系数据库	每个数据库可以包含多个表，每个表可以包含多个行；可以处理多个表的视图（view）；支持空间（spatial）和第三方扩展	SELECT、INSERT、UPDATE、DELETE、函数、存储过程	支持ACID性质（需要使用InnoDB），主从复制和主主复制 （master/master replication）
PostgreSQL	关系数据库	每个数据库可以包含多个表，每个表可以包含多个行；可以处理多个表的视图；支持空间和第三方扩展；支持可定制类型	SELECT、INSERT、UPDATE、DELETE、内置函数、自定义的存储过程	支持ACID性质，主从复制，由第三方支持的多主复制（multi-master replication）
MongoDB	使用硬盘存储（on-disk）的非关系文档存储	每个数据库可以包含多个表，每个表可以包含多个无schema（schema-less）的BSON文档	创建命令、读取命令、更新命令、删除命令、条件查询命令等	支持map-reduce操作，主从复制，分片，空间索引（spatial index）

4. Redis的持久化方式

　　在使用类似Redis这样的内存数据库时（将数据存储在内存中虽然比存储在硬盘的数据库快，但也有问题，如程序退出后内存中的数据会丢失），一个首先要考虑的问题就是“当服务器被关闭时，服务器存储的数据将何去何从呢？”
　　Redis拥有两种不同形式的持久化方法，它们都可以用小而紧凑的格式将存储在内存中的数据写入硬盘：
　　第一种持久化方法为RDB，即时间点转储（point-in-time dump）。有一份数据，就把这一份数据整体保存一份，每隔一定的时间就保存一下数据，保存的是最终的结果。转储操作既可以在“指定时间段内有指定数量的写操作执行”这一条件被满足时执行，又可以通过调用两条转储到硬盘（dump-to-disk）命令中的任何一条来执行；
　　第二种持久化方法是AOF，将所有修改了数据库的命令都写入一个只追加（append-only）文件里面，保存的是命令操作。用户可以根据数据的重要程度，将只追加写入设置为从不同步（sync）、每秒同步一次或者每写入一个命令就同步一次。

5. Redis的主从同步

　　Redis实现了主从复制特性：执行复制的从服务器会连接上主服务器，接收主服务器发送的整个数据库的初始副本（copy）；之后主服务器执行的写命令，都会被发送给所有连接着的从服务器去执行，从而实时地更新从服务器的数据集。因为从服务器包含的数据会不断地进行更新，所以客户端可以向任意一个从服务器发送读请求，以此来避免对主服务器进行集中式的访问。

------------------------------------------------------------------------------------------------------------------------

二、基本数据类型及相应命令

2-1.准备知识

1、获取符合规则的键名列表
 keys pattern
pattern:支持glob风格通配符格式
 ?  匹配一个字符
 *  匹配任意个(包括0个)字符
 [] 匹配括号间的任一字符，可以使用“一”符号表示一个范围，如司a[b-d]可以匹配"ab", "ac”和“ad”
 \x 匹配字符x，用于转义符号。如要匹配“?”就需要使用\?
redis > set bar 1
redis > keys *
 使用keys *就能获取Redis中所有的键了。注意：keys命令需要遍历Redis中所有 的键，当键的数量较多时会影响性能，不建议在生产环境中使用。
 提示：redis不区分命令大小 写。
2).判断一个键是否存在
exists key
如果键存在则返回整数类型1，否则返回0.
3).删除键
del key [key...]
可以删除一个或多个键，返回值是删除的键的个数。不支持通配符，但可以结合管道删除所有符合规则的键。
4).获取键值的数据类型
type key
 type 命令用来获取键值的数据类型。

2-2. String（字符串）

  string是redis最基本的类型，一个key对应一个value。
  string类型是二进制安全的。意思是redis的string可以包含任何数据。比如jpg图片或者序列化的对象 。
  string类型是Redis最基本的数据类型，一个键最大能存储512MB。
　String是最常用的一种数据类型，普通的key/value存储都可以归为此类，value其实不仅是String， 也可以是数字：比如想知道什么时候封锁一个IP地址(访问超过几次)。INCRBY命令让这些变得很容易，通过原子递增保持计数。

1.基本命令
1.赋值与取值
SET key value
GET key
实例：
127.0.0.1:6379> set mykey myvalue
OK
127.0.0.1:6379> get mykey
"myvalue"

2.递增数字
INCR key
前面说过字符串类型可以存储任何形式的字符串，当存储的字符串是整数形式时，Redis提供了一个实用的命令工INCR，其作用是让当前键值递增，并返回递增后的值，用法为:
127.0.0.1:6379> incr num1
(integer) 1
127.0.0.1:6379> incr num1
(integer) 2

当要操作的键不存在时会默认键值为0,所以第一次递增后的结果是1,当键值不是整数时Redis会提示错误:
127.0.0.1:6379> set name changwen
OK
127.0.0.1:6379> incr name
(error) ERR value is not an integer or out of range

1).增加指定的整数
INCRBY key increment
    INCRBY 命令与INCR命令基本一样，只不过前者可以通过increment参数指定一次增加的数值，如:
127.0.0.1:6379> incrby count 2
(integer) 2
127.0.0.1:6379> incrby count 3
(integer) 5

3).增加指定浮点数
incrbyfloat key increment
incrbyfloat 命令类似incrby命令，差别是前者可以递增一个双精度浮点数，如:
127.0.0.1:6379> incrbyfloat count 2.7
"4.7"
127.0.0.1:6379> incrbyfloat count 5e+4
"50004.69999999999999929"

2).减少指定的整数
DECR key
DECRBY key decrement
DECR命令与INCR命令用法相同，只不过是让键值递减，例如:
127.0.0.1:6379> decr count
(integer) 4
127.0.0.1:6379> decrby count 2
(integer) 2

4).向尾部追加值
APPEND key value
    APPEND作用是向键值的末尾追加value。如果键不存在则将该键的值设置为value,即相当于set key value。返回值是追加后字符串的总长度。例如:
127.0.0.1:6379> append name1 "test1"
(integer) 5
127.0.0.1:6379> append name1 " world"
(integer) 11
127.0.0.1:6379> get name1
"test1 world"
APPEND命令的第二个参数需要加双引号，原因是该参数的数据如果包含空格，在redis-c]i中输入需要双引号以示区分。

5).获取字符串长度
strlen  key
STRLEN命令返回键值的长度，如果键不存在则返回0。例如
127.0.0.1:6379> strlen name1
(integer) 11
127.0.0.1:6379> strlen name2
(integer) 0
    前面提到了字符串类型可以存储二进制数据，所以它可以存储任何编码的字符串。例子中Redis接收到的是使用UTF-8编码的中文，由于“你”和“好”两个字的UTF-8编码的长度都是3，所以此例中会返回6.

6).同时获得/设置多个健值
mget key [key... ]
mset key value[ key value...]
    mget/mset与get/set相似，不过mget/mset可以同时获得/设置多个键的键值。例如:
127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3
OK
127.0.0.1:6379> mget k1 k2 k3
1) "v1"
2) "v2"
3) "v3"

getrange key start end: 返回 key 中字符串值的子字符
getset key value: 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。
getbit key offset: 对 key 所储存的字符串值，获取指定偏移量上的位(bit)。
setbit key offset value: 对 key 所储存的字符串值，设置或清除指定偏移量上的位(bit)。
setex key seconds value: 将值 value 关联到 key ，并将 key 的过期时间设为 seconds (以秒为单位)。
setnx key value: 只有在 key 不存在时设置 key 的值。
setrange key offset value: 用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始。
msetnx  key value [key value ...]: 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在。
psetex    key milliseconds value: 这个命令和 SETEX 命令相似，但它以毫秒为单位设置 key 的生存时间，而不是像 SETEX 命令那样，以秒为单位。

2-3.Hash

    我们现在已经知道Redis是采用字典结构以键值对的形式存储数据的，而散列类型(hash)的键值也是一种字典结构，其存储了字段(field)和字段值的映射，但字段值只能是字符串，不支持其他数据类型，换句话说，散列类型不能嵌套其他的数据类型。一个散列类型键可以包含至多232-1个字段。
  提示: 除了散列类型，Redis的其他数据类型同样不支持数据类型嵌套。比如集合类型的每个元素都只能是字符串，不能是另一个集合或散列表等口
  散列类型适合存储对象:使用对象类别和ID构成键名，使用字段表示对象的属性，而字段值则存储属性值。例如要存储ID为2的汽车对象，可以分别使用名为color:name和price的3个字段来存储该辆汽车的颜色、名称和价格。存储结构如图

    如果我们用关系型数据库建这个Car表，就是id,color,name,price，如果只有一条记录要新增日期，就增加date字段。可想而知，当不同的记录需要不同的属性时，表的字段数量会越来越多以至于难以维护。而Redis的散列类型则不存在这个问题。Redis并不要求每个键都依据此结构存储，我们完全可以自由地为任何键增减字段而不影响其他键。

1.命令
1).赋值与取值
hset key field value
hget key field
hmset key field value[field value ...]
hmget key field[field ...]
hgetall key
    HSET命令的方便之处在于不区分插入和更新操作，这意味着修改数据时不用事先判断字段是否存在，来决定要执行的是插入操作(update)还是更新操作(insert )。当执行的是插入操作时(即之前字段不存在)HSET命令会返回1,当执行的是更新操作时(即之前字段己经存在)HSET命令会返回0。更进一步，当键本身不存在时，HSET命令还会自动创建它。
    提示：在Redis中每个健都属于一个明确的数据类型，如通过HSET命令建立的健是散列类型，通过SET命令建立的键是字符串类型等。使用一种数据类型的命令操作另一种数据类型的健会提示错误。
127.0.0.1:6379> hset car color white
(integer) 1
127.0.0.1:6379> hset car name BMW
(integer) 1
127.0.0.1:6379> hset car price 1000000
(integer) 1
127.0.0.1:6379> hget car name
"BMW"
127.0.0.1:6379> get car name
(error) ERR wrong number of arguments for 'get' command

#   当需要同时设置多个字段的值时，可以使用HMSET命令。
127.0.0.1:6379> hmget car name color price
1) "BMW"
2) "white"
3) "1000000"

#  如果想获取键中所有字段和字段值却不知道键中有哪些字段时(如的存储汽车对象的例子，每个对象拥有的属性都未必相同)应该使用HGETALL命令。如:
127.0.0.1:6379> hgetall car
1) "color"
2) "white"
3) "name"
4) "BMW"
5) "price"
6) "1000000"
    返回的结果是字段和字段值组成的列表，不是很直观，好在很多语言的Redis客户端会将HGETALL的返回结果封装成编程语言中的对象，处理起来就非常方便了。例如，
在Nodejs中:
redis.hgetall{"car", function (error, cart){
    //hgetall方法的返回的值被封装成了javaScript的对象
    console.log(car.price);
    console.log(car.name);
}};

2).判断字段是否存在
hexists key field
  hexists 命令用来判断一个字段是否存在。如果存在则返回1，否则返回0(如果键不存在也会返同0).
127.0.0.1:6379> hexists car color
(integer) 1
127.0.0.1:6379> hexists car color1
(integer) 0

3).当字段不存在时赋值
hsetnx key field value
    hsetnx 命令与HSET命令类似，区别在于如果字段己经存在，hsetnx 命令将不执行任何操作,只不过HSETNX命令是原子操作，不用担心竞态条件。

4).增加数字
hincrby key field increment
  hincrby 命令与incrby类似，可以使字段值增加指定的整数。散列类型没有hincr命令，但是可以通过hincrby key field 1来实现。
127.0.0.1:6379> hincrby car price 1
(integer) 1000001
  如果car键不存在，hincrby命令会自动建立该键并默认price字段在执行命令前的值为“0”。命令的返回值是增值后的字段值。

5).删除字段
hdel key field[filed ...]
hdel 命令可以删除一个或多个字段，返回值是被删除的字段个数:
127.0.0.1:6379> hdel car2 color
(integer) 1
127.0.0.1:6379> hgetall color
(empty list or set)

6).只获取所有的字段名或字段值
hkeys key
hvals key
127.0.0.1:6379> hkeys car
1) "color"
2) "name"
3) "price"
127.0.0.1:6379> hvals car
1) "white"
2) "BMW"
3) "1000001"

hlen key：获取哈希表中字段的数量
hscan key cursor [MATCH pattern] [COUNT count]：迭代哈希表中的键值对
hincrbyfloat key field increment：为哈希表 key 中的指定字段的浮点数值加上增量 increment
---------------------------------------------------------------------------------------------------------------

2-4、列表(list)

    列表类型(list)可以存储一个有序的字符串列表，常用的操作是向列表两端添加元素，或者获得列表的某一个片段。
    列表类型内部是使用双向链表(double linked list)实现的，所以向列表两端添加元素的时间复杂度为O(1)，获取越接近两端的元素速度就越快。这意味着即使是一个有几千万个元素的列表，获取头部或尾部的10条记录也是极快的(和从只有20个元索的列表中获取头部或尾部的10条记录的速度是一样的)。不过使用链表的代价是通过索引访问元素比较慢。
    这种特性使列表类型能非常快速地完成关系数据库难以应付的场景:如社交网站的新鲜事，我们关心的只是最新的内容，使用列表类型存储，即使新鲜事的总数达到几千万个，获取其中最新的l00条数据也是极快的。同样因为在两端插入记录的时间复杂度是O(1)，列表类型也适合用来记录日志，可以保证加入新日志的速度不会受到己有日志数量的影响。
    借助列表类型，Redis还可以作为队列使用，之后会介绍。
    与散列类型键最多能客纳的字段数量相同，一个列表类型键最多能容纳2的32`-1个元素。
命令
1).向列表两端增加元素
rpush key value1 [value2]: rpush向列表右边增加元素
rpushx key value: 为已存在的列表添加值

lpush key value1 [value2]: lpush 命令用来向列表左边(头部)增加元素，返回值表示增加元素后列表的长度
lpushx key value: 将一个或多个值插入到已存在的列表头部

2).向列表中插入元素
LINSERT key BEFORE|AFTER pivot value
    linsert命令首先会在列表中从左到右查找值为pivot 的元素，然后根据第二个参数是BEFORE还是AFTER来决定将value插入到该元素的前面还是后面。linsert命令的返回值是插入后列表的元素个数。

3).从列表两端弹出元素
LPOP key：移出并获取列表的第一个元素
RPOP key：移除并获取列表最后一个元素

4).获取列表中元素的个数
LLEN key：获取列表长度    
    LLEN命令的功能类似SQL语句SELECT  count(*)  FROM  talbe_name,但是LLEN的时问复杂度为O(1)，使用时Redis会直接读取现成的值，而不需要像部分关系数据库(如使用InnoDB存储引擎的MySQL表)那样需要遍历一遍数据表来统计条目数量。

5).获取列表片段（不会删除该片段，也不会删除片段处的数据）
LRANGE key start stop：获取列表指定范围内的元素
    LRANGE命令是列表类型最常用的命令之一，它能够获得列表中的某一片段，并且不会删除该片段。lrange命令将返回索引从:start到stop间的所有元素(包含两端的元素)。与大多数人的直觉相同，Redis的列表起始索引为0:
127.0.0.1:6379> lrange list1 0 2
1) "0"
2) "2"
3) "3"
    lrange命令也支持负索引，表示从右边开始计算序数，如"-1"表示最右边第一个元素，"-2 "表示最右边第二个元素，依次类推:
显然lrange list1 0 -1可以获取列表中的所有元素
特殊情况：
①如果start的索引位置比stop的索引位置靠后，则会返回空列表。
②如果stop大于实际的索引范围，则会返回到列表最右边的元素:

6).只保留列表指定片段
LTRIM key start stop
   让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除，其指定列表范围的方法和LRANGE命令相同
   ltrim命令常和lpush命令一起使用来限制表中元素的数量，比如记录日志时只保留最近的100条日志，则每次加入新元素时调用一次ltrim命令即可：
lpush logs $newLog
ltrim logs 0 99

7).删除列表中指定的值
LREM key count value: 移除列表元素
    LREM命令会删除列表中前count个值为value的元素，返回值是实际删除的元素个数。根据count值的不同，LREM命令的执行方式会略有差异:
    ①当count>0时,LREM命令会从列表左边开始删除前count个值为value的元素;
    ②当count<0时,LREM命令会从列表右边开始删除前|count|个值为value的元素:
    ③当count=O是,LREM命令会删除所有值为value的元素。例如:
127.0.0.1:6379> lrange list1 0 -1
1) "2"
2) "1"
3) "2"
4) "0"
# 从右开始删除值为2的两个元素
127.0.0.1:6379> lrem list1 -2 2
(integer) 2
127.0.0.1:6379> lrange list1 0 -1
1) "1"
2) "0"

8).获取/设置指定索引的元素值
LINDEX key index：通过索引获取列表中的元素
LSET key index value：通过索引设置列表元素的值
  如果要将列表类型当作数组来用，lindex命令是必不可少的。lindex命令用来返回指定索引的元素，索引从0开始。如果index是负数表示从右边开始计算。如:
127.0.0.1:6379> lindex list1 0
"1"
127.0.0.1:6379> lindex list1 -1
"0"
127.0.0.1:6379> lset list1 0 12
OK
127.0.0.1:6379> lrange list1 0 -1
1) "12"
2) "0"

RPOPLPUSH source destination：移除列表的最后一个元素，并将该元素添加到另一个列表并返回
BLPOP key1 [key2 ] timeout：移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
BRPOP key1 [key2 ] timeout：移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
BRPOPLPUSH source destination timeout：从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它； 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。

---------------------------------------------------------------------------------------------------------------------------

2-5、集合(Set)
  集合的特点：无序性，唯一性；列表的特点：有序性，不唯一。两者都至多存储2的32-1交方个字符串
命令
1).增加/删除元素
SADD key member1 [member2]：向集合添加一个或多个成员
SREM key member1 [member2]：移除集合中一个或多个成员
    SADD命令用来向集合中增加一个或多个元素，如果键不存在则会自动创建。因为在一个集合中不能有相同的元素，所以如果要加入的元素己经存在于集合中就会忽略这个元素。本命令的返回值是成功加入的元素数量(忽略的元索不计算在内)。
    SREM命令用来从集合中删除一个或多个元素，并返回删除成功的个数（只删除在集合中存在的元素）
127.0.0.1:6379> sadd set1 a
(integer) 1
127.0.0.1:6379> sadd set1 a b c
(integer) 2
127.0.0.1:6379> srem set1 c d
(integer) 1

2).集合间运算
sdiff key1 [key2]：返回给定所有集合的差集
sinter key1 [key2]：返回给定所有集合的交集
sunion key1 [key2]：返回所有给定集合的并集
127.0.0.1:6379> sadd setA 1 2 3
(integer) 3
127.0.0.1:6379> sadd setB 2 3 4
(integer) 3
# 计算顺序是先计算setA-setB,再计算后面的差集
127.0.0.1:6379> sdiff setA setB
1) "1"
127.0.0.1:6379> sinter setA setB
1) "2"
2) "3"
127.0.0.1:6379> sunion setA setB
1) "1"
2) "2"
3) "3"
4) "4"

3).进行集合运算并将结果存储
SDIFFSTORE destination key1 [key2]：返回给定所有集合的差集并存储在 destination 中
SINTERSTORE destination key1 [key2]：返回给定所有集合的交集并存储在 destination 中
SUNIONSTORE destination key1 [key2]：所有给定集合的并集存储在 destination 集合中
  sdiffstore 与sdiff命令功能一样，唯一的区别就是前者不会直接返回运算结果，而是直接存储在destination键中

4).随机获取集合中的元素
SPOP key：移除并返回集合中的一个随机元素
SRANDMEMBER key [count]：返回集合中一个或多个随机数

SMEMBERS key：返回集合中的所有成员
SCARD key：获取集合的成员数
SSCAN key cursor [MATCH pattern] [COUNT count]：迭代集合中的元素
SISMEMBER key member：判断 member 元素是否是集合 key 的成员，O(1)的操作
SMOVE source destination member：将 member 元素从 source 集合移动到 destination 集合

-----------------------------------------------------------------------------------------------------------------------------------

2-6.有序集合(sorted set)

    有序集合类型为集合中的每个元素都关联一个分数，这使得我们能够获得分数最高(或最低)的前N个元素、获得指定分数范围内的元素等与分数有关的操作。虽然集合中每个元素都是不同的，但是它们的分数却可以相同。
    有序集合类型在某些方面和列表类型有些相似口
    (1)二者都是有序的。
    (2)二者都可以获得某一范围的元素。
    但是二者有一着很大的区别，这使得它们的应用场景也是不同的。
    (1)列表类型是通过链表实现的，获取靠近两端的数据速度极快，而当元素增多后，访问中间数据的速度会较慢，所以它更加适合实现如“新鲜事”或“日志”这样很少访问中间元素的应用.
    (2)有序集合类型是使用散列表和跳跃表(Skip list)实现的，所以即使读取位于中间部分的数据速度也很快(时间复杂度是O(log(N))) 。
    (3)列表中不能简单地调整某个元素的位置，但是有序集合可以〔通过更改这个元素的分数)。
    (4)有序集合要比列表类型更耗费内存.
命令：
1).增加元素
ZADD key score1 member1 [score2 member2]
  向有序集合添加一个或多个成员，或者更新已存在成员的分数。如果该元素已经存在则会用新的分数替换原有的分数。
127.0.0.1:6379> zadd sortSet1 69 tom 76 jack 100 mike
(integer) 3
# 如果tom的分数有误，可以这么修改
127.0.0.1:6379> zadd sortSet1 70 tom
(integer) 0
127.0.0.1:6379> zrangebyscore sortSet1 0 100 withscores
1) "tom"
2) "70"
3) "jack"
4) "76"
5) "mike"
6) "100"

2).增加某个元素的分数
ZINCRBY key increment member
    有序集合中对指定成员的分数加上增量 increment
# 给tom增加4分
127.0.0.1:6379> zincrby sortSet1 4 tom
"74"
127.0.0.1:6379> zrangebyscore sortSet1 0 100 withscores
1) "tom"
2) "74"
3) "jack"
4) "76"
5) "mike"
6) "100"

2).获取元素的分数
ZSCORE key member：返回有序集中，成员的分数值
127.0.0.1:6379> zscore sortSet1 tom
"69"

3).获取排名在某个范围的元素列表
ZRANGE key start stop [WITHSCORES]
  通过索引区间返回有序集合成指定区间内的成员，分数从小到大
ZREVRANGE key start stop [WITHSCORES]
  返回有序集中指定区间内的成员，通过索引，分数从高到底(与zrange唯一不同)
  zrange命令会按照元素分数从小到大的顺序返回索引从start到stop之间的所有元素(包含两端的元素)。zrange命令与lrange命令十分相似，如索引都是从O开始，负数代表从后向前查找(-1表示最后一个元素)。就像这样:
127.0.0.1:6379> zrange sortSet1 0 -1
1) "tom"
2) "jack"
3) "mike"
# 如果需要同时获得元素的分数的话可以在尾部加上withscores参数
127.0.0.1:6379> zrange sortSet1 0 -1 withscores
1) "tom"
2) "69"
3) "jack"
4) "76"
5) "mike"
6) "100"
    如果两个元素的分数相同，Redis会按照字典顺序(即"0"<"9"<"A" <"Z" "a"<"z"这样的顺序)来进行排列。再进一步，如果元素的值是中文怎么处理呢?答案是取决于中文的编码方式，如使用UTF-8编码,结果还是按上面的顺序。

4).获取指定分数范围的元素
ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT]
  通过分数返回有序集合指定区间内的成员，分数从低到高排序
ZREVRANGEBYSCORE key max min [WITHSCORES]
  返回有序集中指定分数区间内的成员，分数从高到低排序
max min支持无穷大-inf、+inf
127.0.0.1:6379> zrangebyscore sortSet1 50 100
1) "tom"
2) "jack"
3) "mike"
# 如果分数范围不包含端点值，可以在分数前加上"("符号。
127.0.0.1:6379> zrangebyscore sortSet1 50 (100
1) "tom"
2) "jack"
# 想获得分数高于60分的从第二个人开始的3个人:
127.0.0.1:6379> zrangebyscore sortSet1 50 +inf limit 1 3
1) "jack"
2) "mike"
# 获取分数低于或等于100分的前3个人
127.0.0.1:6379> zrevrangebyscore sortSet1 100 0 limit 0 3
1) "mike"
2) "jack"
3) "tom"

5).移除操作
ZREM key member [member ...]：  移除有序集合中的一个或多个成员
ZREMRANGEBYLEX key min max：    移除有序集合中给定的字典区间的所有成员(0,-1)
ZREMRANGEBYRANK key start stop：移除有序集合中给定的排名区间的所有成员
ZREMRANGEBYSCORE key min max：  移除有序集合中给定的分数区间的所有成员

6).获取元素排名
  ZRANK key member: 返回有序集合中指定成员的索引
  ZREVRANK key member: 返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序

ZCARD key：获取有序集合的成员个数
ZCOUNT key min max：计算在有序集合中指定区间分数的成员数
ZLEXCOUNT key min max: 在有序集合中计算指定字典区间内成员数量
ZINTERSTORE destination numkeys key [key ...]：计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中
ZUNIONSTORE destination numkeys key [key ...]：计算给定的一个或多个有序集的并集，并存储在新的 key 中
ZSCAN key cursor [MATCH pattern] [COUNT count]：迭代有序集合中的元素（包括元素成员和元素分值）
ZRANGEBYLEX key min max [LIMIT offset count]：通过字典区间返回有序集合的成员