Redis

Redis命令

Redis 命令用于在 redis 服务上执行操作。

语法

Redis 客户端的基本语法为:

$ redis-cli

在远程服务上执行命令

$redis-cli -h 127.0.0.1 -p 6379 -a "mypass"
redis 127.0.0.1:6379>
redis 127.0.0.1:6379> PING

PONG

Redis 键(key)

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

语法

redis 127.0.0.1:6379> COMMAND KEY_NAME

实例

redis 127.0.0.1:6379> SET runoobkey redis
OK
redis 127.0.0.1:6379> DEL runoobkey
(integer) 1

如果键被删除成功,命令执行后输出 (integer) 1,否则将输出 (integer) 0

Redis keys 命令

del key

该命令用于在 key 存在时删除 key

被删除 key 的数量。

127.0.0.1:6379> SET name redis
OK

127.0.0.1:6379> DEL w3ckey
(integer) 1

dump key

序列化给定 key ,并返回被序列化的值。

如果 key 不存在,那么返回 nil 。 否则,返回序列化之后的值。

127.0.0.1:6379> set name redis
OK
127.0.0.1:6379> dump name
"\x00\x05redis\t\x00\x15\xa2\xf8=\xb6\xa9\xde\x90"
127.0.0.1:6379> dump helloworld
(nil)

exists key

检查给定 key 是否存在。

key 存在返回 1 ,否则返回 0 。

127.0.0.1:6379> exists name
(integer) 1
127.0.0.1:6379> exists helloworld
(integer) 0

expire key seconds

为给定 key 设置过期时间,以秒计。

设置成功返回 1 。 当 key 不存在或者不能为 key 设置过期时间时(比如在低于 2.1.3 版本的 Redis 中你尝试更新 key 的过期时间)返回 0 。

127.0.0.1:6379> expire name 15
(integer) 1
127.0.0.1:6379> expire helloworld 14
(integer) 0

expireat key timestamp

EXPIREAT 的作用和 EXPIRE 类似,都用于为 key 设置过期时间。 不同在于 EXPIREAT 命令接受的时间参数是 UNIX 时间戳(unix timestamp)。

设置成功返回 1 。 当 key 不存在或者不能为 key 设置过期时间时(比如在低于 2.1.3 版本的 Redis 中你尝试更新 key 的过期时间)返回 0 。

127.0.0.1:6379> expireat name 1602055688
(integer) 1
127.0.0.1:6379> expireat redis 444
(integer) 0
127.0.0.1:6379> ttl name
(integer) 2789

pexpire key milliseconds

设置 key 的过期时间以毫秒计。

设置成功,返回 1,key 不存在或设置失败,返回 0

127.0.0.1:6379> pexpire name 16000
(integer) 1
127.0.0.1:6379> ttl name
(integer) 12
127.0.0.1:6379> pttl name
(integer) 155577
127.0.0.1:6379> pexpire helloworld 12000
(integer) 0

pexpireat key milliseconds-timestamp

设置 key 过期时间的时间戳(unix timestamp) 以毫秒计

设置成功,返回 1,key 不存在或设置失败,返回 0

127.0.0.1:6379> SET runoobkey redis
OK
127.0.0.1:6379> PEXPIREAT runoobkey 1555555555005
(integer) 1

keys pattern

查找所有符合给定模式( pattern)的 key

返回符合给定模式的 key 列表 (Array)。

127.0.0.1:6379> set name1 1
OK
127.0.0.1:6379> set name2 3444
OK
127.0.0.1:6379> set name3 4343
OK
127.0.0.1:6379> keys name*
1) "name1"
2) "name2"
3) "name3"

move key db

将当前数据库的 key 移动到给定的数据库 db 当中。

移动成功返回 1 ,失败则返回 0 。

# key 存在于当前数据库

redis> SELECT 0                             # redis默认使用数据库 0,为了清晰起见,这里再显式指定一次。
OK

redis> SET song "secret base - Zone"
OK

redis> MOVE song 1                          # 将 song 移动到数据库 1
(integer) 1

redis> EXISTS song                          # song 已经被移走
(integer) 0

redis> SELECT 1                             # 使用数据库 1
OK

redis:1> EXISTS song                        # 证实 song 被移到了数据库 1 (注意命令提示符变成了"redis:1",表明正在使用数据库 1)
(integer) 1


# 当 key 不存在的时候

redis:1> EXISTS fake_key
(integer) 0

redis:1> MOVE fake_key 0                    # 试图从数据库 1 移动一个不存在的 key 到数据库 0,失败
(integer) 0

redis:1> select 0                           # 使用数据库0
OK

redis> EXISTS fake_key                      # 证实 fake_key 不存在
(integer) 0


# 当源数据库和目标数据库有相同的 key 时

redis> SELECT 0                             # 使用数据库0
OK
redis> SET favorite_fruit "banana"
OK

redis> SELECT 1                             # 使用数据库1
OK
redis:1> SET favorite_fruit "apple"
OK

redis:1> SELECT 0                           # 使用数据库0,并试图将 favorite_fruit 移动到数据库 1
OK

redis> MOVE favorite_fruit 1                # 因为两个数据库有相同的 key,MOVE 失败
(integer) 0

redis> GET favorite_fruit                   # 数据库 0 的 favorite_fruit 没变
"banana"

redis> SELECT 1
OK

redis:1> GET favorite_fruit                 # 数据库 1 的 favorite_fruit 也是
"apple"

persist key

移除 key 的过期时间,key 将持久保持。

当过期时间移除成功时,返回 1 。 如果 key 不存在或 key 没有设置过期时间,返回 0 。

127.0.0.1:6379> set name test
OK
127.0.0.1:6379> expire name 15
(integer) 1
127.0.0.1:6379> ttl name
(integer) 13
127.0.0.1:6379> persist name
(integer) 1
127.0.0.1:6379> ttl name
(integer) -1

pttl key

以毫秒为单位返回 key 的剩余的过期时间。

key 不存在时,返回 -2 。 当 key 存在但没有设置剩余生存时间时,返回 -1 。 否则,以毫秒为单位,返回 key 的剩余生存时间。

