redis學習教程之一基本命令

參閱redis中文的 互動教程（interactive tutorial）的學習筆記。

全局操作：

#查看所有key
keys *  或  keys "*"

#查看匹配前綴的keys
keys "miao*"

#清空redis
flushdb

#隨機取出一個key
randomkey

#查看key的類型
type key

#查看數據庫中key的數量
dbsize

#查看服務器信息
info

#查看redis正在做什么
monitor   #注意，有高手的文章說這個會急劇降低redis性能，只能在測試環境使用。

#查看日志

slowlog get
slowlog get 10

 

1.redis是key-value存儲的，放在內存中，並在磁盤持久化的數據結構存儲系統

通過set key value來存儲，通過get key來獲取值

set key value:設置key的值,若存在則覆蓋
setnx key value:SET if Not eXists,若存在則不操作。
MSET key1 value1 key2 value2 ... keyN valueN:設置這些key的值，若存在則覆蓋
MSETNX key1 value1 key2 value2 ... keyN valueN:同mset，但如果其中一個key已經存在了，則都不設置。這些操作都是原子的。
rename key: 重命名

append key value:向key的字符串追加拼接。

get key:獲取key對應的值 MGET key1 key2 ... keyN:獲取這些key對應的值 

EXISTS key:查看是否存在該元素。
GETSET key value:獲取該元素的值，並給該元素設置新值。（通常和incr搭配使用，比如一個mycount一直incr，然后達到某些情況需要清零，清零之前需要知道mycount的值）.
del key:刪除元素
RENAME oldkey newkey:重命名

 

 

2.redis提供原子自增操作incr,用來防止多線程並發出現數據錯誤。

incr key:原子的+1；
DECR key：原子的-1；
DECRBY key integer：原子的-integer；
INCRBY key integer：原子的+integer

 

 

 

3.刪除操作：del.若數據不存在返回(nil)

 

 

4.redis可以定時存儲，即設置幾秒后刪除該變量

expire key 多少秒：設置多少秒后過期；  ttl key:Time To Live，查看還可以存活多久，-2表示key不存在；-1表示定時任務消失，永久存儲。

EXPIRE key seconds：設置該元素多少秒后失效
PEXPIRE key milliseconds：設置該元素多少毫秒后失效
TTL key：查看還可以存活多少秒，-2表示key不存在，-1表示永久存儲
SETEX key seconds value：等價於先設置變量再設置超時，即在緩存中使用：存儲的同時設置超時時間，這個操作是原子的
persist key:取消過期時間
expireat key 時間戳：unix時間戳，1970.1.1之后，這個絕對時間，將在這個時間刪除key。expireat pages:about 1356933600：在2012年12月31日上午12點刪除掉關鍵字
SETEX KEY_NAME TIMEOUT VALUE：設置key的值為value，並在timeout秒后失效，key將被刪除

     ->->->

 

 

5.存儲有序隊列：list

rpush keyList value:向keyList添加元素,向后加,r表示右邊

lpush keyList value:向keyList左邊添加元素，LPUSH puts the new value at the start of the list.

lrange keyList beginIndex endIndex:獲取keyList的元素，用兩端的索引取出子集，endIndex=-1則表示全部取出

這里就要了解redis數據結構的存儲類型， 字符串（strings）， 散列（hashes）， 列表（lists），集合（sets）， 有序集合（sorted sets） 與范圍查詢， bitmaps， hyperloglogs 和 地理空間（geospatial） 索引半徑查詢。 Redis 內置了 復制（replication），LUA腳本（Lua scripting），LRU驅動事件（LRU eviction），事務（transactions） 和不同級別的 磁盤持久化（persistence）， 並通過 Redis哨兵（Sentinel）和自動 分區（Cluster）提供高可用性（high availability）。

現在學習list：

->->->

