redis數據類型

時間 2019-11-07

標籤 redis 數據類型欄目 Redis 简体版

原文原文鏈接

Redis 數據類型

　　Redis支持五種數據類型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)。python

String（字符串）

　　string 是 redis 最基本的類型，你能夠理解成與 Memcached 如出一轍的類型，一個 key 對應一個 value。mysql

　　string 類型是二進制安全的。意思是 redis 的 string 能夠包含任何數據。好比jpg圖片或者序列化的對象。程序員

　　string 類型是 Redis 最基本的數據類型，string 類型的值最大能存儲 512MB。web

實例redis

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

以上實例中使用了 Redis 的 SET 和 GET 命令。鍵爲 name，對應的值爲 runoob。sql

注意：一個鍵最大能存儲512MB。mongodb

# 1. 設置指定 key 的值
SET key value 
'''
redis 127.0.0.1:6379> SET the_key "the_value"
OK
'''

# 2. 獲取指定 key 的值。
GET key
'''
不存在的key返回值爲nil
redis> GET db
(nil)
存在的key返回值爲value
redis> GET the_key
"the_value"
'''

# 3. 返回 key 中字符串值的子字符，相似於切片功能
GETRANGE key start end 
'''
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. 將給定 key 的值設爲 value ，並返回 key 的舊值.當 key 沒有舊值時，即 key 不存在時，返回 nil 。
GETSET key value
'''
redis> GETSET my_db my_mongodb    # 沒有舊值，返回 nil
(nil)

redis> GET my_db
"my_mongodb"
redis> GETSET my_db my_redis      # 返回舊值 mongodb
"my_mongodb"
redis> GET my_db
"my_redis"
'''

# 5. 對 key 所儲存的字符串值，獲取指定偏移量上的位(bit)。    
GETBIT key offset
'''
# 對不存在的 key 或者不存在的 offset 進行 GETBIT， 返回 0
redis> EXISTS bit
(integer) 0
redis> GETBIT bit 10086
(integer) 0

# 對已存在的 offset 進行 GETBIT
redis> SETBIT bit 10086 1
(integer) 0
redis> GETBIT bit 10086
(integer) 1
'''

# 6. 獲取全部(一個或多個)給定 key 的值。
MGET key1 [key2..]
'''
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)
'''

# 7. 對 key 所儲存的字符串值，設置或清除指定偏移量上的位(bit)。
SETBIT key offset value
'''
redis> SETBIT bit 10086 1
(integer) 0
redis> GETBIT bit 10086
(integer) 1
redis> GETBIT bit 100   # bit 默認被初始化爲 0
(integer) 0
'''

# 8. 將值 value 關聯到 key ，並將 key 的過時時間設爲 seconds (以秒爲單位)。
SETEX key seconds value
'''
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
'''

# 9. 只有在 key 不存在時設置 key 的值。    
SETNX key value
'''
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"
'''

# 10.用 value 參數覆寫給定 key 所儲存的字符串值，從偏移量 offset 開始。    
SETRANGE key offset value
'''
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"
'''

# 11.返回 key 所儲存的字符串值的長度。    
STRLEN key
'''
# 獲取字符串的長度
redis> SET mykey "Hello world"
OK
redis> STRLEN mykey
(integer) 11

# 不存在的 key 長度爲 0
redis> STRLEN nonexisting
(integer) 0
'''

# 12.同時設置一個或多個 key-value 對。    
MSET key value [key value ...]
'''
redis 127.0.0.1:6379> MSET key1 "Hello" key2 "World"
OK
redis 127.0.0.1:6379> GET key1
"Hello"
redis 127.0.0.1:6379> GET key2
"World"
'''

# 13.同時設置一個或多個 key-value 對，當且僅當全部給定 key 都不存在才成功。    
MSETNX key value [key value ...] 
'''
# 對不存在的 key 進行 MSETNX
redis> MSETNX rmdbs "MySQL" nosql "MongoDB" key-value-store "redis"
(integer) 1
redis> MGET rmdbs nosql key-value-store
1) "MySQL"
2) "MongoDB"
3) "redis"

