redis命令簡明示例

一、string命令示例：
1. SET/GET/APPEND/STRLEN:
/> redis-cli #執行Redis客戶端工具。
redis 127.0.0.1:6379> exists mykey #判斷該鍵是否存在，存在返回1，否則返回0。
(integer) 0
redis 127.0.0.1:6379> append mykey “hello” #該鍵並不存在，因此append命令返回當前Value的長度。
(integer) 5
redis 127.0.0.1:6379> append mykey ” world” #該鍵已經存在，因此返回追加後Value的長度。
(integer) 11
redis 127.0.0.1:6379> get mykey #通過get命令獲取該鍵，以判斷append的結果。
“hello world”
redis 127.0.0.1:6379> set mykey “this is a test” #通過set命令爲鍵設置新值，並覆蓋原有值。
OK
redis 127.0.0.1:6379> get mykey
“this is a test”
redis 127.0.0.1:6379> strlen mykey #獲取指定Key的字符長度，等效於C庫中strlen函數。
(integer) 14

2. INCR/DECR/INCRBY/DECRBY:
redis 127.0.0.1:6379> set mykey 20     #設置Key的值爲20
OK
redis 127.0.0.1:6379> incr mykey         #該Key的值遞增1
(integer) 21
redis 127.0.0.1:6379> decr mykey        #該Key的值遞減1
(integer) 20
redis 127.0.0.1:6379> del mykey          #刪除已有鍵。
(integer) 1
redis 127.0.0.1:6379> decr mykey        #對空值執行遞減操作，其原值被設定爲0，遞減後的值爲-1
(integer) -1
redis 127.0.0.1:6379> del mykey   
(integer) 1
redis 127.0.0.1:6379> incr mykey        #對空值執行遞增操作，其原值被設定爲0，遞增後的值爲1
(integer) 1
redis 127.0.0.1:6379> set mykey hello #將該鍵的Value設置爲不能轉換爲整型的普通字符串。
OK
redis 127.0.0.1:6379> incr mykey        #在該鍵上再次執行遞增操作時，Redis將報告錯誤信息。
(error) ERR value is not an integer or out of range
redis 127.0.0.1:6379> set mykey 10
OK
redis 127.0.0.1:6379> decrby mykey 5 
(integer) 5
redis 127.0.0.1:6379> incrby mykey 10
(integer) 15

3. GETSET：
redis 127.0.0.1:6379> incr mycounter      #將計數器的值原子性的遞增1
(integer) 1
#在獲取計數器原有值的同時，並將其設置爲新值，這兩個操作原子性的同時完成。
redis 127.0.0.1:6379> getset mycounter 0  
"1"
redis 127.0.0.1:6379> get mycounter       #查看設置後的結果。
"0"

4. SETEX:
redis 127.0.0.1:6379> setex mykey 10 "hello"   #設置指定Key的過期時間爲10秒。
OK    
#通過ttl命令查看一下指定Key的剩餘存活時間(秒數)，0表示已經過期，-1表示永不過期。
redis 127.0.0.1:6379> ttl mykey                       
(integer) 4
redis 127.0.0.1:6379> get mykey                      #在該鍵的存活期內我們仍然可以獲取到它的Value。
"hello"
redis 127.0.0.1:6379> ttl mykey                        #該ttl命令的返回值顯示，該Key已經過期。
(integer) 0
redis 127.0.0.1:6379> get mykey                      #獲取已過期的Key將返回nil。
(nil)

1. SETNX:
   redis 127.0.0.1:6379> del mykey #刪除該鍵，以便於下面的測試驗證。
   (integer) 1
   redis 127.0.0.1:6379> setnx mykey “hello” #該鍵並不存在，因此該命令執行成功。
   (integer) 1
   redis 127.0.0.1:6379> setnx mykey “world” #該鍵已經存在，因此本次設置沒有產生任何效果。
   (integer) 0
   redis 127.0.0.1:6379> get mykey #從結果可以看出，返回的值仍爲第一次設置的值。
   “hello”

   1. SETRANGE/GETRANGE:
      redis 127.0.0.1:6379> set mykey “hello world” #設定初始值。
      OK
      redis 127.0.0.1:6379> setrange mykey 6 dd #從第六個字節開始替換2個字節(dd只有2個字節)
      (integer) 11
      redis 127.0.0.1:6379> get mykey #查看替換後的值。
      “hello ddrld”
      redis 127.0.0.1:6379> setrange mykey 20 dd #offset已經超過該Key原有值的長度了，該命令將會在末尾補0。
      (integer) 22
      redis 127.0.0.1:6379> get mykey #查看補0後替換的結果。
      “hello ddrld\x00\x00\x00\x00\x00\x00\x00\x00\x00dd”
      redis 127.0.0.1:6379> del mykey #刪除該Key。
      (integer) 1
      redis 127.0.0.1:6379> setrange mykey 2 dd #替換空值。
      (integer) 4
      redis 127.0.0.1:6379> get mykey #查看替換空值後的結果。
      “\x00\x00dd”
      redis 127.0.0.1:6379> set mykey “0123456789” #設置新值。
      OK
      redis 127.0.0.1:6379> getrange mykey 1 2 #截取該鍵的Value，從第一個字節開始，到第二個字節結束。
      “12”
      redis 127.0.0.1:6379> getrange mykey 1 20 #20已經超過Value的總長度，因此將截取第一個字節後面的所有字節。
      “123456789”

   2. SETBIT/GETBIT:
      redis 127.0.0.1:6379> del mykey
      (integer) 1
      redis 127.0.0.1:6379> setbit mykey 7 1 #設置從0開始計算的第七位BIT值爲1，返回原有BIT值0
      (integer) 0
      redis 127.0.0.1:6379> get mykey #獲取設置的結果，二進制的0000 0001的十六進制值爲0x01
      “\x01”
      redis 127.0.0.1:6379> setbit mykey 6 1 #設置從0開始計算的第六位BIT值爲1，返回原有BIT值0
      (integer) 0
      redis 127.0.0.1:6379> get mykey #獲取設置的結果，二進制的0000 0011的十六進制值爲0x03
      “\x03”
      redis 127.0.0.1:6379> getbit mykey 6 #返回了指定Offset的BIT值。
      (integer) 1
      redis 127.0.0.1:6379> getbit mykey 10 #Offset已經超出了value的長度，因此返回0。
      (integer) 0

