145.《redis原生超詳細使用》

文章目錄

什么是redis
redis 安裝啟動
redis數據類型
redis key操作
- key 的增
- key 的查
- key 的改
- key 的刪
- key 是否存在
- key 查看所有
- key 「設置」過期時間
- key 「查看」過期時間
- key 「移除」過期時間
- key 「查看」數據類型
- key 「匹配」符合條件的key
- key 「移動」到其他數據庫
redis數據類型操作
- string(字符串)
- - 設置字符串
  - 獲取字符串
  - 字符串截取
  - 設置所有(一個或多個)給定 key 的值
  - 獲取一個或多個 key-value 對
  - key 不存在時設置 key 的值
  - 返回字符串值的長度
  - key 中儲存的數字值增一
  - key 的值加上給定的增量值
  - key 中儲存的數字值減一
  - key 所儲存的值減去給定的減量值
  - key 后追加新的字符串
- list（列表）
- - 設置列表
  - 移出并獲取列表的第一個元素
  - 移出并獲取列表的最后一個元素
  - 通過索引獲取列表中的元素
  - 在列表的元素前或者后插入元素
  - 獲取列表長度
  - 移出并獲取列表的第一個元素
  - 將一個值插入到已存在的列表頭部
  - 將一個或多個值插入到列表頭部
  - 獲取列表指定范圍內的元素
  - 獲取全部元素
  - 移除列表元素
  - 通過索引設置列表元素的值
  - 查找指定區間內的元素
  - 移除列表的最后一個元素，并返回
  - 移除列表的最后一個元素，并將該元素添加到另一個列表并返回
  - 在列表中添加一個或多個值到列表尾部
  - 為已存在的列表添加值
- hash（哈希）
- - 刪除一個或多個哈希表字段
  - 查看哈希表 key 中，指定的字段是否存在
  - 獲取存儲在哈希表中指定字段的值
  - 獲取在哈希表中指定 key 的所有字段和值
  - 為哈希表 key 中的指定字段的整數值加上增量 increment
  - 為哈希表 key 中的指定字段的浮點數值加上增量 increment
  - 獲取哈希表中的所有字段
  - 獲取哈希表中字段的數量
  - 獲取所有給定字段的值
  - 同時將多個 field-value (域-值)對設置到哈希表 key 中
  - 將哈希表 key 中的字段 field 的值設為 value
  - 只有在字段 field 不存在時，設置哈希表字段的值
  - 獲取哈希表中所有值
  - 迭代哈希表中的鍵值對
- set（集合）
- - 向集合添加一個或多個成員
  - 獲取集合的成員數
  - 返回第一個集合與其他集合之間的差異
  - 返回給定所有集合的差集并存儲在 destination 中
  - 返回給定所有集合的交集
  - 返回給定所有集合的交集并存儲在 destination 中
  - 判斷 member 元素是否是集合 key 的成員
  - 返回集合中的所有成員
  - 將 member 元素從 source 集合移動到 destination 集合
  - 移除并返回集合中的一個隨機元素
  - 返回集合中一個或多個隨機數
  - 移除集合中一個或多個成員
  - 返回所有給定集合的并集
  - 所有給定集合的并集存儲在 destination 集合中
  - 迭代集合中的元素