# MSET 的給定 key 當中有已存在的 key
redis> MSETNX rmdbs "Sqlite" language "python"  # rmdbs 鍵已經存在，操做失敗
(integer) 0
redis> EXISTS language                          # 由於 MSET 是原子性操做，language 沒有被設置
(integer) 0
redis> GET rmdbs                                # rmdbs 也沒有被修改
"MySQL"
'''

# 14.這個命令和 SETEX 命令類似，但它以毫秒爲單位設置 key 的生存時間，而不是像 SETEX 命令那樣，以秒爲單位。
PSETEX key milliseconds value
'''
redis 127.0.0.1:6379> PSETEX mykey 1000 "Hello"
OK
redis 127.0.0.1:6379> PTTL mykey
999
redis 127.0.0.1:6379> GET mykey
"Hello"
'''

# 15.將 key 中儲存的數字值增一。    
INCR key
'''
redis> SET page_view 20
OK
redis> INCR page_view
(integer) 21
redis> GET page_view    # 數字值在 Redis 中以字符串的形式保存
"21"
'''

# 16.將 key 所儲存的值加上給定的增量值,key爲非數字時報錯
INCRBY key increment
'''
# key 存在且是數字值
redis> SET rank 50
OK
redis> INCRBY rank 20
(integer) 70
redis> GET rank
"70"

# key 不存在時
redis> EXISTS counter
(integer) 0
redis> INCRBY counter 30
(integer) 30
redis> GET counter
"30"

# key 不是數字值時
redis> SET book "long long ago..."
OK
redis> INCRBY book 200
(error) ERR value is not an integer or out of range
'''

# 17將 key 所儲存的值加上給定的浮點增量值（increment） 。    
INCRBYFLOAT key increment
'''
# 值和增量都不是指數符號
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"
'''

# 18.將 key 中儲存的數字值減一。    
DECR key
'''# 對存在的數字值 key 進行 DECR
redis> SET failure_times 10
OK
redis> DECR failure_times
(integer) 9

# 對不存在的 key 值進行 DECR
redis> EXISTS count
(integer) 0
redis> DECR count
(integer) -1

# 對存在但不是數值的 key 進行 DECR
redis> SET company YOUR_CODE_SUCKS.LLC
OK
redis> DECR company
(error) ERR value is not an integer or out of range
'''

# 19.key 所儲存的值減去給定的減量值（decrement） 。    
DECRBY key decrement
'''
# 對已存在的 key 進行 DECRBY
redis> SET count 100
OK
redis> DECRBY count 20
(integer) 80

# 對不存在的 key 進行DECRBY
redis> EXISTS pages
(integer) 0
redis> DECRBY pages 10
(integer) -10
'''

#20.若是 key 已經存在而且是一個字符串， APPEND 命令將指定的 value 追加到該 key 原來值（value）的末尾。
APPEND 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"
'''

redis字符串基本操做

Hash（哈希）

　　Redis hash 是一個鍵值(key=>value)對集合。數組

　　Redis hash 是一個 string 類型的 field 和 value 的映射表，hash 特別適合用於存儲對象。安全

實例nosql

redis> HMSET myhash field1 "Hello" field2 "World""OK"
redis> HGET myhash field1
"Hello"
redis> HGET myhash field2
"World"

實例中使用了 Redis HMSET, HGET 命令，HMSET 設置了兩個 field=>value 對, HGET 獲取對應 field 對應的 value。

每一個 hash 能夠存儲 2³² -1 鍵值對（40多億）。