2. MSET/MGET/MSETNX:
   redis 127.0.0.1:6379> mset key1 “hello” key2 “world” #批量設置了key1和key2兩個鍵。
   OK
   redis 127.0.0.1:6379> mget key1 key2 #批量獲取了key1和key2兩個鍵的值。
   1) “hello”
   2) “world”

   批量設置了key3和key4兩個鍵，因爲之前他們並不存在，所以該命令執行成功並返回1。

   redis 127.0.0.1:6379> msetnx key3 “stephen” key4 “liu”
   (integer) 1
   redis 127.0.0.1:6379> mget key3 key4
   1) “stephen”
   2) “liu”

   批量設置了key3和key5兩個鍵，但是key3已經存在，所以該命令執行失敗並返回0。

   redis 127.0.0.1:6379> msetnx key3 “hello” key5 “world”
   (integer) 0

   批量獲取key3和key5，由於key5沒有設置成功，所以返回nil。

   redis 127.0.0.1:6379> mget key3 key5
   1) “stephen”
   2) (nil)

二、list命令示例：

1. LPUSH/LPUSHX/LRANGE:
/> redis-cli    #在Shell提示符下啓動redis客戶端工具。
redis 127.0.0.1:6379> del mykey
(integer) 1
#mykey鍵並不存在，該命令會創建該鍵及與其關聯的List，之後在將參數中的values從左到右依次插入。
redis 127.0.0.1:6379> lpush mykey a b c d
(integer) 4
#取從位置0開始到位置2結束的3個元素。
redis 127.0.0.1:6379> lrange mykey 0 2
1) "d"
2) "c"
3) "b"
#取鏈表中的全部元素，其中0表示第一個元素，-1表示最後一個元素。
redis 127.0.0.1:6379> lrange mykey 0 -1
1) "d"
2) "c"
3) "b"
4) "a"
#mykey2鍵此時並不存在，因此該命令將不會進行任何操作，其返回值爲0。
redis 127.0.0.1:6379> lpushx mykey2 e
(integer) 0
#可以看到mykey2沒有關聯任何List Value。
redis 127.0.0.1:6379> lrange mykey2 0 -1
(empty list or set)
#mykey鍵此時已經存在，所以該命令插入成功，並返回鏈表中當前元素的數量。
redis 127.0.0.1:6379> lpushx mykey e
(integer) 5
#獲取該鍵的List Value的頭部元素。
redis 127.0.0.1:6379> lrange mykey 0 0
1) "e"

2. LPOP/LLEN:
redis 127.0.0.1:6379> lpush mykey a b c d
(integer) 4
redis 127.0.0.1:6379> lpop mykey
"d"
redis 127.0.0.1:6379> lpop mykey
"c"
#在執行lpop命令兩次後，鏈表頭部的兩個元素已經被彈出，此時鏈表中元素的數量是2
redis 127.0.0.1:6379> llen mykey
(integer) 2