llen keyList :獲取keyList的長度大小
lpop keyList:取出並移除keyList第一個元素，左邊的元素
rpop keyList:取出並移除keyList最后一個元素，右邊的元素
LINDEX key index:獲取該索引下的元素。
lrem key count value:刪除count個value。（count為正數,從頭開始，刪除count個value元素；count為負，則從尾部向頭刪除|count|個value元素；count為0，則所有的元素為value的都刪除）
LSET key index value:設置索引為index下的元素為value.超出索引范圍報錯。
LTRIM key start end:清空索引在start 和end之外的元素，索引從0開始，兩端保留，兩端之外的清空。
RPOPLPUSH srckey dstkey:源隊列srckey，目標隊列dstkey，將srckey的最后一個移除，並放到dstkey的第一個。

-》-》

 

 

6.無序且唯一集合set

和java中list與set的區別一樣。這里的set無序且值唯一。

The next data structure that we'll look at is a set. A set is similar to a list, except it does not have a specific order and each element may only appear once. Some of the important commands in working with sets are SADD, SREM, SISMEMBER, SMEMBERS and SUNION.

sadd key value : 向set添加元素
srem key value ：從set中移除元素
smembers key : 取出所有set元素
SISMEMBER key value: 查看value是否存在set中
SUNION key1 key2 ... keyN:將所有key合並后取出來，相同的值只取一次
scard key : 獲取set中元素的個數
SRANDMEMBER key: Return a random element from a Set, without removing the element.隨機取出一個
SDIFF key1 key2 ... keyN：獲取第一set中不存在后面幾個set里的元素。
SDIFFSTORE dstkey key1 key2 ... keyN：和sdiff相同，獲取key1中不存在其他key里的元素，但要存儲到dstkey中。
SINTER key1 key2 ... keyN:取出這些set的交集
SINTERSTORE dstkey key1 key2 ... keyN：取出這些key的交集並存儲到dstkey
SMOVE srckey dstkey member：將元素member從srckey中轉移到dstkey中，這個操作是原子的。

-》-》-》

 

 

7.有序集合sorted set

和set一樣，唯一。但z多了個score用來排序。所以命令又像list一樣：

ZADD key score member：向有序set中添加元素member，其中score為分數，默認升序；
ZRANGE key start end [WITHSCORES]:獲取按score從低到高索引范圍內的元素，索引可以是負數，-1表示最后一個，-2表示倒數第二個，即從后往前。withscores可選，表示獲取包括分數。
ZREVRANGE key start end [WITHSCORES]：同上，但score從高到低排序。
ZCOUNT key min max：獲取score在min和max范圍內的元素的個數
ZCARD key:獲取集合中元素的個數。
ZINCRBY key increment member:根據元素，score原子增加increment.
ZREMRANGEBYSCORE key min max:清空集合內的score位於min和max之間的元素。
ZRANK key member:獲取元素的索引（照score從低到高排列）。
ZREM key member:移除集合中的該元素
ZSCORE key member:獲取該元素的score

 

 

8.對象存儲Hashes

可以存儲對象，比如人，編號，姓名，年齡等

HSET key field value:key是對象名，field是屬性，value是值；
HMSET key field value [field value ...]:同時設置多個屬性
HGET key field：獲取該對象的該屬性
HMGET key field value [field value ...]：獲取多個屬性值
HGETALL key:獲取對象的所有信息
HKEYS key：獲取對象的所有屬性
HVALS key：獲取對象的所有屬性值
HDEL key field：刪除對象的該屬性
HEXISTS key field:查看對象是否存在該屬性
HINCRBY key field value:原子自增操作，只能是integer的屬性值可以使用；
HLEN key: Return the number of entries (fields) contained in the hash stored at key.獲取屬性的個數。

->->

 

 

 

9.sort排序！

文檔如下：

SORT [BY] [LIMIT] [GET] [ASC|DESC] [ALPHA] [STORE ]

DESCRIPTION: Sort the elements contained in the List, Set, or Sorted Set value at key. By default sorting is numeric with elements being compared as double precision floating point numbers. This is the simplest form of SORT: SORT mylist

Assuming mylist contains a list of numbers, the return value will be the list of numbers ordered from the smallest to the biggest number. In order to get the sorting in reverse order use DESC: SORT mylist DESC

The ASC option is also supported but it's the default so you don't really need it. If you want to sort lexicographically use ALPHA. Note that Redis is utf-8 aware assuming you set the right value for the LC_COLLATE environment variable.