# 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. 查看哈希表 key 中，指定的字段是否存在。    
HEXISTS key field 
'''
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.獲取在哈希表中指定 key 的全部字段和值    
HGETALL 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.爲哈希表 key 中的指定字段的整數值加上增量 increment 。    
HINCRBY key field increment 
'''
redis> HSET myhash field 5
(integer) 1
redis> HINCRBY myhash field 1
(integer) 6
redis> HINCRBY myhash field -1
(integer) 5
redis> HINCRBY myhash field -10
(integer) -5
redis> 
'''

# 6.爲哈希表 key 中的指定字段的浮點數值加上增量 increment 。    
HINCRBYFLOAT key field increment 
'''
redis> HSET mykey field 10.50
(integer) 1
redis> HINCRBYFLOAT mykey field 0.1
"10.60000000000000001"
redis> HINCRBYFLOAT mykey field -5
"5.59999999999999964"
redis> HSET mykey field 5.0e3
(integer) 0
redis> HINCRBYFLOAT mykey field 2.0e2
"5200"
'''

# 7.獲取全部哈希表中的字段    
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"
'''

# 8.獲取哈希表中字段的數量    
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
'''

# 9.獲取全部給定字段的值
HMGET key field1 [field2] 
'''
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)
'''

# 10.同時將多個 field-value (域-值)對設置到哈希表 key 中。
HMSET key field1 value1 [field2 value2 ] 
'''
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"
'''

# 11.將哈希表 key 中的字段 field 的值設爲 value 。
HSET 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
'''

# 12.只有在字段 field 不存在時，設置哈希表字段的值。
HSETNX key field value 
'''
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"
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
'''

# 13.獲取哈希表中全部值
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)
'''

# 14.迭代哈希表中的鍵值對。
HSCAN key cursor [MATCH pattern] [COUNT count]

redis 哈希基本操做

List（列表）

　　Redis 列表是簡單的字符串列表，按照插入順序排序。你能夠添加一個元素到列表的頭部（左邊）或者尾部（右邊）。

實例

redis 127.0.0.1:6379> lpush runoob redis
(integer)1
redis 127.0.0.1:6379> lpush runoob mongodb
(integer)2
redis 127.0.0.1:6379> lpush runoob rabitmq
(integer)3
redis 127.0.0.1:6379> lrange runoob 0101)"rabitmq"2)"mongodb"3)"redis"
redis 127.0.0.1:6379>

　　列表最多可存儲 2³² - 1 元素 (4294967295, 每一個列表可存儲40多億)。

# 1.移出並獲取列表的第一個元素， 若是列表沒有元素會阻塞列表直到等待超時或發現可彈出元素爲止。
BLPOP key1 [key2 ] timeout 
'''
redis 127.0.0.1:6379> BLPOP list1 100
操做會被阻塞，若是指定的列表 key list1 存在數據則會返回第一個元素，不然在等待100秒後會返回 nil 。
(nil)
(100.06s)
'''

# 2.移出並獲取列表的最後一個元素， 若是列表沒有元素會阻塞列表直到等待超時或發現可彈出元素爲止。
BRPOP key1 [key2 ] timeout 
'''
操做同上
'''

# 3.從列表中彈出一個值，將彈出的元素插入到另一個列表中並返回它； 若是列表沒有元素會阻塞列表直到等待超時或發現可彈出元素爲止。
BRPOPLPUSH source destination timeout 
'''
# 非空列表
redis> BRPOPLPUSH msg reciver 500
"hello moto"                        # 彈出元素的值
(3.38s)                             # 等待時長
redis> LLEN reciver
(integer) 1
redis> LRANGE reciver 0 0
1) "hello moto"