- zset(sorted set）
- - 向有序集合添加一個或多個成員，或者更新已存在成員的分數
  - 獲取有序集合的成員數
  - 計算在有序集合中指定區間分數的成員數
  - 有序集合中對指定成員的分數加上增量 increment
  - 計算給定的一個或多個有序集的交集并將結果集存儲在新的有序集合 destination 中
  - 在有序集合中計算指定字典區間內成員數量
  - 通過索引區間返回有序集合指定區間內的成員
  - 通過字典區間返回有序集合的成員
  - 通過分數返回有序集合指定區間內的成員
  - 返回有序集合中指定成員的索引
  - 移除有序集合中的一個或多個成員
  - 移除有序集合中給定的字典區間的所有成員
  - 移除有序集合中給定的排名區間的所有成員
  - 移除有序集合中給定的分數區間的所有成員
  - 返回有序集中指定區間內的成員，通過索引，分數從高到低
  - 返回有序集中指定分數區間內的成員，分數從高到低排序
  - 返回有序集合中指定成員的排名，有序集成員按分數值遞減(從大到小)排序
  - 返回有序集中，成員的分數值
  - 計算給定的一個或多個有序集的并集，并存儲在新的 key 中
  - 迭代有序集合中的元素（包括元素成員和元素分值）

什么是redis

REmote DIctionary Server(Redis) 是一個由 Salvatore Sanfilippo 寫的 key-value 存儲系統，是跨平臺的非關系型數據庫。

Redis 是一個開源的使用 ANSI C 語言編寫、遵守 BSD 協議、支持網絡、可基于內存、分布式、可選持久性的鍵值對(Key-Value)存儲數據庫，并提供多種語言的 API。

Redis 通常被稱為數據結構服務器，因為值（value）可以是字符串(String)、哈希(Hash)、列表(list)、集合(sets)和有序集合(sorted sets)等類型。

redis 安裝啟動

在 macOS 上安裝 Redis并啟動
在 window 上安裝 Redis并啟動

redis數據類型

Redis 主要支持以下幾種數據類型：
常用

string（字符串）：基本的數據存儲單元，可以存儲字符串、整數或者浮點數。
hash（哈希）:一個鍵值對集合，可以存儲多個字段。
list（列表）:一個簡單的列表，可以存儲一系列的字符串元素。
set（集合）:一個無序集合，可以存儲不重復的字符串元素。
zset(sorted set）：有序集合): 類似于集合，但是每個元素都有一個分數（score）與之關聯。

不常用

位圖（Bitmaps）：基于字符串類型，可以對每個位進行操作。
超日志（HyperLogLogs）：用于基數統計，可以估算集合中的唯一元素數量。
地理空間（Geospatial）：用于存儲地理位置信息。
發布/訂閱（Pub/Sub）：一種消息通信模式，允許客戶端訂閱消息通道，并接收發布到該通道的消息。
流（Streams）：用于消息隊列和日志存儲，支持消息的持久化和時間排序。
模塊（Modules）：Redis 支持動態加載模塊，可以擴展 Redis 的功能。

redis key操作

Redis 鍵命令用于管理 redis 的鍵。

開始之前，先選擇操作的數據庫，redis的數據庫默認16個，操作之前先選擇數據庫

# 選擇了索引為0的數據庫
select 0

下面的所有的操作都在索引為0的數據庫里操作

key 的增

127.0.0.1:6379> set name lisi
OK

key 的查

127.0.0.1:6379> get name
"lisi"

key 的改

127.0.0.1:6379> rename name newName
OK
127.0.0.1:6379> get newName
"lisi"

key 的刪

127.0.0.1:6379> del newName
(integer) 1
127.0.0.1:6379> get newName
(nil)

key 是否存在

不存在

127.0.0.1:6379> exists newName
(integer) 0

存在

127.0.0.1:6379> exists name
(integer) 1

key 查看所有

127.0.0.1:6379> keys *
1) "runoob3"
2) "runoob1"
3) "name"
4) "runoob2"

key 「設置」過期時間

以秒計

127.0.0.1:6379> expire name 60
(integer) 1

以 UNIX 時間戳

127.0.0.1:6379> expireat runoobkey 1293840000
(integer) 1

以毫秒計

127.0.0.1:6379> pexpire name 1500
(integer) 1

key 「查看」過期時間

pttl
以毫秒為單位返回 key 的剩余的過期時間

127.0.0.1:6379> expire name 60
(integer) 1
127.0.0.1:6379> pttl name 
(integer) 53144

ttl
以秒為單位，返回給定 key 的剩余生存時間(TTL, time to live)。

127.0.0.1:6379> EXPIRE name 60
(integer) 1
127.0.0.1:6379> ttl name
(integer) 33

key 「移除」過期時間

移除 key 的過期時間，key 將持久保持

127.0.0.1:6379> expire name 60
(integer) 1
127.0.0.1:6379> get name
"lisi"
127.0.0.1:6379> PERSIST name
(integer) 1

key 「查看」數據類型

127.0.0.1:6379> type name
string

key 「匹配」符合條件的key

127.0.0.1:6379> keys runoob*
1) "runoob3"
2) "runoob1"
3) "runoob2"

key 「移動」到其他數據庫

127.0.0.1:6379> move name 2
(integer) 1

redis數據類型操作

string(字符串)

設置字符串

命令用于設置給定 key 的值。如果 key 已經存儲其他值， SET 就覆寫舊值，且無視類型。

SET key value

127.0.0.1:6379> set name lisi
OK

獲取字符串

命令用于獲取指定 key 的值。如果 key 不存在，返回 nil 。如果key 儲存的值不是字符串類型，返回一個錯誤。

GET key

127.0.0.1:6379> get name
"lisi"

字符串截取

命令用于獲取存儲在指定 key 中字符串的子字符串。字符串的截取范圍由 start 和 end 兩個偏移量決定(包括 start 和 end 在內)

GETRANGE key start end

127.0.0.1:6379> get name
"zhangsan nihao"
127.0.0.1:6379> getrange name 1 3
"han"

設置所有(一個或多個)給定 key 的值

命令返回所有(一個或多個)給定 key 的值。如果給定的 key 里面，有某個 key 不存在，那么這個 key 返回特殊值 nil 。

 MGET KEY1 KEY2 .. KEYN

127.0.0.1:6379> mset name 'zhangsan' age 15
OK
127.0.0.1:6379> keys *
1) "name"
2) "age"

獲取一個或多個 key-value 對

命令返回所有(一個或多個)給定 key 的值。如果給定的 key 里面，有某個 key 不存在，那么這個 key 返回特殊值 nil 。

MGET KEY1 KEY2 .. KEYN

127.0.0.1:6379> mget name age 
1) "zhangsan"
2) "15"

key 不存在時設置 key 的值

命令在指定的 key 不存在時，為 key 設置指定的值

SETNX KEY_NAME VALUE

127.0.0.1:6379> keys *
1) "name"
2) "age"
127.0.0.1:6379> setnx sex 'man'
(integer) 1
127.0.0.1:6379> keys *
1) "name"
2) "sex"
3) "age"