Sort is able to limit the number of returned elements using the LIMIT option: SORT mylist LIMIT 0 10

In the above example SORT will return only 10 elements, starting from the first one (start is zero-based). Almost all the sort options can be mixed together. For example the command: SORT mylist LIMIT 0 10 ALPHA DESC

Will sort mylist lexicographically, in descending order, returning only the first 10 elements.

Sometimes you want to sort elements using external keys as weights to compare instead to compare the actual List Sets or Sorted Set elements. For example the list mylist may contain the elements 1, 2, 3, 4, that are just unique IDs of objects stored at object_1, object_2, object_3 and object_4, while the keys weight_1, weight_2, weight_3 and weight_4 can contain weights we want to use to sort our list of objects identifiers. We can use the following command:

SORTING BY EXTERNAL KEYS:

SORT mylist BY weight_*

the BY option takes a pattern (weight_* in our example) that is used in order to generate the key names of the weights used for sorting. Weight key names are obtained substituting the first occurrence of * with the actual value of the elements on the list (1,2,3,4 in our example).

Our previous example will return just the sorted IDs. Often it is needed to get the actual objects sorted (object_1, ..., object_4 in the example). We can do it with the following command:

RETRIEVING EXTERNAL KEYS:

SORT mylist BY weight* GET object*

Note that GET can be used multiple times in order to get more keys for every element of the original List, Set or Sorted Set sorted.

Since Redis >= 1.1 it's possible to also GET the list elements itself using the special # pattern: SORT mylist BY weight* GET object* GET #

STORING THE RESULT OF A SORT OPERATION:

By default SORT returns the sorted elements as its return value. Using the STORE option instead to return the elements SORT will store this elements as a Redis List in the specified key. An example:SORT mylist BY weight_* STORE resultkey

An interesting pattern using SORT ... STORE consists in associating an EXPIRE timeout to the resulting key so that in applications where the result of a sort operation can be cached for some time other clients will use the cached list instead to call SORT for every request. When the key will timeout an updated version of the cache can be created using SORT ... STORE again.

Note that implementing this pattern it is important to avoid that multiple clients will try to rebuild the cached version of the cache at the same time, so some form of locking should be implemented (for instance using SETNX).

RETURN VALUE: A multi bulk reply containing a list of sorted elements.

復制一個sort的用法：http://www.cnblogs.com/linjiqin/archive/2013/06/14/3135921.html

9.1 sort命令描述：

返回或保存給定列表、集合、有序集合key中經過排序的元素。排序默認以數字作為對象，值被解釋為雙精度浮點數，然后進行比較。

9.2 一般sort用法

最簡單的sort使用方法是sort key和sort key desc。
sort key：返回鍵值從小到大排序的結果。
sort key desc：返回鍵值從大到小排序的結果。

假設price列表保存了今日的物品價格， 那么可以用sort命令對它進行排序：
# 開銷金額列表

redis> lpush price 30 1.5 10 8
(integer) 4

# 排序

redis> sort price
1) "1.5"
2) "8"
3) "10"
4) "30"

# 逆序排序

redis 127.0.0.1:6379> sort price desc
1) "30"
2) "10"
3) "8"
4) "1.5"

 

9.3 使用alpha修飾符對字符串進行排序

因為sort命令默認排序對象為數字，當需要對字符串進行排序時，需要顯式地在sort命令之后添加alpha修飾符。

# 網址

redis> lpush website "www.ceddit.com"
(integer) 1

redis> lpush website "www.hlashdot.com"
(integer) 2

redis> lpush website "www.bnfoq.com"
(integer) 3

# 默認(按數字)排序

redis 127.0.0.1:8888> sort website
1) "www.bnfoq.com"
2) "www.hlashdot.com"
3) "www.ceddit.com"

# 按字符排序

redis 127.0.0.1:8888> sort website alpha
1) "www.bnfoq.com"
2) "www.ceddit.com"
3) "www.hlashdot.com"

redis 127.0.0.1:8888> sort website alpha desc
1) "www.hlashdot.com"
2) "www.ceddit.com"
3) "www.bnfoq.com"

 