# 空列表
redis> BRPOPLPUSH msg reciver 1
(nil)
(1.34s)
'''

# 4.經過索引獲取列表中的元素
LINDEX key index 
'''
redis 127.0.0.1:6379> LPUSH mylist "World"
(integer) 1
redis 127.0.0.1:6379> LPUSH mylist "Hello"
(integer) 2
redis 127.0.0.1:6379> LINDEX mylist 0
"Hello"
redis 127.0.0.1:6379> LINDEX mylist -1
"World"
redis 127.0.0.1:6379> LINDEX mylist 3        # index不在 mylist 的區間範圍內
(nil)
'''

# 5.在列表的元素前或者後插入元素
LINSERT key BEFORE|AFTER pivot value 
'''
若是命令執行成功，返回插入操做完成以後，列表的長度。 若是沒有找到指定元素 ，返回 -1 。 若是 key 不存在或爲空列表，返回 0 。
redis> RPUSH mylist "Hello"
(integer) 1
redis> RPUSH mylist "World"
(integer) 2
redis> LINSERT mylist BEFORE "World" "There"
(integer) 3
redis> LRANGE mylist 0 -1
1) "Hello"
2) "There"
3) "World"
'''

# 6.獲取列表長度
LLEN key 
'''
redis 127.0.0.1:6379> RPUSH list1 "foo"
(integer) 1
redis 127.0.0.1:6379> RPUSH list1 "bar"
(integer) 2
redis 127.0.0.1:6379> LLEN list1
(integer) 2
'''

# 7.移出並獲取列表的第一個元素，當列表 key 不存在時，返回 nil 。
LPOP key 
'''
redis 127.0.0.1:6379> RPUSH list1 "foo"
(integer) 1
redis 127.0.0.1:6379> RPUSH list1 "bar"
(integer) 2
redis 127.0.0.1:6379> LPOP list1
"foo"
'''

# 8.將一個或多個值插入到列表頭部
LPUSH key value1 [value2] 
'''
執行 LPUSH 命令後，返回值是列表的長度。
127.0.0.1:6379> LPUSH list1 "foo"
(integer) 1
127.0.0.1:6379> LPUSH list1 "bar"
(integer) 2
127.0.0.1:6379> LRANGE list1 0 -1
1) "bar"
2) "foo"
'''

# 9.將一個值插入到已存在的列表頭部
LPUSHX key value 
'''
127.0.0.1:6379> LPUSH list1 "foo"
(integer) 1
127.0.0.1:6379> LPUSHX list1 "bar"
(integer) 2
127.0.0.1:6379> LPUSHX list2 "bar"
(integer) 0
127.0.0.1:6379> LRANGE list1 0 -1
1) "bar"
2) "foo"
'''

# 10.獲取列表指定範圍內的元素
LRANGE key start stop 
'''
redis> RPUSH mylist "one"
(integer) 1
redis> RPUSH mylist "two"
(integer) 2
redis> RPUSH mylist "three"
(integer) 3
redis> LRANGE mylist 0 0
1) "one"
redis> LRANGE mylist -3 2
1) "one"
2) "two"
3) "three"
redis> LRANGE mylist -100 100
1) "one"
2) "two"
3) "three"
redis> LRANGE mylist 5 10
(empty list or set)
'''

# 11.移除列表元素
LREM key count value 
'''
redis> RPUSH mylist "hello"
(integer) 1
redis> RPUSH mylist "hello"
(integer) 2
redis> RPUSH mylist "foo"
(integer) 3
redis> RPUSH mylist "hello"
(integer) 4
redis> LREM mylist -2 "hello"
(integer) 2
redis> LRANGE mylist 0 -1
1) "hello"
2) "foo"
'''

# 12.經過索引設置列表元素的值
LSET key index value 
'''
redis 127.0.0.1:6379> RPUSH mylist "hello"
(integer) 1
redis 127.0.0.1:6379> RPUSH mylist "hello"
(integer) 2
redis 127.0.0.1:6379> RPUSH mylist "foo"
(integer) 3
redis 127.0.0.1:6379> RPUSH mylist "hello"
(integer) 4
redis 127.0.0.1:6379> LSET mylist 0 "bar"
OK
redis 127.0.0.1:6379> LRANGE mylist 0 -1
1: "bar"
2) "hello"
3) "foo"
4) "hello"
'''

# 13.對一個列表進行修剪(trim)，就是說，讓列表只保留指定區間內的元素，不在指定區間以內的元素都將被刪除。
LTRIM key start stop 
'''
redis 127.0.0.1:6379> RPUSH mylist "hello"
(integer) 1
redis 127.0.0.1:6379> RPUSH mylist "hello"
(integer) 2
redis 127.0.0.1:6379> RPUSH mylist "foo"
(integer) 3
redis 127.0.0.1:6379> RPUSH mylist "bar"
(integer) 4
redis 127.0.0.1:6379> LTRIM mylist 1 -1
OK
redis 127.0.0.1:6379> LRANGE mylist 0 -1
1) "hello"
2) "foo"
3) "bar"
'''

# 14.移除並獲取列表最後一個元素
RPOP key 
'''
redis> RPUSH mylist "one"
(integer) 1
redis> RPUSH mylist "two"
(integer) 2
redis> RPUSH mylist "three"
(integer) 3
redis> RPOP mylist
"three"
redis> LRANGE mylist 0 -1
1) "one"
2) "two"
'''

# 15.移除列表的最後一個元素，並將該元素添加到另外一個列表並返回
RPOPLPUSH source destination 
'''
redis 127.0.0.1:6379> RPUSH mylist "hello"
(integer) 1
redis 127.0.0.1:6379> RPUSH mylist "foo"
(integer) 2
redis 127.0.0.1:6379> RPUSH mylist "bar"
(integer) 3
redis 127.0.0.1:6379> RPOPLPUSH mylist myotherlist
"bar"
redis 127.0.0.1:6379> LRANGE mylist 0 -1
1) "hello"
2) "foo"
'''

# 16在列表中添加一個或多個值
RPUSH key value1 [value2] 
'''
redis 127.0.0.1:6379> RPUSH mylist "hello"
(integer) 1
redis 127.0.0.1:6379> RPUSH mylist "foo"
(integer) 2
redis 127.0.0.1:6379> RPUSH mylist "bar"
(integer) 3
redis 127.0.0.1:6379> LRANGE mylist 0 -1
1) "hello"
2) "foo"
3) "bar"
'''

#17.爲已存在的列表添加值
RPUSHX key value 
'''
redis 127.0.0.1:6379> RPUSH mylist "hello"
(integer) 1
redis 127.0.0.1:6379> RPUSH mylist "foo"
(integer) 2
redis 127.0.0.1:6379> RPUSHX mylist2 "bar"
(integer) 0
redis 127.0.0.1:6379> LRANGE mylist 0 -1
1) "hello"
2) "foo"
'''

redis 列表基本操做

redis 列表基本操做

Set（集合）

　　Redis的Set是string類型的無序集合。

　　集合是經過哈希表實現的，因此添加，刪除，查找的複雜度都是O(1)。

sadd 命令

添加一個 string 元素到 key 對應的 set 集合中，成功返回1，若是元素已經在集合中返回 0，若是 key 對應的 set 不存在則返回錯誤。

sadd key member

實例

redis 127.0.0.1:6379> sadd runoob redis
(integer)1
redis 127.0.0.1:6379> sadd runoob mongodb
(integer)1
redis 127.0.0.1:6379> sadd runoob rabitmq
(integer)1
redis 127.0.0.1:6379> sadd runoob rabitmq
(integer)0
redis 127.0.0.1:6379> smembers runoob

1)"redis"2)"rabitmq"3)"mongodb"

注意：以上實例中 rabitmq 添加了兩次，但根據集合內元素的惟一性，第二次插入的元素將被忽略。

集合中最大的成員數爲 2³² - 1(4294967295, 每一個集合可存儲40多億個成員)。

# 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 
'''
返回值:集合的數量。 當集合 key 不存在時，返回 0 。
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> SCARD myset
(integer) 2
'''

# 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"
'''