返回字符串值的長度

命令用于獲取指定 key 所儲存的字符串值的長度。當 key 儲存的不是字符串值時，返回一個錯誤。

STRLEN key

127.0.0.1:6379> strlen age 
(integer) 2
127.0.0.1:6379> strlen name
(integer) 8

key 中儲存的數字值增一

Incr 命令將 key 中儲存的數字值增一。
如果 key 不存在，那么 key 的值會先被初始化為 0 ，然后再執行 INCR 操作。
如果值包含錯誤的類型，或字符串類型的值不能表示為數字，那么返回一個錯誤。
本操作的值限制在 64 位(bit)有符號數字表示之內。

INCR KEY_NAME

127.0.0.1:6379> get age
"16"
127.0.0.1:6379> incr age
(integer) 17

key 的值加上給定的增量值

命令將 key 中儲存的數字加上指定的增量值。
如果 key 不存在，那么 key 的值會先被初始化為 0 ，然后再執行 INCRBY 命令。
如果值包含錯誤的類型，或字符串類型的值不能表示為數字，那么返回一個錯誤。
本操作的值限制在 64 位(bit)有符號數字表示之內。

INCRBY KEY_NAME INCR_AMOUNT

127.0.0.1:6379> get age
"17"
127.0.0.1:6379> incrby age
(integer) 19

key 中儲存的數字值減一

Decr 命令將 key 中儲存的數字值減一。
如果 key 不存在，那么 key 的值會先被初始化為 0 ，然后再執行 DECR 操作。
如果值包含錯誤的類型，或字符串類型的值不能表示為數字，那么返回一個錯誤。
本操作的值限制在 64 位(bit)有符號數字表示之內。

DECR KEY_NAME

127.0.0.1:6379> get age 
"19"
127.0.0.1:6379> decr age
(integer) 18

key 所儲存的值減去給定的減量值

命令將 key 所儲存的值減去指定的減量值。
如果 key 不存在，那么 key 的值會先被初始化為 0 ，然后再執行 DECRBY 操作。
如果值包含錯誤的類型，或字符串類型的值不能表示為數字，那么返回一個錯誤。
本操作的值限制在 64 位(bit)有符號數字表示之內。

DECRBY KEY_NAME DECREMENT_AMOUNT

127.0.0.1:6379> get age
"16"
127.0.0.1:6379> decrby age 2
(integer) 14

key 后追加新的字符串

命令用于為指定的 key 追加值。
如果 key 已經存在并且是一個字符串， APPEND 命令將 value 追加到 key 原來的值的末尾。
如果 key 不存在， APPEND 就簡單地將給定 key 設為 value ，就像執行 SET key value 一樣。

 APPEND KEY_NAME NEW_VALUE

127.0.0.1:6379> get name 
"zhangsan"
127.0.0.1:6379> append name " nihao"
(integer) 14
127.0.0.1:6379> get name
"zhangsan nihao"

list（列表）

設置列表

 lpush abc value1 value2 value3

127.0.0.1:6379> lpush abc 11 22 33 44 55
(integer) 5

移出并獲取列表的第一個元素

移出并獲取列表的第一個元素，如果列表沒有元素會阻塞列表直到等待超時或發現可彈出元素為止。

BLPOP key1 [key2 ] timeout

127.0.0.1:6379> blpop abc 1000
1) "abc"
2) "55"

移出并獲取列表的最后一個元素

移出并獲取列表的最后一個元素，如果列表沒有元素會阻塞列表直到等待超時或發現可彈出元素為止。

BRPOP key1 [key2 ] timeout

127.0.0.1:6379> brpop abc 1000
1) "abc"
2) "11"

通過索引獲取列表中的元素

LINDEX key index

127.0.0.1:6379> lrange abc 0 -1
1) "44"
2) "33"
3) "22"
127.0.0.1:6379> lindex abc 2
"22"

在列表的元素前或者后插入元素

命令用于在列表的元素前或者后插入元素。當指定元素不存在于列表中時，不執行任何操作。
當列表不存在時，被視為空列表，不執行任何操作。
如果 key 不是列表類型，返回一個錯誤

LINSERT key BEFORE|AFTER pivot value

前

127.0.0.1:6379> lrange abc 0 -1
1) "55"
2) "44"
3) "33"
4) "22"
5) "11"
127.0.0.1:6379> lpush abc 55 66
(integer) 7
127.0.0.1:6379> lrange abc 0 -1
1) "66"
2) "55"
3) "55"
4) "44"
5) "33"
6) "22"
7) "11"
127.0.0.1:6379>

后

127.0.0.1:6379> lrange abc 0 -1
1) "66"
2) "55"
3) "55"
4) "44"
5) "33"
6) "22"
7) "11"
127.0.0.1:6379> lpush abc after 11 00
(integer) 10
127.0.0.1:6379> lrange abc 0 -11) "00"2) "11"3) "after"4) "66"5) "55"6) "55"7) "44"8) "33"9) "22"
10) "11"

獲取列表長度

命令用于返回列表的長度。如果列表 key 不存在，則 key 被解釋為一個空列表，返回 0 。如果 key 不是列表類型，返回一個錯誤。

LLEN KEY_NAME