1. LREM/LSET/LINDEX/LTRIM:

   爲後面的示例準備測試數據。

   redis 127.0.0.1:6379> lpush mykey a b c d a c
   (integer) 6

   從頭部(left)向尾部(right)變量鏈表，刪除2個值等於a的元素，返回值爲實際刪除的數量。

   redis 127.0.0.1:6379> lrem mykey 2 a
   (integer) 2

   看出刪除後鏈表中的全部元素。

   redis 127.0.0.1:6379> lrange mykey 0 -1
   1) “c”
   2) “d”
   3) “c”
   4) “b”

   獲取索引值爲1(頭部的第二個元素)的元素值。

   redis 127.0.0.1:6379> lindex mykey 1
   “d”

   將索引值爲1(頭部的第二個元素)的元素值設置爲新值e。

   redis 127.0.0.1:6379> lset mykey 1 e
   OK

   查看是否設置成功。

   redis 127.0.0.1:6379> lindex mykey 1
   “e”

   索引值6超過了鏈表中元素的數量，該命令返回nil。

   redis 127.0.0.1:6379> lindex mykey 6
   (nil)

   設置的索引值6超過了鏈表中元素的數量，設置失敗，該命令返回錯誤信息。

   redis 127.0.0.1:6379> lset mykey 6 hh
   (error) ERR index out of range

   僅保留索引值0到2之間的3個元素，注意第0個和第2個元素均被保留。

   redis 127.0.0.1:6379> ltrim mykey 0 2
   OK

   查看trim後的結果。

   redis 127.0.0.1:6379> lrange mykey 0 -1
   1) “c”
   2) “e”
   3) “c”

   1. LINSERT:

   刪除該鍵便於後面的測試。

   redis 127.0.0.1:6379> del mykey
   (integer) 1

   爲後面的示例準備測試數據。

   redis 127.0.0.1:6379> lpush mykey a b c d e
   (integer) 5

   在a的前面插入新元素a1。

   redis 127.0.0.1:6379> linsert mykey before a a1
   (integer) 6

   查看是否插入成功，從結果看已經插入。注意lindex的index值是0-based。

   redis 127.0.0.1:6379> lindex mykey 0
   “e”

   在e的後面插入新元素e2，從返回結果看已經插入成功。

   redis 127.0.0.1:6379> linsert mykey after e e2
   (integer) 7

   再次查看是否插入成功。

   redis 127.0.0.1:6379> lindex mykey 1
   “e2”

   在不存在的元素之前或之後插入新元素，該命令操作失敗，並返回-1。

   redis 127.0.0.1:6379> linsert mykey after k a
   (integer) -1

   爲不存在的Key插入新元素，該命令操作失敗，返回0。

   redis 127.0.0.1:6379> linsert mykey1 after a a2
   (integer) 0

   1. RPUSH/RPUSHX/RPOP/RPOPLPUSH:

   刪除該鍵，以便於後面的測試。

   redis 127.0.0.1:6379> del mykey
   (integer) 1

   從鏈表的尾部插入參數中給出的values，插入順序是從左到右依次插入。

   redis 127.0.0.1:6379> rpush mykey a b c d
   (integer) 4

   通過lrange的可以獲悉rpush在插入多值時的插入順序。

   redis 127.0.0.1:6379> lrange mykey 0 -1
   1) “a”
   2) “b”
   3) “c”
   4) “d”

   該鍵已經存在並且包含4個元素，rpushx命令將執行成功，並將元素e插入到鏈表的尾部。

   redis 127.0.0.1:6379> rpushx mykey e
   (integer) 5

   通過lindex命令可以看出之前的rpushx命令確實執行成功，因爲索引值爲4的元素已經是新元素了。

   redis 127.0.0.1:6379> lindex mykey 4
   “e”

   由於mykey2鍵並不存在，因此該命令不會插入數據，其返回值爲0。

   redis 127.0.0.1:6379> rpushx mykey2 e
   (integer) 0

   在執行rpoplpush命令前，先看一下mykey中鏈表的元素有哪些，注意他們的位置關係。

   redis 127.0.0.1:6379> lrange mykey 0 -1
   1) “a”
   2) “b”
   3) “c”
   4) “d”
   5) “e”

   將mykey的尾部元素e彈出，同時再插入到mykey2的頭部(原子性的完成這兩步操作)。

   redis 127.0.0.1:6379> rpoplpush mykey mykey2
   “e”

   通過lrange命令查看mykey在彈出尾部元素後的結果。

   redis 127.0.0.1:6379> lrange mykey 0 -1
   1) “a”
   2) “b”
   3) “c”
   4) “d”

   通過lrange命令查看mykey2在插入元素後的結果。

   redis 127.0.0.1:6379> lrange mykey2 0 -1
   1) “e”

   將source和destination設爲同一鍵，將mykey中的尾部元素移到其頭部。

   redis 127.0.0.1:6379> rpoplpush mykey mykey
   “d”

   查看移動結果。

   redis 127.0.0.1:6379> lrange mykey 0 -1
   1) “d”
   2) “a”
   3) “b”
   4) “c”

三、set命令示例：