9.4、使用limit修飾符限制返回結果

排序之后返回元素的數量可以通過limit修飾符進行限制，修飾符接受offset和count兩個參數。offset：指定要跳過的元素數量，即起始位置。count：指定跳過offset個指定的元素之后，要返回多少個對象。

以下例子返回排序結果的前5個對象(offset為0表示沒有元素被跳過)。

# 添加測試數據，列表值為1~10

redis 127.0.0.1:6379> rpush age 1 3 5 7 9
(integer) 5

redis 127.0.0.1:6379> rpush age 2 4 6 8 10
(integer) 10

# 返回列表中最小的5個值

redis 127.0.0.1:6379> sort age limit 0 5
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"

 

9.5、使用外部key進行排序

可以使用外部 key 的數據作為權重，代替默認的直接對比鍵值的方式來進行排序。

假設現在有用戶數據如下：

以下代碼將數據輸入到redis中：

# admin
redis 127.0.0.1:6379> lpush uid 1
(integer) 1

redis 127.0.0.1:6379> set user_name_1 admin
ok

redis 127.0.0.1:6379> set user_level_1 9999
ok

# jack
redis 127.0.0.1:6379> lpush uid 2
(integer) 2

redis 127.0.0.1:6379> set user_name_2 jack
ok

redis 127.0.0.1:6379> set user_level_2 10
ok

# peter
redis 127.0.0.1:6379> lpush uid 3
(integer) 3

redis 127.0.0.1:6379> set user_name_3 peter
ok

redis 127.0.0.1:6379> set user_level_3 25
ok

# mary
redis 127.0.0.1:6379> lpush uid 4
(integer) 4

redis 127.0.0.1:6379> set user_name_4 mary
ok

redis 127.0.0.1:6379> set user_level_4 70
ok

 

9.6、by選項

默認情況下， sort uid直接按uid中的值排序：

redis 127.0.0.1:6379> sort uid
1) "1" # admin
2) "2" # jack
3) "3" # peter
4) "4" # mary

通過使用by選項，可以讓uid按其他鍵的元素來排序。

比如說， 以下代碼讓uid鍵按照user_level_{uid}的大小來排序：

redis 127.0.0.1:6379> sort uid by user_level_*
1) "2" # jack , level = 10
2) "3" # peter, level = 25
3) "4" # mary, level = 70
4) "1" # admin, level = 9999

user_level_*是一個占位符，它先取出uid中的值，然后再用這個值來查找相應的鍵。

比如在對uid列表進行排序時，程序就會先取出uid的值1、2、3、4，然后使用user_level_1、user_level_2、user_level_3和 user_level_4的值作為排序uid的權重。

 

9.7、get選項

使用get選項，可以根據排序的結果來取出相應的鍵值。

比如說，以下代碼先排序uid，再取出鍵user_name_{uid}的值：

redis 127.0.0.1:6379> sort uid get user_name_*
1) "admin"
2) "jack"
3) "peter"
4) "mary"

現在的排序結果要比只使用 sort uid by user_level_* 要直觀得多。

 

9.8、獲取多個外部鍵

可以同時使用多個get選項，獲取多個外部鍵的值。

以下代碼就按 uid 分別獲取 user_level_{uid} 和 user_name_{uid} ：

redis 127.0.0.1:6379> sort uid get user_level_* get user_name_*
1) "9999" # level
2) "admin" # name
3) "10"
4) "jack"
5) "25"
6) "peter"
7) "70"
8) "mary"

get有一個額外的參數規則，那就是可以用#獲取被排序鍵的值。

以下代碼就將 uid 的值、及其相應的 user_level_* 和 user_name_* 都返回為結果：

redis 127.0.0.1:6379> sort uid get # get user_level_* get user_name_*
1) "1" # uid
2) "9999" # level
3) "admin" # name
4) "2"
5) "10"
6) "jack"
7) "3"
8) "25"
9) "peter"
10) "4"
11) "70"
12) "mary"

 

9.9、獲取外部鍵，但不進行排序

通過將一個不存在的鍵作為參數傳給 by 選項， 可以讓 sort 跳過排序操作，直接返回結果：