127.0.0.1:6379> llen abc
(integer) 10

移出并獲取列表的第一個元素

命令用于移除并返回列表的第一個元素

Lpop KEY_NAME

127.0.0.1:6379> lrange abc 0 -11) "00"2) "11"3) "after"4) "66"5) "55"6) "55"7) "44"8) "33"9) "22"
10) "11"
127.0.0.1:6379> lpop abc
"00"
127.0.0.1:6379> lrange abc 0 -1
1) "11"
2) "after"
3) "66"
4) "55"
5) "55"
6) "44"
7) "33"
8) "22"
9) "11"

將一個值插入到已存在的列表頭部

將一個值插入到已存在的列表頭部，列表不存在時操作無效

LPUSHX key value

127.0.0.1:6379> lpush abc liuhuan
(integer) 13
127.0.0.1:6379> lrange abc 0 -11) "liuhuan"2) "3"3) "2"4) "1"5) "11"6) "after"7) "66"8) "55"9) "55"
10) "44"
11) "33"
12) "22"
13) "11"

將一個或多個值插入到列表頭部

命令將一個或多個值插入到列表頭部。如果 key 不存在，一個空列表會被創建并執行 LPUSH 操作。當 key 存在但不是列表類型時，返回一個錯誤。

	LPUSH key value1 [value2]

127.0.0.1:6379> lpush abc 1 2 3
(integer) 12
127.0.0.1:6379> lrange abc 0 -11) "3"2) "2"3) "1"4) "11"5) "after"6) "66"7) "55"8) "55"9) "44"
10) "33"
11) "22"
12) "11"

獲取列表指定范圍內的元素

返回列表中指定區間內的元素，區間以偏移量 START 和 END 指定。其中 0 表示列表的第一個元素， 1 表示列表的第二個元素，以此類推。你也可以使用負數下標，以 -1 表示列表的最后一個元素， -2 表示列表的倒數第二個元素，以此類推。

LRANGE KEY_NAME START END

127.0.0.1:6379> lrange abc 2 5
1) "2"
2) "1"
3) "11"
4) "after"

獲取全部元素

127.0.0.1:6379> lrange abc 0 -11) "liuhuan"2) "3"3) "2"4) "1"5) "11"6) "after"7) "66"8) "55"9) "55"
10) "44"
11) "33"
12) "22"
13) "11"

移除列表元素

語法

 LREM key count VALUE

count > 0 : 從表頭開始向表尾搜索，移除與 VALUE 相等的元素，數量為 COUNT 。
count < 0 : 從表尾開始向表頭搜索，移除與 VALUE 相等的元素，數量為 COUNT 的絕對值。
count = 0 : 移除表中所有與 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"
redis>

通過索引設置列表元素的值

通過索引來設置元素的值。
當索引參數超出范圍，或對一個空列表進行 LSET 時，返回一個錯誤。

LSET key index value

4) "after"
127.0.0.1:6379> lset abc 2 zhangsan
OK
127.0.0.1:6379> lrange abc 0 -11) "liuhuan"2) "3"3) "zhangsan"4) "1"5) "11"6) "after"7) "66"8) "55"9) "55"
10) "44"
11) "33"
12) "22"
13) "11"

查找指定區間內的元素

對一個列表進行修剪(trim)，就是說，讓列表只保留指定區間內的元素，不在指定區間之內的元素都將被刪除。

127.0.0.1:6379> lrange abc 0 -11) "liuhuan"2) "3"3) "zhangsan"4) "1"5) "11"6) "after"7) "66"8) "55"9) "55"
10) "44"
11) "33"
12) "22"
13) "11"
127.0.0.1:6379> ltrim abc 3 6
OK
127.0.0.1:6379> lrange abc 0 -1
1) "1"
2) "11"
3) "after"
4) "66"

移除列表的最后一個元素，并返回

移除列表的最后一個元素，返回值為移除的元素。

127.0.0.1:6379> lrange abc 0 -1
1) "1"
2) "11"
3) "after"
4) "66"
127.0.0.1:6379> rpop abc
"66"
127.0.0.1:6379> lrange abc 0 -1
1) "1"
2) "11"
3) "after"

移除列表的最后一個元素，并將該元素添加到另一個列表并返回

命令用于移除列表的最后一個元素，并將該元素添加到另一個列表并返回。

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"

在列表中添加一個或多個值到列表尾部

127.0.0.1:6379> lrange abc 0 -1
1) "1"
2) "11"
3) "after"
127.0.0.1:6379> rpush abc 33 44 55
(integer) 6
127.0.0.1:6379> lrange abc 0 -1
1) "1"
2) "11"
3) "after"
4) "33"
5) "44"
6) "55"

為已存在的列表添加值

127.0.0.1:6379> lrange abc 0 -1
1) "1"
2) "11"
3) "after"
4) "33"
5) "44"
6) "55"
127.0.0.1:6379> rpushx abc 66
(integer) 7
127.0.0.1:6379> lrange abc 0 -1
1) "1"
2) "11"
3) "after"
4) "33"
5) "44"
6) "55"
7) "66"

hash（哈希）

刪除一個或多個哈希表字段

命令用于刪除哈希表 key 中的一個或多個指定字段，不存在的字段將被忽略。