# 4.返回給定全部集合的差集並存儲在 destination 中
SDIFFSTORE destination key1 [key2] 
'''
返回值:結果集中的元素數量。
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] 
'''
返回值:交集成員的列表。
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> SINTER myset myset2
"hello"
'''

# 6.返回給定全部集合的交集並存儲在 destination 中
SINTERSTORE destination key1 [key2] 
'''
返回值:返回存儲交集的集合的元素數量。
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
"hello"
'''

# 7.判斷 member 元素是不是集合 key 的成員
SISMEMBER key member 
'''
返回值:若是成員元素是集合的成員，返回 1 。 若是成員元素不是集合的成員，或 key 不存在，返回 0 。
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"
'''
返回值:若是成員元素被成功移除，返回 1 。 若是成員元素不是 source 集合的成員，而且沒有任何操做對 destination 集合執行，那麼返回 0 。
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"
'''

# 9.將 member 元素從 source 集合移動到 destination 集合
SMOVE source destination member 
'''
返回值:若是成員元素被成功移除，返回 1 。 若是成員元素不是 source 集合的成員，而且沒有任何操做對 destination 集合執行，那麼返回 0 。
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 
'''
返回:被移除的隨機元素。 當集合不存在或是空集時，返回 nil 。
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> SPOP myset1
"bar"
redis 127.0.0.1:6379> SMEMBERS myset1
1) "Hello"
2) "world"
'''

# 11.返回集合中一個或多個隨機數
SRANDMEMBER key [count] 
'''
返回值:只提供集合 key 參數時，返回一個元素；若是集合爲空，返回 nil 。 若是提供了 count 參數，那麼返回一個數組；若是集合爲空，返回空數組。
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> SRANDMEMBER myset1
"bar"
redis 127.0.0.1:6379> SRANDMEMBER myset1 2
1) "Hello"
2) "world"
'''

# 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] 
'''
返回值:並集成員的列表。
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> SUNION key1 key2
1) "a"
2) "c"
3) "b"
4) "e"
5) "d"
'''

# 14.全部給定集合的並集存儲在 destination 集合中
SUNIONSTORE destination key1 [key2] 
'''
返回值:結果集中的元素數量。
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 "hello"
(integer) 1
redis 127.0.0.1:6379> SADD myset2 "bar"
(integer) 1
redis 127.0.0.1:6379> SUNIONSTORE myset myset1 myset2
(integer) 1
redis 127.0.0.1:6379> SMEMBERS myset
1) "bar"
2) "world"
3) "hello"
4) "foo"
'''

# 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"
'''