1. SADD/SMEMBERS/SCARD/SISMEMBER:

   在Shell命令行下啓動Redis的客戶端程序。

   /> redis-cli

   插入測試數據，由於該鍵myset之前並不存在，因此參數中的三個成員都被正常插入。

   redis 127.0.0.1:6379> sadd myset a b c
   (integer) 3

   由於參數中的a在myset中已經存在，因此本次操作僅僅插入了d和e兩個新成員。

   redis 127.0.0.1:6379> sadd myset a d e
   (integer) 2

   判斷a是否已經存在，返回值爲1表示存在。

   redis 127.0.0.1:6379> sismember myset a
   (integer) 1

   判斷f是否已經存在，返回值爲0表示不存在。

   redis 127.0.0.1:6379> sismember myset f
   (integer) 0

   通過smembers命令查看插入的結果，從結果可以，輸出的順序和插入順序無關。

   redis 127.0.0.1:6379> smembers myset
   1) “c”
   2) “d”
   3) “a”
   4) “b”
   5) “e”

   獲取Set集合中元素的數量。

   redis 127.0.0.1:6379> scard myset
   (integer) 5

   1. SPOP/SREM/SRANDMEMBER/SMOVE:

   刪除該鍵，便於後面的測試。

   redis 127.0.0.1:6379> del myset
   (integer) 1

   爲後面的示例準備測試數據。

   redis 127.0.0.1:6379> sadd myset a b c d
   (integer) 4

   查看Set中成員的位置。

   redis 127.0.0.1:6379> smembers myset
   1) “c”
   2) “d”
   3) “a”
   4) “b”

   從結果可以看出，該命令確實是隨機的返回了某一成員。

   redis 127.0.0.1:6379> srandmember myset
   “c”

   Set中尾部的成員b被移出並返回，事實上b並不是之前插入的第一個或最後一個成員。

   redis 127.0.0.1:6379> spop myset
   “b”

   查看移出後Set的成員信息。

   redis 127.0.0.1:6379> smembers myset
   1) “c”
   2) “d”
   3) “a”

   從Set中移出a、d和f三個成員，其中f並不存在，因此只有a和d兩個成員被移出，返回爲2。

   redis 127.0.0.1:6379> srem myset a d f
   (integer) 2

   查看移出後的輸出結果。

   redis 127.0.0.1:6379> smembers myset
   1) “c”

   爲後面的smove命令準備數據。

   redis 127.0.0.1:6379> sadd myset a b
   (integer) 2
   redis 127.0.0.1:6379> sadd myset2 c d
   (integer) 2

   將a從myset移到myset2，從結果可以看出移動成功。

   redis 127.0.0.1:6379> smove myset myset2 a
   (integer) 1

   再次將a從myset移到myset2，由於此時a已經不是myset的成員了，因此移動失敗並返回0。

   redis 127.0.0.1:6379> smove myset myset2 a
   (integer) 0

   分別查看myset和myset2的成員，確認移動是否真的成功。

   redis 127.0.0.1:6379> smembers myset
   1) “b”
   redis 127.0.0.1:6379> smembers myset2
   1) “c”
   2) “d”
   3) “a”

2. SDIFF/SDIFFSTORE/SINTER/SINTERSTORE:

   爲後面的命令準備測試數據。

   redis 127.0.0.1:6379> sadd myset a b c d
   (integer) 4
   redis 127.0.0.1:6379> sadd myset2 c
   (integer) 1
   redis 127.0.0.1:6379> sadd myset3 a c e
   (integer) 3

   myset和myset2相比，a、b和d三個成員是兩者之間的差異成員。再用這個結果繼續和myset3進行差異比較，b和d是myset3不存在的成員。

   redis 127.0.0.1:6379> sdiff myset myset2 myset3
   1) “d”
   2) “b”

   將3個集合的差異成員存在在diffkey關聯的Set中，並返回插入的成員數量。

   redis 127.0.0.1:6379> sdiffstore diffkey myset myset2 myset3
   (integer) 2

   查看一下sdiffstore的操作結果。

   redis 127.0.0.1:6379> smembers diffkey
   1) “d”
   2) “b”

   從之前準備的數據就可以看出，這三個Set的成員交集只有c。

   redis 127.0.0.1:6379> sinter myset myset2 myset3
   1) “c”

   將3個集合中的交集成員存儲到與interkey關聯的Set中，並返回交集成員的數量。

   redis 127.0.0.1:6379> sinterstore interkey myset myset2 myset3
   (integer) 1

   查看一下sinterstore的操作結果。

   redis 127.0.0.1:6379> smembers interkey
   1) “c”

   獲取3個集合中的成員的並集。

   redis 127.0.0.1:6379> sunion myset myset2 myset3
   1) “b”
   2) “c”
   3) “d”
   4) “e”
   5) “a”

   將3個集合中成員的並集存儲到unionkey關聯的set中，並返回並集成員的數量。

   redis 127.0.0.1:6379> sunionstore unionkey myset myset2 myset3
   (integer) 5

   查看一下suiionstore的操作結果。

   redis 127.0.0.1:6379> smembers unionkey
   1) “b”
   2) “c”
   3) “d”
   4) “e”
   5) “a”

四、hashmap命令示例：