HDEL key field1 [field2]

127.0.0.1:6379> hkeys info
1) "name"
2) "age"
3) "gender"
4) "dec"
5) "sex"
127.0.0.1:6379> hdel info  dec sex
(integer) 2
127.0.0.1:6379> hkeys info
1) "name"
2) "age"
3) "gender"

查看哈希表 key 中，指定的字段是否存在

命令用于查看哈希表的指定字段是否存在

HEXISTS key field

127.0.0.1:6379> hkeys info
1) "name"
2) "age"
3) "gender"
127.0.0.1:6379> exists info name
(integer) 1

獲取存儲在哈希表中指定字段的值

命令用于查看哈希表的指定字段是否存在

HGET key field

127.0.0.1:6379> hkeys info
1) "name"
2) "age"
3) "gender"
127.0.0.1:6379> hget info name
"zhangsan"

獲取在哈希表中指定 key 的所有字段和值

命令用于返回哈希表中，所有的字段和值。在返回值里，緊跟每個字段名(field name)之后是字段的值(value)，所以返回值的長度是哈希表大小的兩倍

HGETALL key

127.0.0.1:6379> hgetall info
1) "name"
2) "zhangsan"
3) "age"
4) "18"
5) "gender"
6) "main"

為哈希表 key 中的指定字段的整數值加上增量 increment

命令用于為哈希表中的字段值加上指定增量值。
增量也可以為負數，相當于對指定字段進行減法操作。
如果哈希表的 key 不存在，一個新的哈希表被創建并執行 HINCRBY 命令。
如果指定的字段不存在，那么在執行命令前，字段的值被初始化為 0 。
對一個儲存字符串值的字段執行 HINCRBY 命令將造成一個錯誤。
本操作的值被限制在 64 位(bit)有符號數字表示之內。

HINCRBY key field increment

127.0.0.1:6379> hget info age
"19"
127.0.0.1:6379> hincrby info age 2
(integer) 21

為哈希表 key 中的指定字段的浮點數值加上增量 increment

命令用于為哈希表中的字段值加上指定浮點數增量值。
如果指定的字段不存在，那么在執行命令前，字段的值被初始化為 0

HINCRBYFLOAT key field increment

127.0.0.1:6379> hgetall info
1) "name"
2) "zhangsan"
3) "age"
4) "21"
5) "gender"
6) "main"
7) "money"
8) "12.2"
127.0.0.1:6379> hincrbyfloat info money 1.2 
"13.4"

獲取哈希表中的所有字段

命令用于獲取哈希表中的所有域（field）

HKEYS key

127.0.0.1:6379> hkeys info
1) "name"
2) "age"
3) "gender"
4) "money"

獲取哈希表中字段的數量

令用于獲取哈希表中字段的數量

HLEN key

127.0.0.1:6379> hkeys info
1) "name"
2) "age"
3) "gender"
4) "money"
127.0.0.1:6379> hlen info
(integer) 4

獲取所有給定字段的值

命令用于返回哈希表中，一個或多個給定字段的值。
如果指定的字段不存在于哈希表，那么返回一個 nil 值

HMGET key field1 [field2]

127.0.0.1:6379> hgetall info 
1) "name"
2) "zhangsan"
3) "age"
4) "21"
5) "gender"
6) "main"
7) "money"
8) "13.4"

同時將多個 field-value (域-值)對設置到哈希表 key 中

命令用于同時將多個 field-value (字段-值)對設置到哈希表中。
此命令會覆蓋哈希表中已存在的字段。
如果哈希表不存在，會創建一個空哈希表，并執行 HMSET 操作

HMSET key field1 value1 [field2 value2 ]

127.0.0.1:6379> hmset user name zhansgan age 18 sex man
OK
127.0.0.1:6379> hgetall user
1) "name"
2) "zhansgan"
3) "age"
4) "18"
5) "sex"
6) "man"

將哈希表 key 中的字段 field 的值設為 value

命令用于為哈希表中的字段賦值。
如果哈希表不存在，一個新的哈希表被創建并進行 HSET 操作。
如果字段已經存在于哈希表中，舊值將被覆蓋。

HSET key field value

127.0.0.1:6379> hgetall info
1) "name"
2) "lisi"
3) "age"
4) "21"
5) "gender"
6) "main"
7) "money"
8) "13.4"
127.0.0.1:6379> HSET info name zhangsan
(integer) 0
127.0.0.1:6379> hgetall info
1) "name"
2) "zhangsan"
3) "age"
4) "21"
5) "gender"
6) "main"
7) "money"
8) "13.4"

只有在字段 field 不存在時，設置哈希表字段的值

命令用于為哈希表中不存在的的字段賦值。
如果哈希表不存在，一個新的哈希表被創建并進行 HSET 操作。
如果字段已經存在于哈希表中，操作無效。
如果 key 不存在，一個新哈希表被創建并執行 HSETNX 命令

HSETNX key field value