注意:在 Redis 2.8 以前,当 key 不存在,或者 key 没有设置剩余生存时间时,命令都返回 -1 。

127.0.0.1:6379> ttl name
(integer) -1
127.0.0.1:6379> pttl name
(integer) -1
127.0.0.1:6379> pttl test
(integer) -2
127.0.0.1:6379> set test 43
OK
127.0.0.1:6379> expire test 13
(integer) 1
127.0.0.1:6379> pttl test
(integer) 5432

ttl key

以秒为单位,返回给定 key 的剩余生存时间(TTL, time to live)。

key 不存在时,返回 -2 。 当 key 存在但没有设置剩余生存时间时,返回 -1 。 否则,以秒为单位,返回 key 的剩余生存时间。

注意:在 Redis 2.8 以前,当 key 不存在,或者 key 没有设置剩余生存时间时,命令都返回 -1 。

# 不存在的 key

redis> FLUSHDB
OK

redis> TTL key
(integer) -2


# key 存在,但没有设置剩余生存时间

redis> SET key value
OK

redis> TTL key
(integer) -1


# 有剩余生存时间的 key

redis> EXPIRE key 10086
(integer) 1

redis> TTL key
(integer) 10084

randomkey

当数据库不为空时,返回一个 key 。 当数据库为空时,返回 nilwindows 系统返回 null)。

从当前数据库中随机返回一个 key

27.0.0.1:6379>  MSET fruit "apple" drink "beer" food "cookies"
OK
127.0.0.1:6379> randomkey
"food"
127.0.0.1:6379> randomkey
"drink"
127.0.0.1:6379> randomkey
"fruit"
127.0.0.1:6379> randomkey
"fruit"
127.0.0.1:6379> randomkey
"food"
127.0.0.1:6379>

127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> randomkey
(nil)
127.0.0.1:6379>

rename key newkey

修改 key 的名称

改名成功时提示 OK ,失败时候返回一个错误。

OLD_KEY_NAMENEW_KEY_NAME 相同,或者 OLD_KEY_NAME 不存在时,返回一个错误。 当 NEW_KEY_NAME 已经存在时, RENAME 命令将覆盖旧值。

# key 存在且 newkey 不存在

redis> SET message "hello world"
OK

redis> RENAME message greeting
OK

redis> EXISTS message               # message 不复存在
(integer) 0

redis> EXISTS greeting              # greeting 取而代之
(integer) 1


# 当 key 不存在时,返回错误

redis> RENAME fake_key never_exists
(error) ERR no such key


# newkey 已存在时, RENAME 会覆盖旧 newkey

redis> SET pc "lenovo"
OK

redis> SET personal_computer "dell"
OK

redis> RENAME pc personal_computer
OK

redis> GET pc
(nil)

redis:1> GET personal_computer      # 原来的值 dell 被覆盖了
"lenovo"

renamenx key newkey

仅当 newkey 不存在时,将 key 改名为 newkey

修改成功时,返回 1 。 如果 NEW_KEY_NAME 已经存在,返回 0 。

# newkey 不存在,改名成功

redis> SET player "MPlyaer"
OK

redis> EXISTS best_player
(integer) 0

redis> RENAMENX player best_player
(integer) 1


# newkey存在时,失败

redis> SET animal "bear"
OK

redis> SET favorite_animal "butterfly"
OK

redis> RENAMENX animal favorite_animal
(integer) 0

redis> get animal
"bear"

redis> get favorite_animal
"butterfly"

flushdb

清空当前所处的db

成功返回ok

127.0.0.1:6379> flushdb
OK

type key

返回 key 所储存的值的类型。

Redis 字符串(String)

语法

redis 127.0.0.1:6379> COMMAND KEY_NAME

实例

127.0.0.1:6379> set name redis
OK
127.0.0.1:6379> get name
"redis"

Redis字符串命令

set key value

设置指定 key 的值

Redis 2.6.12 以前版本,SET 命令总是返回 OK

Redis 2.6.12 版本开始, SET在设置操作成功完成时,才返回 OK

# 对不存在的键进行设置

127.0.0.1:6379> SET key "value"
OK

127.0.0.1:6379> GET key
"value"


# 对已存在的键进行设置

127.0.0.1:6379> SET key "new-value"
OK

127.0.0.1:6379> GET key
"new-value"

get key

获取指定 key 的值。

返回 key 的值,如果 key 不存在时,返回 nil。 如果 key 不是字符串类型,那么返回一个错误。

# 对不存在的 key 或字符串类型 key 进行 GET

127.0.0.1:6379> GET db
(nil)

127.0.0.1:6379> SET db redis
OK

127.0.0.1:6379> GET db
"redis"


# 对不是字符串类型的 key 进行 GET

127.0.0.1:6379> DEL db
(integer) 1

127.0.0.1:6379> LPUSH db redis mongodb mysql
(integer) 3

127.0.0.1:6379> GET db
(error) ERR Operation against a key holding the wrong kind of value

getrange key start end

返回key 中字符串值的子字符

截取得到的子字符串。如果key不存在,返回的为""

127.0.0.1:6379> set name redis
OK
127.0.0.1:6379> getrange name 0 2
"red"
127.0.0.1:6379> set name redis
OK
127.0.0.1:6379> getrange name 1 2
"ed"
127.0.0.1:6379> getrange test 1 3
""

getset key value

将给定 key 的值设为 value ,并返回 key 的旧值(old value)。

返回给定 key 的旧值。 当 key 没有旧值时,即 key 不存在时,返回 nil

key 存在但不是字符串类型时,返回一个错误。

““shell
redis> GETSET db mongodb # 没有旧值,返回 nil
(nil)

redis> GET db
“mongodb”

redis> GETSET db redis # 返回旧值 mongodb
“mongodb”

redis> GET db
“redis”

### `mget key1 [key2...]`

获取所有(一个或多个)给定 `key` 的值。

一个包含所有给定` key` 的值的列表。