1. HSET/HGET/HDEL/HEXISTS/HLEN/HSETNX:
#在Shell命令行啓動Redis客戶端程序
/> redis-cli
#給鍵值爲myhash的鍵設置字段爲field1，值爲stephen。
redis 127.0.0.1:6379> hset myhash field1 "stephen"
(integer) 1
#獲取鍵值爲myhash，字段爲field1的值。
redis 127.0.0.1:6379> hget myhash field1
"stephen"
#myhash鍵中不存在field2字段，因此返回nil。
redis 127.0.0.1:6379> hget myhash field2
(nil)
#給myhash關聯的Hashes值添加一個新的字段field2，其值爲liu。
redis 127.0.0.1:6379> hset myhash field2 "liu"
(integer) 1
#獲取myhash鍵的字段數量。
redis 127.0.0.1:6379> hlen myhash
(integer) 2
#判斷myhash鍵中是否存在字段名爲field1的字段，由於存在，返回值爲1。
redis 127.0.0.1:6379> hexists myhash field1
(integer) 1
#刪除myhash鍵中字段名爲field1的字段，刪除成功返回1。
redis 127.0.0.1:6379> hdel myhash field1
(integer) 1
#再次刪除myhash鍵中字段名爲field1的字段，由於上一條命令已經將其刪除，因爲沒有刪除，返回0。
redis 127.0.0.1:6379> hdel myhash field1
(integer) 0
#判斷myhash鍵中是否存在field1字段，由於上一條命令已經將其刪除，因爲返回0。
redis 127.0.0.1:6379> hexists myhash field1
(integer) 0
#通過hsetnx命令給myhash添加新字段field1，其值爲stephen，因爲該字段已經被刪除，所以該命令添加成功並返回1。
redis 127.0.0.1:6379> hsetnx myhash field1 stephen
(integer) 1
#由於myhash的field1字段已經通過上一條命令添加成功，因爲本條命令不做任何操作後返回0。
redis 127.0.0.1:6379> hsetnx myhash field1 stephen
(integer) 0

1. HINCRBY：

   刪除該鍵，便於後面示例的測試。

   redis 127.0.0.1:6379> del myhash
   (integer) 1

   準備測試數據，該myhash的field字段設定值1。

   redis 127.0.0.1:6379> hset myhash field 5
   (integer) 1

   給myhash的field字段的值加1，返回加後的結果。

   redis 127.0.0.1:6379> hincrby myhash field 1
   (integer) 6

   給myhash的field字段的值加-1，返回加後的結果。

   redis 127.0.0.1:6379> hincrby myhash field -1
   (integer) 5

   給myhash的field字段的值加-10，返回加後的結果。

   redis 127.0.0.1:6379> hincrby myhash field -10
   (integer) -5

   1. HGETALL/HKEYS/HVALS/HMGET/HMSET:

   刪除該鍵，便於後面示例測試。

   redis 127.0.0.1:6379> del myhash
   (integer) 1

   爲該鍵myhash，一次性設置多個字段，分別是field1 = “hello”, field2 = “world”。

   redis 127.0.0.1:6379> hmset myhash field1 “hello” field2 “world”
   OK

   獲取myhash鍵的多個字段，其中field3並不存在，因爲在返回結果中與該字段對應的值爲nil。

   redis 127.0.0.1:6379> hmget myhash field1 field2 field3
   1) “hello”
   2) “world”
   3) (nil)

   返回myhash鍵的所有字段及其值，從結果中可以看出，他們是逐對列出的。

   redis 127.0.0.1:6379> hgetall myhash
   1) “field1”
   2) “hello”
   3) “field2”
   4) “world”

   僅獲取myhash鍵中所有字段的名字。

   redis 127.0.0.1:6379> hkeys myhash
   1) “field1”
   2) “field2”

   僅獲取myhash鍵中所有字段的值。

   redis 127.0.0.1:6379> hvals myhash
   1) “hello”
   2) “world”

五、sortedset命令示例：

1. ZADD/ZCARD/ZCOUNT/ZREM/ZINCRBY/ZSCORE/ZRANGE/ZRANK:

   在Shell的命令行下啓動Redis客戶端工具。

   /> redis-cli

   添加一個分數爲1的成員。

   redis 127.0.0.1:6379> zadd myzset 1 “one”
   (integer) 1

   添加兩個分數分別是2和3的兩個成員。

   redis 127.0.0.1:6379> zadd myzset 2 “two” 3 “three”
   (integer) 2

   0表示第一個成員，-1表示最後一個成員。WITHSCORES選項表示返回的結果中包含每個成員及其分數，否則只返回成員。

   redis 127.0.0.1:6379> zrange myzset 0 -1 WITHSCORES
   1) “one”
   2) “1”
   3) “two”
   4) “2”
   5) “three”
   6) “3”

   獲取成員one在Sorted-Set中的位置索引值。0表示第一個位置。

   redis 127.0.0.1:6379> zrank myzset one
   (integer) 0

   成員four並不存在，因此返回nil。

   redis 127.0.0.1:6379> zrank myzset four
   (nil)

   獲取myzset鍵中成員的數量。

   redis 127.0.0.1:6379> zcard myzset
   (integer) 3

   返回與myzset關聯的Sorted-Set中，分數滿足表達式1 <= score <= 2的成員的數量。

   redis 127.0.0.1:6379> zcount myzset 1 2
   (integer) 2

   刪除成員one和two，返回實際刪除成員的數量。

   redis 127.0.0.1:6379> zrem myzset one two
   (integer) 2

   查看是否刪除成功。

   redis 127.0.0.1:6379> zcard myzset
   (integer) 1

   獲取成員three的分數。返回值是字符串形式。

   redis 127.0.0.1:6379> zscore myzset three
   “3”

   由於成員two已經被刪除，所以該命令返回nil。

   redis 127.0.0.1:6379> zscore myzset two
   (nil)

   將成員one的分數增加2，並返回該成員更新後的分數。

   redis 127.0.0.1:6379> zincrby myzset 2 one
   “3”

   將成員one的分數增加-1，並返回該成員更新後的分數。

   redis 127.0.0.1:6379> zincrby myzset -1 one
   “2”

   查看在更新了成員的分數後是否正確。

   redis 127.0.0.1:6379> zrange myzset 0 -1 WITHSCORES
   1) “one”
   2) “2”
   3) “two”
   4) “2”
   5) “three”
   6) “3”