127.0.0.1:6379> hgetall info 
1) "name"
2) "zhangsan"
3) "age"
4) "21"
5) "gender"
6) "main"
7) "money"
8) "13.4"
127.0.0.1:6379> hsetnx info name 111
(integer) 0
127.0.0.1:6379> hgetall info 
1) "name"
2) "zhangsan"
3) "age"
4) "21"
5) "gender"
6) "main"
7) "money"
8) "13.4"
127.0.0.1:6379> hsetnx info address beijing
(integer) 1
127.0.0.1:6379> hgetall info 1) "name"2) "zhangsan"3) "age"4) "21"5) "gender"6) "main"7) "money"8) "13.4"9) "address"
10) "beijing"

獲取哈希表中所有值

HVALS key

127.0.0.1:6379> hkeys info
1) "name"
2) "age"
3) "gender"
4) "money"
5) "address"

迭代哈希表中的鍵值對

命令用于迭代哈希表中的鍵值對

HSCAN key cursor [MATCH pattern] [COUNT count]

> HMSET sites google "google.com" runoob "runoob.com" weibo "weibo.com" 4 "taobao.com"
OK
> HSCAN sites 0 match "run*"
1) "0"
2) 1) "runoob"
2) "runoob.com"

set（集合）

向集合添加一個或多個成員

命令將一個或多個成員元素加入到集合中，已經存在于集合的成員元素將被忽略。
假如集合 key 不存在，則創建一個只包含添加的元素作成員的集合。
當集合 key 不是集合類型時，返回一個錯誤。
注意：在 Redis2.4 版本以前， SADD 只接受單個成員值。

SADD KEY_NAME VALUE1..VALUEN

127.0.0.1:6379> sadd myset 11 22 33 44
(integer) 4
127.0.0.1:6379> smembers myset
1) "11"
2) "22"
3) "33"
4) "44"

獲取集合的成員數

命令返回集合中元素的數量

SCARD key

127.0.0.1:6379> scard myset
(integer) 4

返回第一個集合與其他集合之間的差異

命令返回第一個集合與其他集合之間的差異，也可以認為說第一個集合中獨有的元素。不存在的集合 key 將視為空集。差集的結果來自前面的 FIRST_KEY ,而不是后面的 OTHER_KEY1，也不是整個 FIRST_KEY OTHER_KEY1…OTHER_KEYN 的差集

SDIFF key1 [key2]

127.0.0.1:6379> smembers myset
1) "11"
2) "22"
3) "33"
4) "44"
127.0.0.1:6379> smembers myset1
1) "33"
2) "44"
3) "55"
4) "66"
127.0.0.1:6379> sdiff myset myset1
1) "11"
2) "22"

返回給定所有集合的差集并存儲在 destination 中

命令將給定集合之間的差集存儲在指定的集合中。如果指定的集合 key 已存在，則會被覆蓋

SDIFFSTORE destination key1 [key2]

127.0.0.1:6379> smembers myset
1) "11"
2) "22"
3) "33"
4) "44"
127.0.0.1:6379> smembers myset1
1) "33"
2) "44"
3) "55"
4) "66"
127.0.0.1:6379> sdiffstore abc  myset myset1
(integer) 2
127.0.0.1:6379> smembers abc
1) "11"
2) "22"

返回給定所有集合的交集

命令返回給定所有給定集合的交集。不存在的集合 key 被視為空集。當給定集合當中有一個空集時，結果也為空集(根據集合運算定律)。

SINTER key1 [key2]

127.0.0.1:6379> smembers myset
1) "11"
2) "22"
3) "33"
4) "44"
5) "55"
6) "66"
127.0.0.1:6379> smembers myset1
1) "33"
2) "44"
3) "55"
4) "66"
127.0.0.1:6379> sinter myset1 myset
1) "33"
2) "44"
3) "55"
4) "66"

返回給定所有集合的交集并存儲在 destination 中

命令將給定集合之間的交集存儲在指定的集合中。如果指定的集合已經存在，則將其覆蓋

SINTERSTORE destination key1 [key2]

127.0.0.1:6379> smembers myset
1) "11"
2) "22"
3) "33"
4) "44"
5) "55"
6) "66"
127.0.0.1:6379> smembers myset1
1) "33"
2) "44"
3) "55"
4) "66"
127.0.0.1:6379> sdiffstore abc  myset myset1
(integer) 2
127.0.0.1:6379> smembers abc
1) "11"
2) "22"

判斷 member 元素是否是集合 key 的成員

命令判斷成員元素是否是集合的成員

SISMEMBER key member

127.0.0.1:6379> smembers myset1
1) "33"
2) "44"
3) "55"
4) "66"
127.0.0.1:6379> sismember myset1 33
(integer) 1

返回集合中的所有成員

命令返回集合中的所有的成員。不存在的集合 key 被視為空集合

SMEMBERS key

127.0.0.1:6379> smembers myset
1) "11"
2) "22"
3) "33"
4) "44"
5) "55"
6) "66"

將 member 元素從 source 集合移動到 destination 集合

命令將指定成員 member 元素從 source 集合移動到 destination 集合。
SMOVE 是原子性操作。如果 source 集合不存在或不包含指定的 member 元素，則 SMOVE 命令不執行任何操作，僅返回 0 。否則， member 元素從 source 集合中被移除，并添加到 destination 集合中去。
當 destination 集合已經包含 member 元素時， SMOVE 命令只是簡單地將 source 集合中的 member 元素刪除。當 source 或 destination 不是集合類型時，返回一個錯誤。