redis 127.0.0.1:6379> sort uid by not-exists-key
1) "4"
2) "3"
3) "2"
4) "1"

這種用法在單獨使用時，沒什么實際用處。

不過，通過將這種用法和get選項配合，就可以在不排序的情況下，獲取多個外部鍵，相當於執行一個整合的獲取操作（類似於 sql數據庫的join關鍵字）。

以下代碼演示了，如何在不引起排序的情況下，使用sort、by和get獲取多個外部鍵：

redis 127.0.0.1:6379> sort uid by not-exists-key get # get user_level_* get user_name_*
1) "4" # id
2) "70" # level
3) "mary" # name
4) "3"
5) "25"
6) "peter"
7) "2"
8) "10"
9) "jack"
10) "1"
11) "9999"
12) "admin"

 

9.10、將哈希表作為get或by的參數

除了可以將字符串鍵之外， 哈希表也可以作為 get 或 by 選項的參數來使用。
比如說，對於前面給出的用戶信息表：

我們可以不將用戶的名字和級別保存在 user_name_{uid} 和 user_level_{uid} 兩個字符串鍵中， 而是用一個帶有 name 域和 level 域的哈希表 user_info_{uid} 來保存用戶的名字和級別信息：

redis 127.0.0.1:6379> hmset user_info_1 name admin level 9999
ok

redis 127.0.0.1:6379> hmset user_info_2 name jack level 10
ok

redis 127.0.0.1:6379> hmset user_info_3 name peter level 25
ok

redis 127.0.0.1:6379> hmset user_info_4 name mary level 70
ok

之后， by 和 get 選項都可以用 key->field 的格式來獲取哈希表中的域的值， 其中 key 表示哈希表鍵， 而 field 則表示哈希表的域：

redis 127.0.0.1:6379> sort uid by user_info_*->level
1) "2"
2) "3"
3) "4"
4) "1"

redis 127.0.0.1:6379> sort uid by user_info_*->level get user_info_*->name
1) "jack"
2) "peter"
3) "mary"
4) "admin"

 

9.11、保存排序結果

默認情況下， sort 操作只是簡單地返回排序結果，並不進行任何保存操作。
通過給 store 選項指定一個 key 參數，可以將排序結果保存到給定的鍵上。
如果被指定的 key 已存在，那么原有的值將被排序結果覆蓋。

# 測試數據

redis 127.0.0.1:6379> rpush numbers 1 3 5 7 9
(integer) 5

redis 127.0.0.1:6379> rpush numbers 2 4 6 8 10
(integer) 10

redis 127.0.0.1:6379> lrange numbers 0 -1
1) "1"
2) "3"
3) "5"
4) "7"
5) "9"
6) "2"
7) "4"
8) "6"
9) "8"
10) "10"

redis 127.0.0.1:6379> sort numbers store sorted-numbers
(integer) 10

# 排序后的結果
redis 127.0.0.1:6379> lrange sorted-numbers 0 -1
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"
6) "6"
7) "7"
8) "8"
9) "9"
10) "10"

 

9.12、返回值

沒有使用 store 參數，返回列表形式的排序結果。
使用 store 參數，返回排序結果的元素數量。

 

 

 

10事物

redis內置了很多原子操作的命令，比如incr,getset等，但實際中我們希望將一組命令原子的執行，這時候就需要用到事物。做法如下：

1. 使用關鍵字multi
2. 輸入你想要的命令組合
3. 輸入exec來執行，或discard來放棄

127.0.0.1:6379> multi
OK
127.0.0.1:6379> keys *
QUEUED
127.0.0.1:6379> set miao "transaction is by using multi then do some order,end with exec"
QUEUED
127.0.0.1:6379> get miao
QUEUED
127.0.0.1:6379> get users:9001
QUEUED
127.0.0.1:6379> exec
1) 1) "friends:duncan"
   2) "users:lookup:email"
   3) "users:9001"
2) OK
3) "transaction is by using multi then do some order,end with exec"
4) "{id:9001,email:[e-mail],..}"

 

 

 

參考：

http://www.redis.net.cn/

http://redis.io/