2. ZRANGEBYSCORE/ZREMRANGEBYRANK/ZREMRANGEBYSCORE
   redis 127.0.0.1:6379> del myzset
   (integer) 1
   redis 127.0.0.1:6379> zadd myzset 1 one 2 two 3 three 4 four
   (integer) 4

   獲取分數滿足表達式1 <= score <= 2的成員。

   redis 127.0.0.1:6379> zrangebyscore myzset 1 2
   1) “one”
   2) “two”

   獲取分數滿足表達式1 < score <= 2的成員。

   redis 127.0.0.1:6379> zrangebyscore myzset (1 2
   1) “two”

   -inf表示第一個成員，+inf表示最後一個成員，limit後面的參數用於限制返回成員的自己，

   2表示從位置索引(0-based)等於2的成員開始，去後面3個成員。

   redis 127.0.0.1:6379> zrangebyscore myzset -inf +inf limit 2 3
   1) “three”
   2) “four”

   刪除分數滿足表達式1 <= score <= 2的成員，並返回實際刪除的數量。

   redis 127.0.0.1:6379> zremrangebyscore myzset 1 2
   (integer) 2

   看出一下上面的刪除是否成功。

   redis 127.0.0.1:6379> zrange myzset 0 -1
   1) “three”
   2) “four”

   刪除位置索引滿足表達式0 <= rank <= 1的成員。

   redis 127.0.0.1:6379> zremrangebyrank myzset 0 1
   (integer) 2

   查看上一條命令是否刪除成功。

   redis 127.0.0.1:6379> zcard myzset
   (integer) 0

3. ZREVRANGE/ZREVRANGEBYSCORE/ZREVRANK:

   爲後面的示例準備測試數據。

   redis 127.0.0.1:6379> del myzset
   (integer) 0
   redis 127.0.0.1:6379> zadd myzset 1 one 2 two 3 three 4 four
   (integer) 4

   以位置索引從高到低的方式獲取並返回此區間內的成員。

   redis 127.0.0.1:6379> zrevrange myzset 0 -1 WITHSCORES
   1) “four”
   2) “4”
   3) “three”
   4) “3”
   5) “two”
   6) “2”
   7) “one”
   8) “1”

   由於是從高到低的排序，所以位置等於0的是four，1是three，並以此類推。

   redis 127.0.0.1:6379> zrevrange myzset 1 3
   1) “three”
   2) “two”
   3) “one”

   由於是從高到低的排序，所以one的位置是3。

   redis 127.0.0.1:6379> zrevrank myzset one
   (integer) 3

   由於是從高到低的排序，所以four的位置是0。

   redis 127.0.0.1:6379> zrevrank myzset four
   (integer) 0

   獲取分數滿足表達式3 >= score >= 0的成員，並以相反的順序輸出，即從高到底的順序。

   redis 127.0.0.1:6379> zrevrangebyscore myzset 3 0
   1) “three”
   2) “two”
   3) “one”

   該命令支持limit選項，其含義等同於zrangebyscore中的該選項，只是在計算位置時按照相反的順序計算和獲取。

   redis 127.0.0.1:6379> zrevrangebyscore myzset 4 0 limit 1 2
   1) “three”
   2) “two”

六、key相關命令示例：