SMOVE source destination member

127.0.0.1:6379> smembers myset
1) "11"
2) "22"
3) "33"
4) "44"
5) "55"
6) "66"
127.0.0.1:6379> smembers myset1
1) "33"
2) "44"
3) "55"
4) "66"
127.0.0.1:6379> smove myset myset1 11
(integer) 1
127.0.0.1:6379> smembers myset
1) "22"
2) "33"
3) "44"
4) "55"
5) "66"
127.0.0.1:6379> smembers myset1
1) "11"
2) "33"
3) "44"
4) "55"
5) "66"

移除并返回集合中的一個隨機元素

命令用于移除集合中的指定 key 的一個或多個隨機元素，移除后會返回移除的元素。該命令類似 Srandmember 命令，但 SPOP 將隨機元素從集合中移除并返回，而 Srandmember 則僅僅返回隨機元素，而不對集合進行任何改動。

SPOP key [count]

127.0.0.1:6379> smembers myset1
1) "11"
2) "33"
3) "44"
4) "55"
5) "66"
127.0.0.1:6379> spop myset 1
1) "55"
127.0.0.1:6379> smembers myset
1) "22"
2) "33"
3) "44"
4) "66"

返回集合中一個或多個隨機數

Redis Srandmember 命令用于返回集合中的一個隨機元素。
從 Redis 2.6 版本開始， Srandmember 命令接受可選的 count 參數：
如果 count 為正數，且小于集合基數，那么命令返回一個包含 count 個元素的數組，數組中的元素各不相同。如果 count 大于等于集合基數，那么返回整個集合。
如果 count 為負數，那么命令返回一個數組，數組中的元素可能會重復出現多次，而數組的長度為 count 的絕對值。
該操作和 SPOP 相似，但 SPOP 將隨機元素從集合中移除并返回，而 Srandmember 則僅僅返回隨機元素，而不對集合進行任何改動

SRANDMEMBER key [count]

127.0.0.1:6379> smembers myset
1) "22"
2) "33"
3) "44"
4) "66"
127.0.0.1:6379> srandmember myset
"66"
127.0.0.1:6379> srandmember myset
"66"
127.0.0.1:6379> srandmember myset
"66"
127.0.0.1:6379> srandmember myset
"44"
127.0.0.1:6379> srandmember myset
"22"

移除集合中一個或多個成員

命令用于移除集合中的一個或多個成員元素，不存在的成員元素會被忽略。
當 key 不是集合類型，返回一個錯誤。
在 Redis 2.4 版本以前， SREM 只接受單個成員值

SREM key member1 [member2]

127.0.0.1:6379> smembers myset
1) "22"
2) "33"
3) "44"
4) "66"
127.0.0.1:6379> srem myset 22 33
(integer) 2
127.0.0.1:6379> smembers myset
1) "44"
2) "66"

返回所有給定集合的并集

命令返回給定集合的并集。不存在的集合 key 被視為空集

SUNION key1 [key2]

127.0.0.1:6379> smembers myset
1) "44"
2) "66"
127.0.0.1:6379> smembers myset1
1) "11"
2) "33"
3) "44"
4) "55"
5) "66"
127.0.0.1:6379> sunion myset myset1
1) "11"
2) "33"
3) "44"
4) "55"
5) "66"

所有給定集合的并集存儲在 destination 集合中

命令將給定集合的并集存儲在指定的集合 destination 中。如果 destination 已經存在，則將其覆蓋

SUNIONSTORE destination key1 [key2]

127.0.0.1:6379> smembers myset
1) "44"
2) "66"
127.0.0.1:6379> smembers myset1
1) "11"
2) "33"
3) "44"
4) "55"
5) "66"
127.0.0.1:6379> sunionstore abc myset myset1
(integer) 5
127.0.0.1:6379> smembers abc
1) "11"
2) "33"
3) "44"
4) "55"
5) "66"

迭代集合中的元素

命令用于迭代集合中鍵的元素

cursor - 游標
pattern - 匹配的模式
count - 指定從數據集里返回多少元素，默認值為 10

SSCAN key cursor [MATCH pattern] [COUNT count]

> SADD myset1 "Google"
(integer) 1
> SADD myset1 "Runoob"
(integer) 1
> SADD myset1 "Taobao"
(integer) 1
> SSCAN myset1 0 match R*
1) "0"
2) 1) "Runoob"

zset(sorted set）

向有序集合添加一個或多個成員，或者更新已存在成員的分數

ZADD key score1 member1 [score2 member2]

127.0.0.1:6379> zadd score  1 "one" 2 "two"
(integer) 2
127.0.0.1:6379> zrange score 0 -1 withscores
1) "one"
2) "1"
3) "two"
4) "2"

獲取有序集合的成員數

ZCARD key

127.0.0.1:6379> zrange score 0 -1 withscores
1) "one"
2) "1"
3) "two"
4) "2"
127.0.0.1:6379> zcard score
(integer) 2

計算在有序集合中指定區間分數的成員數

ZCOUNT key min max