redis set基本操做

zset(sorted set：有序集合)

　　Redis zset 和 set 同樣也是string類型元素的集合,且不容許重複的成員。不一樣的是每一個元素都會關聯一個double類型的分數。redis正是經過分數來爲集合中的成員進行從小到大的排序。zset的成員是惟一的,但分數(score)卻能夠重複。

zadd 命令

　　添加元素到集合，元素在集合中存在則更新對應score

zadd key score member

實例

redis 127.0.0.1:6379> zadd runoob 0 redis
(integer)1
redis 127.0.0.1:6379> zadd runoob 0 mongodb
(integer)1
redis 127.0.0.1:6379> zadd runoob 0 rabitmq
(integer)1
redis 127.0.0.1:6379> zadd runoob 0 rabitmq
(integer)0
redis 127.0.0.1:6379>> ZRANGEBYSCORE runoob 010001)"mongodb"2)"rabitmq"3)"redis"

# 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"
'''

# 2.獲取有序集合的成員數
ZCARD key 
'''
返回值:當 key 存在且是有序集類型時，返回有序集的基數。 當 key 不存在時，返回 0 。
redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZCARD myzset
(integer) 2
'''

# 3.計算在有序集合中指定區間分數的成員數
ZCOUNT key min max 
'''
返回值:分數值在 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.有序集合中對指定成員的分數加上增量 increment
ZINCRBY key increment member 
'''
返回值: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.計算給定的一個或多個有序集的交集並將結果集存儲在新的有序集合 key 中
ZINTERSTORE destination numkeys key [key ...] 
'''
返回值:保存到目標結果集的的成員數量。
# 有序集 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"
'''

# 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 
'''
返回值:若是成員是有序集 key 的成員，返回 member 的排名。 若是成員不是有序集 key 的成員，返回 nil 。
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"
'''

# 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 
'''
返回值:若是成員是有序集 key 的成員，返回成員的排名。 若是成員不是有序集 key 的成員，返回 nil 。
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.計算給定的一個或多個有序集的並集，並存儲在新的 key 中
ZUNIONSTORE destination numkeys key [key ...] 
'''
返回值:保存到 destination 的結果集的成員數量。
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] 
'''
返回值:
返回的每一個元素都是一個有序集合元素，一個有序集合元素由一個成員（member）和一個分值（score）組成。
'''