1. KEYS/RENAME/DEL/EXISTS/MOVE/RENAMENX:

   在Shell命令行下啓動Redis客戶端工具。

   /> redis-cli

   清空當前選擇的數據庫，以便於對後面示例的理解。

   redis 127.0.0.1:6379> flushdb
   OK

   添加String類型的模擬數據。

   redis 127.0.0.1:6379> set mykey 2
   OK
   redis 127.0.0.1:6379> set mykey2 “hello”
   OK

   添加Set類型的模擬數據。

   redis 127.0.0.1:6379> sadd mysetkey 1 2 3
   (integer) 3

   添加Hash類型的模擬數據。

   redis 127.0.0.1:6379> hset mmtest username “stephen”
   (integer) 1

   根據參數中的模式，獲取當前數據庫中符合該模式的所有key，從輸出可以看出，該命令在執行時並不區分與Key關聯的Value類型。

   redis 127.0.0.1:6379> keys my*
   1) “mysetkey”
   2) “mykey”
   3) “mykey2”

   刪除了兩個Keys。

   redis 127.0.0.1:6379> del mykey mykey2
   (integer) 2

   查看一下剛剛刪除的Key是否還存在，從返回結果看，mykey確實已經刪除了。

   redis 127.0.0.1:6379> exists mykey
   (integer) 0

   查看一下沒有刪除的Key，以和上面的命令結果進行比較。

   redis 127.0.0.1:6379> exists mysetkey
   (integer) 1

   將當前數據庫中的mysetkey鍵移入到ID爲1的數據庫中，從結果可以看出已經移動成功。

   redis 127.0.0.1:6379> move mysetkey 1
   (integer) 1

   打開ID爲1的數據庫。

   redis 127.0.0.1:6379> select 1
   OK

   查看一下剛剛移動過來的Key是否存在，從返回結果看已經存在了。

   redis 127.0.0.1:6379[1]> exists mysetkey
   (integer) 1

   在重新打開ID爲0的缺省數據庫。

   redis 127.0.0.1:6379[1]> select 0
   OK

   查看一下剛剛移走的Key是否已經不存在，從返回結果看已經移走。

   redis 127.0.0.1:6379> exists mysetkey
   (integer) 0

   準備新的測試數據。

   redis 127.0.0.1:6379> set mykey “hello”
   OK

   將mykey改名爲mykey1

   redis 127.0.0.1:6379> rename mykey mykey1
   OK

   由於mykey已經被重新命名，再次獲取將返回nil。

   redis 127.0.0.1:6379> get mykey
   (nil)

   通過新的鍵名獲取。

   redis 127.0.0.1:6379> get mykey1
   “hello”

   由於mykey已經不存在了，所以返回錯誤信息。

   redis 127.0.0.1:6379> rename mykey mykey1
   (error) ERR no such key

   爲renamenx準備測試key

   redis 127.0.0.1:6379> set oldkey “hello”
   OK
   redis 127.0.0.1:6379> set newkey “world”
   OK

   由於newkey已經存在，因此該命令未能成功執行。

   redis 127.0.0.1:6379> renamenx oldkey newkey
   (integer) 0

   查看newkey的值，發現它也沒有被renamenx覆蓋。

   redis 127.0.0.1:6379> get newkey
   “world”

2. PERSIST/EXPIRE/EXPIREAT/TTL:

   爲後面的示例準備的測試數據。

   redis 127.0.0.1:6379> set mykey “hello”
   OK

   將該鍵的超時設置爲100秒。

   redis 127.0.0.1:6379> expire mykey 100
   (integer) 1

   通過ttl命令查看一下還剩下多少秒。

   redis 127.0.0.1:6379> ttl mykey
   (integer) 97

   立刻執行persist命令，該存在超時的鍵變成持久化的鍵，即將該Key的超時去掉。

   redis 127.0.0.1:6379> persist mykey
   (integer) 1

   ttl的返回值告訴我們，該鍵已經沒有超時了。

   redis 127.0.0.1:6379> ttl mykey
   (integer) -1

   爲後面的expire命令準備數據。

   redis 127.0.0.1:6379> del mykey
   (integer) 1
   redis 127.0.0.1:6379> set mykey “hello”
   OK

   設置該鍵的超時被100秒。

   redis 127.0.0.1:6379> expire mykey 100
   (integer) 1

   用ttl命令看一下當前還剩下多少秒，從結果中可以看出還剩下96秒。

   redis 127.0.0.1:6379> ttl mykey
   (integer) 96

   重新更新該鍵的超時時間爲20秒，從返回值可以看出該命令執行成功。

   redis 127.0.0.1:6379> expire mykey 20
   (integer) 1

   再用ttl確認一下，從結果中可以看出果然被更新了。

   redis 127.0.0.1:6379> ttl mykey
   (integer) 17

   立刻更新該鍵的值，以使其超時無效。

   redis 127.0.0.1:6379> set mykey “world”
   OK

   從ttl的結果可以看出，在上一條修改該鍵的命令執行後，該鍵的超時也無效了。

   redis 127.0.0.1:6379> ttl mykey
   (integer) -1

3. TYPE/RANDOMKEY/SORT:

   由於mm鍵在數據庫中不存在，因此該命令返回none。

   redis 127.0.0.1:6379> type mm
   none

   mykey的值是字符串類型，因此返回string。

   redis 127.0.0.1:6379> type mykey
   string

   準備一個值是set類型的鍵。

   redis 127.0.0.1:6379> sadd mysetkey 1 2
   (integer) 2

   mysetkey的鍵是set，因此返回字符串set。

   redis 127.0.0.1:6379> type mysetkey
   set

   返回數據庫中的任意鍵。

   redis 127.0.0.1:6379> randomkey
   “oldkey”

   清空當前打開的數據庫。

   redis 127.0.0.1:6379> flushdb
   OK

   由於沒有數據了，因此返回nil。

   redis 127.0.0.1:6379> randomkey
   (nil)