```shell
127.0.0.1:6379> set key1 test
OK
127.0.0.1:6379> set key2 test1
OK
127.0.0.1:6379> set key3 ss
OK
127.0.0.1:6379> mget key1 key2 key3
1) "test"
2) "test1"
3) "ss"


127.0.0.1:6379> mget key1 key3 key
1) "test"
2) "ss"
3) (nil)
127.0.0.1:6379>

setex key seconds value

将值 value 关联到 key ,并将 key 的过期时间设为 seconds (以秒为单位)。

设置成功时返回 OK

127.0.0.1:6379> setex test 12 hello
OK
127.0.0.1:6379> ttl test
(integer) 8

strlen key

返回 key 所储存的字符串值的长度。

返回字符串值的长度。 当 key 不存在时,返回 0。

127.0.0.1:6379> set name test
OK
127.0.0.1:6379> strlen name
(integer) 4
127.0.0.1:6379> strlen test
(integer) 0

mset key1 value1 [key2 value2 ...]

同时设置一个或多个key-value 对。

总是返回 OK

127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3
OK
127.0.0.1:6379> mget k1 k2 k3
1) "v1"
2) "v2"
3) "v3"

msetnx key1 value1 [key2 value2 ...]

同时设置一个或多个 key-value 对,当且仅当所有给定 key 都不存在。

当所有 key 都成功设置,返回 1 。 如果所有给定 key 都设置失败(至少有一个 key 已经存在),那么返回 0 。

127.0.0.1:6379> msetnx k test k5 s k6 x
(integer) 1
127.0.0.1:6379> msetnx k 11 k8 xx
(integer) 0

psetex key milliseconds value

这个命令和 SETEX 命令相似,但它以毫秒为单位设置 key 的生存时间,而不是像 SETEX 命令那样,以秒为单位。

设置成功时返回 OK

127.0.0.1:6379> psetex test 14000 hello
OK
127.0.0.1:6379> ttl test
(integer) 10
127.0.0.1:6379> pttl test
(integer) 4333
127.0.0.1:6379>

incr key

key 中储存的数字值增一。

返回执行 INCR 命令之后 key 的值。

127.0.0.1:6379> set name 1
OK
127.0.0.1:6379> incr name
(integer) 2
127.0.0.1:6379> incr name
(integer) 3
127.0.0.1:6379> incr name
(integer) 4
127.0.0.1:6379> incr name
(integer) 5
127.0.0.1:6379> incr name
(integer) 6

127.0.0.1:6379> set name test
OK
127.0.0.1:6379> incr name
(error) ERR value is not an integer or out of range

incrby key increment

key 所储存的值加上给定的增量值(increment) 。

加上指定的增量值之后, key 的值。

127.0.0.1:6379> set name 1
OK
127.0.0.1:6379> incrby name 10
(integer) 11
127.0.0.1:6379> get name
"11"
127.0.0.1:6379> incrby name 22
(integer) 33
127.0.0.1:6379> get name
"33"

incrbyfloat key float

key 所储存的值加上给定的浮点增量值(increment) 。

执行命令之后 key 的值。

127.0.0.1:6379> set test 13
OK
127.0.0.1:6379> incrby test 24
(integer) 37
127.0.0.1:6379> incrbyfloat test 23.43
"60.43"
127.0.0.1:6379> get test
"60.43"

decr key

key 中储存的数字值减一。

返回执行命令之后 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

decrby key decrement

key 所储存的值减去给定的减量值(decrement) 。

返回减去指定减量值之后, key 的值。

如果 key 不存在,那么 key 的值会先被初始化为 0 ,然后再执行 DECRBY 操作。

如果值包含错误的类型,或字符串类型的值不能表示为数字,那么返回一个错误。

本操作的值限制在 64 位(bit)有符号数字表示之内。

# 对已存在的 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

append key value

如果 key 已经存在并且是一个字符串, APPEND 命令将指定的 value 追加到该 key 原来值(value)的末尾。

如果 key 已经存在并且是一个字符串, APPEND 命令将 value 追加到 key 原来的值的末尾。

如果 key 不存在, APPEND 就简单地将给定 key 设为 value ,就像执行 SET 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 是一个 string 类型的 field(字段) 和 value(值) 的映射表,hash 特别适合用于存储对象。

Redis 中每个hash 可以存储 2^32 – 1 键值对(40多亿)。

实例

127.0.0.1:6379>  HMSET runoobkey name "redis tutorial" description "redis basic commands for caching" likes 20 visitors 23000
OK
127.0.0.1:6379>  HGETALL runoobkey
1) "name"
2) "redis tutorial"
3) "description"
4) "redis basic commands for caching"
5) "likes"
6) "20"
7) "visitors"
8) "23000"

Redis hash 命令

hdel key field1 [field2]

删除一个或多个哈希表字段

返回被成功删除字段的数量,不包括被忽略的字段。

127.0.0.1:6379> hmset test f1 hello f2 world f3 ezreal
OK
127.0.0.1:6379> hgetall test
1) "f1"
2) "hello"
3) "f2"
4) "world"
5) "f3"
6) "ezreal"
127.0.0.1:6379> hdel test f1 f4
(integer) 1
127.0.0.1:6379>

hexists key field

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

如果哈希表含有给定字段,返回 1 。 如果哈希表不含有给定字段,或 key 不存在,返回 0 。

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

hget key field

获取存储在哈希表中指定字段的值。

返回给定字段的值。如果给定的字段或 key 不存在时,返回 nil

# 字段存在

redis> HSET site redis redis.com
(integer) 1

redis> HGET site redis
"redis.com"


# 字段不存在

redis> HGET site mysql
(nil)

hgetall key

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

以列表形式返回哈希表的字段及字段值。 若 key 不存在,返回空列表。

在返回值里,紧跟每个字段名(field name)之后是字段的值(value),所以返回值的长度是哈希表大小的两倍。

127.0.0.1:6379> hmset test f1 hello f2 world f3 test
OK
127.0.0.1:6379> hgetall test
1) "f1"
2) "hello"
3) "f2"
4) "world"
5) "f3"
6) "test"

hincrby key field increment

Redis Hincrby 命令用于为哈希表中的字段值加上指定增量值。

增量也可以为负数,相当于对指定字段进行减法操作。

如果哈希表的 key 不存在,一个新的哈希表被创建并执行 HINCRBY 命令。

如果指定的字段不存在,那么在执行命令前,字段的值被初始化为 0 。

对一个储存字符串值的字段执行 HINCRBY 命令将造成一个错误。

本操作的值被限制在 64 位(bit)有符号数字表示之内。

127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> hset test f1 14
(integer) 1
127.0.0.1:6379> hincrby test f1 -10
(integer) 4
127.0.0.1:6379> hincrby test f1 3
(integer) 7
127.0.0.1:6379> hincrby test f2 18
(integer) 18
127.0.0.1:6379> hget test f2
"18"
127.0.0.1:6379>

hincrbyfloat key field float

Redis Hincrbyfloat 命令用于为哈希表中的字段值加上指定浮点数增量值。

如果指定的字段不存在,那么在执行命令前,字段的值被初始化为 0 。

redis> HSET mykey field 10.50
(integer) 1
redis> HINCRBYFLOAT mykey field 0.1
"10.6"
redis> HINCRBYFLOAT mykey field -5
"5.6"
redis> HSET mykey field 5.0e3
(integer) 0
redis> HINCRBYFLOAT mykey field 2.0e2
"5200"

hkeys key

Redis Hkeys 命令用于获取哈希表中的所有域(field)。

返回包含哈希表中所有域(field)列表。 当 key 不存在时,返回一个空列表。

127.0.0.1:6379> hkeys test
1) "f1"
2) "f2"
127.0.0.1:6379> hkeys h
(empty list or set)

hlen key

获取哈希表中字段的数量

返回哈希表中字段的数量。 当 key 不存在时,返回 0 。

127.0.0.1:6379> hmset test f1 2 f2 2 f3 3 f4 4
OK
127.0.0.1:6379> hlen test
(integer) 4
127.0.0.1:6379>

hmget key field1 [field2...]

获取所有给定字段的值。

返回一个包含多个给定字段关联值的表,表值的排列顺序和指定字段的请求顺序一样。如果指定的字段不存在于哈希表,那么返回一个 nil 值。

127.0.0.1:6379> hmget test f1 f2 f9
1) "2"
2) "2"
3) (nil)

hmset key field1 value1 [field2 value2 ...]

同时将多个 field-value (域-值)对设置到哈希表 key 中。

如果命令执行成功,返回 OK

127.0.0.1:6379> hmset test f1 2 f2 2 f3 3 f4 4
OK

hset key field value

将哈希表 key 中的字段 field 的值设为 value

127.0.0.1:6379> hmset test f hello
OK

hsetnx key field value

用于为哈希表中不存在的的字段赋值 。

如果哈希表不存在,一个新的哈希表被创建并进行 HSET 操作。

如果字段已经存在于哈希表中,操作无效。

如果 key 不存在,一个新哈希表被创建并执行 HSETNX 命令。

127.0.0.1:6379> hmset test f hello
OK
127.0.0.1:6379> hsetnx test f 1233
(integer) 0
127.0.0.1:6379> hsetnx test f1 1234
(integer) 1
127.0.0.1:6379> hsetnx test1 f 1233343
(integer) 1
127.0.0.1:6379>

hvals key

获取哈希表中所有值。

一个包含哈希表中所有域(field)值的列表。 当 key 不存在时,返回一个空表。

127.0.0.1:6379> hvals test
1) "hello"
2) "1234"
127.0.0.1:6379> hvals tt
(empty list or set)

Redis 列表(List)

实例

redis 127.0.0.1:6379> LPUSH runoobkey redis
(integer) 1
redis 127.0.0.1:6379> LPUSH runoobkey mongodb
(integer) 2
redis 127.0.0.1:6379> LPUSH runoobkey mysql
(integer) 3
redis 127.0.0.1:6379> LRANGE runoobkey 0 10

1) "mysql"
2) "mongodb"
3) "redis"

Redis 列表命令

blpop key key1 ... timeout

Redis Blpop 命令移出并获取列表的第一个元素, 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。

假如在指定时间内没有任何元素被弹出,则返回一个 nil 和等待时长 。 否则,返回一个含有两个元素的列表,第一个元素是被弹出元素所属的 key ,第二个元素是被弹出元素的值。

127.0.0.1:6379> lrange db 0 10
1) "memercache"
2) "mysql"
3) "redis"
127.0.0.1:6379> lrange db 0 3
1) "memercache"
2) "mysql"
3) "redis"
127.0.0.1:6379> blpop db 10
1) "db"
2) "memercache"
127.0.0.1:6379> blpop db 10
1) "db"
2) "mysql"
127.0.0.1:6379> blpop db 10
1) "db"
2) "redis"
127.0.0.1:6379> blpop db 10
(nil)
(10.06s)
127.0.0.1:6379>

brpop key key1 ... timeout

Redis Brpop命令移出并获取列表的最后一个元素, 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。

假如在指定时间内没有任何元素被弹出,则返回一个 nil 和等待时长。 反之,返回一个含有两个元素的列表,第一个元素是被弹出元素所属的 key ,第二个元素是被弹出元素的值。

127.0.0.1:6379> lpush db redis
(integer) 1
127.0.0.1:6379> lpush db mysql
(integer) 2
127.0.0.1:6379> lpush db nosql
(integer) 3
127.0.0.1:6379> brpop db 10
1) "db"
2) "redis"
127.0.0.1:6379> brpop db 10
1) "db"
2) "mysql"
127.0.0.1:6379> brpop db 10
1) "db"
2) "nosql"
127.0.0.1:6379> brpop db 10
(nil)
(10.15s)
127.0.0.1:6379>

brpoplpush source destination timeout

Redis Brpoplpush 命令从列表中取出最后一个元素,并插入到另外一个列表的头部; 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。

假如在指定时间内没有任何元素被弹出,则返回一个 nil和等待时长。 反之,返回一个含有两个元素的列表,第一个元素是被弹出元素的值,第二个元素是等待时长。

# 非空列表

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)

lindex key index

Redis Lindex 命令用于通过索引获取列表中的元素。你也可以使用负数下标,以 -1 表示列表的最后一个元素, -2 表示列表的倒数第二个元素,以此类推。

返回列表中下标为指定索引值的元素。 如果指定索引值不在列表的区间范围内,返回 nil

127.0.0.1:6379> lindex db 0
"redis"
127.0.0.1:6379> lindex db 1
"postgresql"
127.0.0.1:6379> lindex db 2
"mysql"
127.0.0.1:6379> lindex db 3
(nil)
127.0.0.1:6379> lrange db 0 10
1) "redis"
2) "postgresql"
3) "mysql"
127.0.0.1:6379>

llen key

Redis Llen 命令用于返回列表的长度。 如果列表 key 不存在,则 key 被解释为一个空列表,返回 0 。 如果 key 不是列表类型,返回一个错误。

返回列表的长度。

127.0.0.1:6379> set name redis
OK
127.0.0.1:6379> llen name
(error) WRONGTYPE Operation against a key holding the wrong kind of value
127.0.0.1:6379>
127.0.0.1:6379> lpush db redis
(integer) 1
127.0.0.1:6379> lpush db mysql
(integer) 2
127.0.0.1:6379> lpush db postgresql
(integer) 3
127.0.0.1:6379> llen db
(integer) 3
127.0.0.1:6379> llen db1
(integer) 0
127.0.0.1:6379>

lpop key

Redis Lpop命令用于移除并返回列表的第一个元素。

列表的第一个元素。 当列表 key 不存在时,返回 nil

127.0.0.1:6379> lrange db 0 10
1) "postgresql"
2) "mysql"
3) "redis"
127.0.0.1:6379> lpop db
"postgresql"
127.0.0.1:6379> lpop db1
(nil)
127.0.0.1:6379>

lpush key value [value1 value2 ...]

Redis Lpush 命令将一个或多个值插入到列表头部。 如果 key 不存在,一个空列表会被创建并执行 LPUSH 操作。 当 key 存在但不是列表类型时,返回一个错误。

Redis 2.4版本以前的 LPUSH 命令,都只接受单个 value 值。

执行 LPUSH 命令后,列表的长度。

127.0.0.1:6379> lpush db redids mysql postgresql memercache
(integer) 4
127.0.0.1:6379> lrange db 0 10
1) "memercache"
2) "postgresql"
3) "mysql"
4) "redids"
127.0.0.1:6379> set name redis
OK
127.0.0.1:6379> lpush name h
(error) WRONGTYPE Operation against a key holding the wrong kind of value
127.0.0.1:6379>

lpushx key value [value1 value2 value3 ...]

Redis Lpushx 将一个值插入到已存在的列表头部,列表不存在时操作无效。

LPUSHX 命令执行之后,列表的长度。

127.0.0.1:6379> lpush db redis mysql
(integer) 2
127.0.0.1:6379> lpushx db nosql
(integer) 3
127.0.0.1:6379> lrange db 0 10
1) "nosql"
2) "mysql"
3) "redis"
127.0.0.1:6379>

lrange key start stop

Redis Lrange 返回列表中指定区间内的元素,区间以偏移量 STARTEND 指定。 其中 0 表示列表的第一个元素, 1 表示列表的第二个元素,以此类推。 你也可以使用负数下标,以 -1 表示列表的最后一个元素, -2 表示列表的倒数第二个元素,以此类推。

返回一个列表,包含指定区间内的元素。

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

lrem key count value

Redis Lrem 根据参数 COUNT 的值,移除列表中与参数 VALUE 相等的元素。

COUNT 的值可以是以下几种:

  • count > 0 : 从表头开始向表尾搜索,移除与 VALUE 相等的元素,数量为 COUNT
  • count < 0 : 从表尾开始向表头搜索,移除与 VALUE 相等的元素,数量为 COUNT 的绝对值。
  • count = 0 : 移除表中所有与 VALUE 相等的值。

返回被移除元素的数量。 列表不存在时返回 0 。

127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> lpush db redis mysql nosql memercache
(integer) 4
127.0.0.1:6379> lrem db -1 redis
(integer) 1
127.0.0.1:6379> lrange db 0 -1
1) "memercache"
2) "nosql"
3) "mysql"
127.0.0.1:6379>

lset key index value

Redis Lset 通过索引来设置元素的值。

当索引参数超出范围,或对一个空列表进行 LSET 时,返回一个错误。

操作成功返回 ok ,否则返回错误信息。

127.0.0.1:6379> lrange db 0 -1
1) "memercache"
2) "nosql"
3) "mysql"
127.0.0.1:6379> lset db 1 hello
OK
127.0.0.1:6379> lrange db 0 -1
1) "memercache"
2) "hello"
3) "mysql"
127.0.0.1:6379> lrange db 10 hello
(error) ERR value is not an integer or out of range
127.0.0.1:6379>

ltrim key start stop

Redis Ltrim 对一个列表进行修剪(trim),就是说,让列表只保留指定区间内的元素,不在指定区间之内的元素都将被删除。

下标 0 表示列表的第一个元素,以 1 表示列表的第二个元素,以此类推。 你也可以使用负数下标,以 -1 表示列表的最后一个元素, -2 表示列表的倒数第二个元素,以此类推。

命令执行成功时,返回 ok

127.0.0.1:6379> lrange db 0 -1
1) "memercache"
2) "hello"
3) "mysql"
127.0.0.1:6379> ltrim db 1 1
OK
127.0.0.1:6379> lrange db 0 -1
1) "hello"
127.0.0.1:6379>

rpop key

Redis Rpop 命令用于移除列表的最后一个元素,返回值为移除的元素。

返回被移除的元素。当列表不存在时,返回 nil

127.0.0.1:6379> lrange db 0 -1
1) "nosql"
2) "postgresql"
3) "mysql"
4) "redis"
127.0.0.1:6379> rpop db
"redis"
127.0.0.1:6379>

rpoppush source_key_name destination_key_name

Redis Rpoplpush 命令用于移除列表的最后一个元素,并将该元素添加到另一个列表并返回。

返回被弹出的元素。

127.0.0.1:6379> lrange db 0 -1
1) "nosql"
2) "postgresql"
3) "mysql"
127.0.0.1:6379> rpoplpush db db1
"mysql"
127.0.0.1:6379> lrange db1 0 -1
1) "mysql"
127.0.0.1:6379>

rpush key value [value1 value2 ...]

Redis Rpush 命令用于将一个或多个值插入到列表的尾部(最右边)。

如果列表不存在,一个空列表会被创建并执行 RPUSH 操作。 当列表存在但不是列表类型时,返回一个错误。

在 Redis 2.4 版本以前的 RPUSH 命令,都只接受单个 value 值。

执行 RPUSH 操作后,列表的长度。

127.0.0.1:6379> lrange db 0 -1
1) "redis"
2) "mysql"
3) "nosql"
4) "postgresql"
127.0.0.1:6379>

rpushx key value

Redis Rpushx命令用于将一个值插入到已存在的列表尾部(最右边)。如果列表不存在,操作无效。

执行 Rpushx 操作后,列表的长度。

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 集合(Set)

RedisSetString 类型的无序集合。集合成员是唯一的,这就意味着集合中不能出现重复的数据。

Redis 中集合是通过哈希表实现的,所以添加,删除,查找的复杂度都是 O(1)。

集合中最大的成员数为 232 – 1 (4294967295, 每个集合可存储40多亿个成员)。

实例

127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> sadd test redis
(integer) 1
127.0.0.1:6379> sadd test mysql
(integer) 1
127.0.0.1:6379> sadd test mongodb
(integer) 1
127.0.0.1:6379> sadd test mysql
(integer) 0
127.0.0.1:6379> smembers test
1) "mongodb"
2) "mysql"
3) "redis"
127.0.0.1:6379>

Redis 集合命令

sadd key member [member1 ...]

Redis Sadd 命令将一个或多个成员元素加入到集合中,已经存在于集合的成员元素将被忽略。

假如集合 key 不存在,则创建一个只包含添加的元素作成员的集合。

当集合 key 不是集合类型时,返回一个错误。

Redis2.4 版本以前, SADD 只接受单个成员值。

返回被添加到集合中的新元素的数量,不包括被忽略的元素。

127.0.0.1:6379> sadd db redis mysql mongodbb postgresql
(integer) 4
127.0.0.1:6379> sadd db redis
(integer) 0
127.0.0.1:6379>

scard key

Redis Scard命令返回集合中元素的数量。

返回集合的数量。 当集合 key 不存在时,返回 0 。

127.0.0.1:6379> scard db
(integer) 4
127.0.0.1:6379> scard db1
(integer) 0
127.0.0.1:6379>

sdiff key key1

Redis Sdiff命令返回第一个集合与其他集合之间的差异,也可以认为说第一个集合中独有的元素。不存在的集合 key 将视为空集。

差集的结果来自前面的 FIRST_KEY ,而不是后面的 OTHER_KEY1,也不是整个 FIRST_KEY OTHER_KEY1..OTHER_KEYN 的差集。

返回包含差集成员的列表。

127.0.0.1:6379> sadd key1 a b c d e f
(integer) 6
127.0.0.1:6379> sadd key2 b c f g h i
(integer) 6
127.0.0.1:6379> sdiff key1 key2
1) "d"
2) "e"
3) "a"
127.0.0.1:6379>

sdiffstore destination_key key1 key2...

Redis Sdiffstore 命令将给定集合之间的差集存储在指定的集合中。如果指定的集合 key 已存在,则会被覆盖。

返回结果集中的元素数量。

127.0.0.1:6379> sadd key1 a b c d e f
(integer) 6
127.0.0.1:6379> sadd key2 b c f g h i
(integer) 6
127.0.0.1:6379> sdiff key1 key2
1) "d"
2) "e"
3) "a"
127.0.0.1:6379> sdiffstore key3 key1 key2
(integer) 3
127.0.0.1:6379> smembers key3
1) "d"
2) "e"
3) "a"
127.0.0.1:6379>

sinter key1 key2 ...

Redis Sinter 命令返回给定所有给定集合的交集。 不存在的集合 key 被视为空集。 当给定集合当中有一个空集时,结果也为空集(根据集合运算定律)。

返回交集成员的列表。

127.0.0.1:6379> smembers key1
1) "a"
2) "b"
3) "c"
4) "d"
5) "f"
6) "e"
127.0.0.1:6379> smembers key2
1) "c"
2) "g"
3) "i"
4) "f"
5) "h"
6) "b"
127.0.0.1:6379> sinter key1 key2
1) "b"
2) "c"
3) "f"
127.0.0.1:6379> sinter key1 key2 key3
(empty list or set)
127.0.0.1:6379> smembers key3
1) "d"
2) "e"
3) "a"
127.0.0.1:6379>

sinterstore destination_key key key1 key2 ...

Redis Sinterstore命令将给定集合之间的交集存储在指定的集合中。如果指定的集合已经存在,则将其覆盖。

返回存储交集的集合的元素数量。

127.0.0.1:6379> smembers key1
1) "c"
2) "d"
3) "f"
4) "e"
5) "a"
6) "b"
127.0.0.1:6379> smembers key2
1) "c"
2) "g"
3) "i"
4) "f"
5) "h"
6) "b"
127.0.0.1:6379> smembers key3
1) "d"
2) "e"
3) "a"
127.0.0.1:6379> sinterstore key3 key1 key2
(integer) 3
127.0.0.1:6379> smembers key3
1) "f"
2) "c"
3) "b"
127.0.0.1:6379>

sismember key member

Redis Sismember 命令判断成员元素是否是集合的成员。

如果成员元素是集合的成员,返回 1 。 如果成员元素不是集合的成员,或 key 不存在,返回 0 。

127.0.0.1:6379> smembers key1
1) "c"
2) "d"
3) "f"
4) "e"
5) "a"
6) "b"
127.0.0.1:6379> sismember key1 h
(integer) 0
127.0.0.1:6379> sismember key1 a
(integer) 1
127.0.0.1:6379>

smembers key

Redis Smembers 命令返回集合中的所有的成员。 不存在的集合 key 被视为空集合。

返回集合中的所有成员。

127.0.0.1:6379> smembers key1
1) "c"
2) "d"
3) "f"
4) "e"
5) "a"
6) "b"
127.0.0.1:6379>

smove source destination member

Redis Smove 命令将指定成员 member 元素从 source 集合移动到 destination 集合。

SMOVE 是原子性操作。

如果 source 集合不存在或不包含指定的 member 元素,则 SMOVE 命令不执行任何操作,仅返回 0 。否则, member 元素从 source 集合中被移除,并添加到 destination 集合中去。

destination 集合已经包含 member 元素时, SMOVE 命令只是简单地将 source 集合中的 member 元素删除。

sourcedestination 不是集合类型时,返回一个错误。

如果成员元素被成功移除,返回 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"

spop key

Redis Spop 命令用于移除集合中的指定 key 的一个或多个随机元素,移除后会返回移除的元素。

该命令类似 Srandmember命令,但 SPOP 将随机元素从集合中移除并返回,而 Srandmember 则仅仅返回随机元素,而不对集合进行任何改动。

127.0.0.1:6379> smembers key1
1) "world"
2) "redis"
3) "hello"
127.0.0.1:6379> spop key1
"redis"
127.0.0.1:6379> smembers key1
1) "world"
2) "hello"
127.0.0.1:6379> spop key1
"hello"
127.0.0.1:6379> smembers key1
1) "world"
127.0.0.1:6379> spop key1
"world"
127.0.0.1:6379> smembers key1
(empty list or set)
127.0.0.1:6379>

srandmember key [count]

Redis Srandmember 命令用于返回集合中的一个随机元素。

Redis 2.6 版本开始, Srandmember命令接受可选的 count 参数:

  • 如果count 为正数,且小于集合基数,那么命令返回一个包含 count个元素的数组,数组中的元素各不相同。如果 count 大于等于集合基数,那么返回整个集合。
  • 如果 count为负数,那么命令返回一个数组,数组中的元素可能会重复出现多次,而数组的长度为 count 的绝对值。

该操作和SPOP 相似,但 SPOP 将随机元素从集合中移除并返回,而Srandmember 则仅仅返回随机元素,而不对集合进行任何改动。

127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> sadd db redis mysql postgresql mongodb
(integer) 4
127.0.0.1:6379>
127.0.0.1:6379>
127.0.0.1:6379> srandmember db 3
1) "mongodb"
2) "redis"
3) "mysql"
127.0.0.1:6379> srandmember db 10
1) "postgresql"
2) "mongodb"
3) "redis"
4) "mysql"
127.0.0.1:6379> srandmember db -3
1) "postgresql"
2) "postgresql"
3) "redis"
127.0.0.1:6379> smembers db
1) "mongodb"
2) "postgresql"
3) "mysql"
4) "redis"
127.0.0.1:6379>

srem key member [member1 ...]

Redis Srem 命令用于移除集合中的一个或多个成员元素,不存在的成员元素会被忽略。

key 不是集合类型,返回一个错误。

Redis 2.4版本以前, SREM 只接受单个成员值。

127.0.0.1:6379> keys *
1) "db"
127.0.0.1:6379> type db
set
127.0.0.1:6379> smembers db
1) "mongodb"
2) "postgresql"
3) "mysql"
4) "redis"
127.0.0.1:6379> srem db redis mysql
(integer) 2
127.0.0.1:6379> srem db test
(integer) 0
127.0.0.1:6379>

sunion key key1 ...

Redis Sunion 命令返回给定集合的并集。不存在的集合 key 被视为空集。

返回并集成员的列表。

127.0.0.1:6379> sadd k1 redis mysql test hello
(integer) 4
127.0.0.1:6379> sadd k2 redis mysql world  h1
(integer) 4
127.0.0.1:6379> sunion k1 k2
1) "test"
2) "redis"
3) "h1"
4) "world"
5) "mysql"
6) "hello"
127.0.0.1:6379>

sunionstore destination key key1 ...

Redis Sunionstore 命令将给定集合的并集存储在指定的集合 destination 中。如果 destination 已经存在,则将其覆盖。

返回结果集中的元素数量。

127.0.0.1:6379> sadd k1 redis mysql test hello
(integer) 4
127.0.0.1:6379> sadd k2 redis mysql world  h1
(integer) 4
127.0.0.1:6379> sunion k1 k2
1) "test"
2) "redis"
3) "h1"
4) "world"
5) "mysql"
6) "hello"
127.0.0.1:6379> sunionstore k3 k1 k2
(integer) 6
127.0.0.1:6379> smembers k3
1) "test"
2) "redis"
3) "h1"
4) "world"
5) "mysql"
6) "hello"
127.0.0.1:6379>

sscan key cursor [MATCH pattern] [COUNT count]

Redis Sscan 命令用于迭代集合中键的元素。

  • cursor – 游标。
  • pattern匹配的模式。
  • count指定从数据集里返回多少元素,默认值为 10 。

返回数组列表。

127.0.0.1:6379> smembers k3
1) "test"
2) "redis"
3) "h1"
4) "world"
5) "mysql"
6) "hello"
127.0.0.1:6379> sscan k3 0 match h* count 10
1) "0"
2) 1) "h1"
   2) "hello"
127.0.0.1:6379>

Redis 有序集合(sorted set)

Redis 有序集合和集合一样也是 string 类型元素的集合,且不允许重复的成员。

不同的是每个元素都会关联一个 double 类型的分数。redis 正是通过分数来为集合中的成员进行从小到大的排序。

有序集合的成员是唯一的,但分数(score)却可以重复。

集合是通过哈希表实现的,所以添加,删除,查找的复杂度都是 O(1)。 集合中最大的成员数为 232 – 1 (4294967295, 每个集合可存储40多亿个成员)。

实例

127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> zadd db 1 redis
(integer) 1
127.0.0.1:6379> zadd db 2 mysql
(integer) 1
127.0.0.1:6379> zadd db 3 mongodb
(integer) 1
127.0.0.1:6379> zadd db 3 mongodb
(integer) 0
127.0.0.1:6379> zrange db 0 10 withscores
1) "redis"
2) "1"
3) "mysql"
4) "2"
5) "mongodb"
6) "3"
127.0.0.1:6379>

Redis 有序集合命令

zadd key score1 member1 [score2 member2 ...]

Redis Zadd命令用于将一个或多个成员元素及其分数值加入到有序集当中。

如果某个成员已经是有序集的成员,那么更新这个成员的分数值,并通过重新插入这个成员元素,来保证该成员在正确的位置上。

分数值可以是整数值或双精度浮点数。

如果有序集合 key 不存在,则创建一个空的有序集并执行 ZADD 操作。

key 存在但不是有序集类型时,返回一个错误。

在 Redis 2.4 版本以前, ZADD 每次只能添加一个元素。

127.0.0.1:6379> zadd db 1 redis 2 mysql 3 mongodb 4 postgresql
(integer) 4
127.0.0.1:6379> zrange db 0 20
1) "redis"
2) "mysql"
3) "mongodb"
4) "postgresql"
127.0.0.1:6379>

zcard key

Redis Zcard 命令用于计算集合中元素的数量。

127.0.0.1:6379> zadd db 1 redis 2 mysql 3 mongodb 4 postgresql
(integer) 4
127.0.0.1:6379> zrange db 0 20
1) "redis"
2) "mysql"
3) "mongodb"
4) "postgresql"
127.0.0.1:6379> zcard db
(integer) 4
127.0.0.1:6379>

zcount key min max

Redis Zcount 命令用于计算有序集合中指定分数区间的成员数量。

127.0.0.1:6379> zrange db 0 10 withscores
1) "redis"
2) "1"
3) "mysql"
4) "2"
5) "mongodb"
6) "3"
7) "postgresql"
8) "4"
127.0.0.1:6379> zcount db 1 10
(integer) 4
127.0.0.1:6379>

zincrby key increment member

Redis Zincrby命令对有序集合中指定成员的分数加上增量 increment

可以通过传递一个负数值 increment ,让分数减去相应的值,比如ZINCRBY key -5 member ,就是让 memberscore 值减去 5 。

key 不存在,或分数不是 key的成员时,ZINCRBY key increment member 等同于ZADD key increment member

key不是有序集类型时,返回一个错误。

分数值可以是整数值或双精度浮点数。

返回member 成员的新分数值,以字符串形式表示。

127.0.0.1:6379> zrange db 0 10 withscores
1) "redis"
2) "1"
3) "mysql"
4) "2"
5) "mongodb"
6) "3"
7) "postgresql"
8) "4"
127.0.0.1:6379> zincrby db 10 mongodb
"13"
127.0.0.1:6379> zrange db 0 100 withscores
1) "redis"
2) "1"
3) "mysql"
4) "2"
5) "postgresql"
6) "4"
7) "mongodb"
8) "13"
127.0.0.1:6379> zincrby db 15 test
"15"
127.0.0.1:6379> zrange db 0 100 withscores
 1) "redis"
 2) "1"
 3) "mysql"
 4) "2"
 5) "postgresql"
 6) "4"
 7) "mongodb"
 8) "13"
 9) "test"
10) "15"
127.0.0.1:6379>

Redis HyperLogLog

Redis 在 2.8.9 版本添加了 HyperLogLog 结构。

Redis HyperLogLog 是用来做基数统计的算法,HyperLogLog 的优点是,在输入元素的数量或者体积非常非常大时,计算基数所需的空间总是固定 的、并且是很小的。

Redis 里面,每个 HyperLogLog 键只需要花费 12 KB 内存,就可以计算接近 2^64个不同元素的基 数。这和计算基数时,元素越多耗费内存就越多的集合形成鲜明对比。

但是,因为 HyperLogLog 只会根据输入元素来计算基数,而不会储存输入元素本身,所以 HyperLogLog 不能像集合那样,返回输入的各个元素。

实例

127.0.0.1:6379> pfadd db redis
(integer) 1
127.0.0.1:6379> pfadd db mysql
(integer) 1
127.0.0.1:6379> pfadd db mongodb
(integer) 1
127.0.0.1:6379> pfcount db
(integer) 3

Redis HyperLogLog 命令

pfadd key element [element1 ...]

添加指定元素到 HyperLogLog 中。

返回整型,如果至少有个元素被添加返回 1, 否则返回 0。

127.0.0.1:6379> pfadd db redis mysql mongodb postgresql
(integer) 1
127.0.0.1:6379> pfcount db
(integer) 4

pfcount key [key...]

Redis Pfcount 命令返回给定 HyperLogLog 的基数估算值。

返回整数,返回给定 HyperLogLog 的基数值,如果多个 HyperLogLog 则返回基数估值之和。

127.0.0.1:6379> pfadd db redis mysql mongodb postgresql
(integer) 1
127.0.0.1:6379> pfcount db
(integer) 4
127.0.0.1:6379> pfadd db1 redis mysql mongodb postgresql
(integer) 1
127.0.0.1:6379> pfcount db db1
(integer) 4
127.0.0.1:6379> pfadd db2 1 2 3 4
(integer) 1
127.0.0.1:6379> pfcount db1 db db2
(integer) 8
127.0.0.1:6379>

pfmerge destkey sourcekey [sourcekey...]

Redis PFMERGE 命令将多个 HyperLogLog 合并为一个 HyperLogLog ,合并后的 HyperLogLog 的基数估算值是通过对所有 给定 HyperLogLog 进行并集计算得出的。

返回 OK

127.0.0.1:6379> pfadd db redis mysql mongodb postgresql
(integer) 1
127.0.0.1:6379> pfcount db
(integer) 4
127.0.0.1:6379> pfadd db1 redis mysql mongodb postgresql
(integer) 1
127.0.0.1:6379> pfcount db db1
(integer) 4
127.0.0.1:6379> pfadd db2 1 2 3 4
(integer) 1
127.0.0.1:6379> pfcount db1 db db2
(integer) 8
127.0.0.1:6379> pfmerge db2 db1 db
OK
127.0.0.1:6379> pfcount db2
(integer) 8
127.0.0.1:6379>
暂无评论

发送评论 编辑评论


|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
(╯‵□′)╯︵┴─┴
 ̄﹃ ̄
(/ω\)
∠( ᐛ 」∠)_
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ`)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ( ̄∇ ̄o)
ヾ(´・ ・`。)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò。)
Σ(っ °Д °;)っ
( ,,´・ω・)ノ"(´っω・`。)
╮(╯▽╰)╭
o(*////▽////*)q
>﹏<
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
颜文字
Emoji
小恐龙
花!
上一篇
下一篇