127.0.0.1:6379> zadd info 1.0 "shuxue" 2.0 "yuwen" 3.0 "yingyu"
(integer) 3
127.0.0.1:6379> zrange info 0 -1 withscores
1) "shuxue"
2) "1"
3) "yuwen"
4) "2"
5) "yingyu"
6) "3"

有序集合中對指定成員的分數加上增量 increment

ZINCRBY key increment member

127.0.0.1:6379> zrange info 0 -1 withscores
1) "shuxue"
2) "1"
3) "yuwen"
4) "2"
5) "yingyu"
6) "3"
127.0.0.1:6379> zincrby info 11 shuxue
"12"
127.0.0.1:6379> zrange info 0 -1 withscores
1) "yuwen"
2) "2"
3) "yingyu"
4) "3"
5) "shuxue"
6) "12"

計算給定的一個或多個有序集的交集并將結果集存儲在新的有序集合 destination 中

ZINTERSTORE destination numkeys key [key ...]

127.0.0.1:6379> zadd zset1 1 shuxue 2 yuwen 3 yingyu
(integer) 3
127.0.0.1:6379> zadd zset2 2 dili 3 yingyu 4 zhengzhi
(integer) 3
127.0.0.1:6379> zinterstore sum_point 2 zset1 zset2
(integer) 1
127.0.0.1:6379> zrange sum_point 0 -1 withscores
1) "yingyu"
2) "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

通過索引區間返回有序集合指定區間內的成員

ZRANGE key start stop [WITHSCORES]

127.0.0.1:6379> zadd info 1.0 "shuxue" 2.0 "yuwen" 3.0 "yingyu"
(integer) 3
127.0.0.1:6379> zrange info 0 -1 withscores
1) "shuxue"
2) "1"
3) "yuwen"
4) "2"
5) "yingyu"
6) "3"

通過字典區間返回有序集合的成員

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"
redis>

通過分數返回有序集合指定區間內的成員

返回有序集合中指定分數區間的成員列表。有序集成員按分數值遞增(從小到大)次序排列。
具有相同分數值的成員按字典序來排列(該屬性是有序集提供的，不需要額外的計算)。
默認情況下，區間的取值使用閉區間 (小于等于或大于等于)，你也可以通過給參數前增加 ( 符號來使用可選的開區間 (小于或大于)。

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) 0redis 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"

返回有序集合中指定成員的索引

返回有序集中指定成員的排名。其中有序集成員按分數值遞增(從小到大)順序排列

ZRANK key member

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

移除有序集合中的一個或多個成員

令用于移除有序集中的一個或多個成員，不存在的成員將被忽略。
當 key 存在但不是有序集類型時，返回一個錯誤。

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) 1redis 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) 2redis 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

移除有序集合中給定的字典區間的所有成員

命令用于移除有序集中，指定排名(rank)區間內的所有成

ZREMRANGEBYLEX key min max

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) 1redis 127.0.0.1:6379> ZREMRANGEBYRANK salary 0 1       # 移除下標 0 至 1 區間內的成員
(integer) 2redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES    # 有序集只剩下一個成員
1) "tom"
2) "5000"

移除有序集合中給定的排名區間的所有成員

命令用于移除有序集中，指定排名(rank)區間內的所有成員

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) 1redis 127.0.0.1:6379> ZREMRANGEBYRANK salary 0 1       # 移除下標 0 至 1 區間內的成員
(integer) 2redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES    # 有序集只剩下一個成員
1) "tom"
2) "5000"

移除有序集合中給定的分數區間的所有成員

Zremrangebyscore 命令用于移除有序集中，指定分數（score）區間內的所有成員

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) 2redis> ZRANGE salary 0 -1 WITHSCORES          # 剩下的有序集成員
1) "jack"
2) "5000"

返回有序集中指定區間內的成員，通過索引，分數從高到低

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"

返回有序集中指定分數區間內的成員，分數從高到低排序

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) 1redis 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"

返回有序集合中指定成員的排名，有序集成員按分數值遞減(從大到小)排序

	ZREVRANK key member

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) 1redis 127.0.0.1:6379> ZREVRANK salary tom       # tom 的工資最高
(integer) 0

返回有序集中，成員的分數值

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"

計算給定的一個或多個有序集的并集，并存儲在新的 key 中

ZUNIONSTORE destination numkeys key [key ...]

redis> ZADD zset1 1 "one"
(integer) 1
redis> ZADD zset1 2 "two"
(integer) 1
redis> ZADD zset2 1 "one"
(integer) 1
redis> ZADD zset2 2 "two"
(integer) 1
redis> ZADD zset2 3 "three"
(integer) 1
redis> ZUNIONSTORE out 2 zset1 zset2 WEIGHTS 2 3
(integer) 3
redis> ZRANGE out 0 -1 WITHSCORES
1) "one"
2) "5"
3) "three"
4) "9"
5) "two"
6) "10"
redis>

迭代有序集合中的元素（包括元素成員和元素分值）

ZSCAN key cursor [MATCH pattern] [COUNT count]

> ZADD site 1 "Google" 2 "Runoob" 3 "Taobao" 4 "Weibo"
(integer) 4
> ZSCAN site 0 match "R*"
1) "0"
2) 1) "Runoob"
2) 2.0