七、事務處理命令與WATCH命令和基於CAS的樂觀鎖示例：

1. 事務被正常執行：

   在Shell命令行下執行Redis的客戶端工具。

   /> redis-cli

   在當前連接上啓動一個新的事務。

   redis 127.0.0.1:6379> multi
   OK

   執行事務中的第一條命令，從該命令的返回結果可以看出，該命令並沒有立即執行，而是存於事務的命令隊列。

   redis 127.0.0.1:6379> incr t1
   QUEUED

   又執行一個新的命令，從結果可以看出，該命令也被存於事務的命令隊列。

   redis 127.0.0.1:6379> incr t2
   QUEUED

   執行事務命令隊列中的所有命令，從結果可以看出，隊列中命令的結果得到返回。

   redis 127.0.0.1:6379> exec
   1) (integer) 1
   2) (integer) 1

2. 事務中存在失敗的命令：

   開啓一個新的事務。

   redis 127.0.0.1:6379> multi
   OK

   設置鍵a的值爲string類型的3。

   redis 127.0.0.1:6379> set a 3
   QUEUED

   從鍵a所關聯的值的頭部彈出元素，由於該值是字符串類型，而lpop命令僅能用於List類型，因此在執行exec命令時，該命令將會失敗。

   redis 127.0.0.1:6379> lpop a
   QUEUED

   再次設置鍵a的值爲字符串4。

   redis 127.0.0.1:6379> set a 4
   QUEUED

   獲取鍵a的值，以便確認該值是否被事務中的第二個set命令設置成功。

   redis 127.0.0.1:6379> get a
   QUEUED

   從結果中可以看出，事務中的第二條命令lpop執行失敗，而其後的set和get命令均執行成功，這一點是Redis的事務與關係型數據庫中的事務之間最爲重要的差別。

   redis 127.0.0.1:6379> exec
   1) OK
   2) (error) ERR Operation against a key holding the wrong kind of value
   3) OK
   4) “4”

3. 回滾事務：

   爲鍵t2設置一個事務執行前的值。

   redis 127.0.0.1:6379> set t2 tt
   OK

   開啓一個事務。

   redis 127.0.0.1:6379> multi
   OK

   在事務內爲該鍵設置一個新值。

   redis 127.0.0.1:6379> set t2 ttnew
   QUEUED

   放棄事務。

   redis 127.0.0.1:6379> discard
   OK

   查看鍵t2的值，從結果中可以看出該鍵的值仍爲事務開始之前的值。

   redis 127.0.0.1:6379> get t2
   “tt”

   在Redis的事務中，WATCH命令可用於提供CAS(check-and-set)功能。假設我們通過WATCH命令在事務執行之前監控了多個Keys，倘若在WATCH之後有任何Key的值發生了變化，EXEC命令執行的事務都將被放棄，同時返回Null multi-bulk應答以通知調用者事務執行失敗。例如，我們再次假設Redis中並未提供incr命令來完成鍵值的原子性遞增，如果要實現該功能，我們只能自行編寫相應的代碼。其僞碼如下：
   val = GET mykey
   val = val + 1
   SET mykey val以上代碼只有在單連接的情況下才可以保證執行結果是正確的，因爲如果在同一時刻有多個客戶端在同時執行該段代碼，那麼就會出現多線程程序中經常出現的一種錯誤場景–競態爭用(racecondition)。比如，客戶端A和B都在同一時刻讀取了mykey的原有值，假設該值爲10，此後兩個客戶端又均將該值加一後set回Redis服務器，這樣就會導致mykey的結果爲11，而不是我們認爲的12。爲了解決類似的問題，我們需要借助WATCH命令的幫助，見如下代碼：WATCHmykeyval=GETmykeyval=val+1MULTISETmykey val
   EXEC

八、replicaset應用示例：

這裏我們假設Master-Slave已經建立。
#啓動master服務器。
[root@Stephen-PC redis]# redis-cli -p 6379
redis 127.0.0.1:6379>
#情況Master當前數據庫中的所有Keys。
redis 127.0.0.1:6379> flushdb
OK
#在Master中創建新的Keys作爲測試數據。
redis 127.0.0.1:6379> set mykey hello
OK
redis 127.0.0.1:6379> set mykey2 world
OK
#查看Master中存在哪些Keys。
redis 127.0.0.1:6379> keys *
1) "mykey"
2) "mykey2"

#啓動slave服務器。
[root@Stephen-PC redis]# redis-cli -p 6380
#查看Slave中的Keys是否和Master中一致，從結果看，他們是相等的。
redis 127.0.0.1:6380> keys *
1) "mykey"
2) "mykey2"

#在Master中刪除其中一個測試Key，並查看刪除後的結果。
redis 127.0.0.1:6379> del mykey2
(integer) 1
redis 127.0.0.1:6379> keys *
1) "mykey"

#在Slave中查看是否mykey2也已經在Slave中被刪除。
redis 127.0.0.1:6380> keys *
1) "mykey"

轉自：http://blog.csdn.net/hexrain/article/details/42263223