从零开始的Linux运维屌丝之路,资源免费分享平台   运维人员首选:简单、易用、高效、安全、稳定、社区活跃的开源软件

Redis入门笔记

发布:蔺要红05-26分类: NOSQL


Redis 是完全开源免费的,高性能的 key-value 内存数据库。
优秀博文:  https://www.fengbohello.top/archives/redis-cmd

Redis 有三个主要的特点:
1、Redis 支持数据的持久化,可以将内存中的数据保持在磁盘中,重启的时候可以再次加载进行使用
2、Redis 不仅仅支持简单的 key-value 类型的数据,同时还提供 list , set , zset , hash 等数据结构的存储
3、Redis 支持数据的备份,即 master-slave 模式的数据备份。

Redis 优点
1、性能极高 – Redis 能读的速度是 110000 次/s,写的速度是 81000 次/s 。
2、支持丰富的数据类型 - Redis 支持最大多数开发人员已经知道如列表,集合,可排序集合,哈希等数据类型。 这使得在应用中很容易解决的各种问题,因为我们知道哪些问题处理, 使用哪种数据类型更好解决。
3、操作都是原子的 - 所有 Redis 的操作都是原子,从而确保当两个客户同时访问 Redis 服务器得到的是更新后的值(最新值)。 原子性(atomicity):一个事务是一个不可分割的最小工作单位,事务中包括的诸操作要么都做,要么都不做。 Redis 所有单个命令的执行都是原子性的,这与它的单线程机制有关;

Redis 是一个多功能实用工具,可以在很多如:
1.缓存 消息传递队列中使用(Redis 原生支持发布/订阅),
2、在应用程序中,如:Web 应用程序会话,网站页面点击数等任何短暂的数

redis 可视化客户端工具   :Redis Desktop Manager
redis 可视化客户端工具   :https://github.com/erikdubbelboer/phpRedisAdmin
redis 状态查看带web界面  https://github.com/junegunn/redis-stat

redis和Memcached对比
 

1、Redis和Memcache都是将数据存放在内存中,都是内存数据库。不过memcache还可用于缓存其他东西,例如图片、视频等等;
2、Redis不仅仅支持简单的k/v类型的数据,同时还提供list,set,hash等数据结构的存储;
3、虚拟内存--Redis当物理内存用完时,可以将一些很久没用到的value 交换到磁盘;
4、过期策略--memcache在set时就指定,例如set key1 0 0 8,即永不过期。Redis可以通过例如expire 设定,例如expire name 10;
5、分布式--设定memcache集群,利用magent做一主多从;redis可以做一主多从。都可以一主一从;
6、存储数据安全--memcache挂掉后,数据没了;redis可以定期保存到磁盘(持久化);
7、灾难恢复--memcache挂掉后,数据不可恢复; redis数据丢失后可以通过aof恢复;
8、Redis支持数据的备份,即master-slave模式的数据备份;
9、应用场景不一样:Redis出来作为NoSQL数据库使用外,还能用做消息队列、数据堆栈和数据缓存等;Memcached适合于缓存SQL语句、数据集、用户临时性数据、延迟查询数据和session等。

 

功能 Memcached Redis
类型 Key-value数据库 Key-value数据库
过期策略 支持 支持
数据类型 单一数据类型 多种数据类型(list,hash,列表等)
持久化 不支持 支持
主从复制 不支持 支持
虚拟内存 不支持 支持(不建议使用)


安装
wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
yum -y install redis
[root@web01 ~]# rpm -ql redis #查看安装了什么内容


部分配置文件
[root@web01 ~]# grep ^[a-z] /etc/redis.conf 
bind 10.10.10.20  #绑定的IP地址
protected-mode yes
port 6379
tcp-backlog 511
timeout 0  #是否主动断开连接
tcp-keepalive 300
daemonize yes  #以守护进程模式运行
supervised no
pidfile /var/run/redis_6379.pid
loglevel notice #日志级别
logfile /var/log/redis/redis.log #日志文件存放位置
databases 16  #redis能支持数据库的数量0-15 16个
requirepass 123123 #打开注释设置密码
save 900 1
save 300 10
save 60 10000
...
...
maxmemory-policy volatile-lru

#连接Redis
redis-cli -h 10.10.10.20
#启动
systemctl start redis
maxmemory-policy volatile-lru  #当内存不足以容纳新写入数据时,在键空间中,移除最近最少使用的key
maxmemory 8gb                  #(8g 1000 8gb 1024)

redis设置过期Key的maxmemory-policy六种方式
设置方法:
config set maxmemory-policy volatile-lru 
maxmemory-policy 六种方式
    1、volatile-lru:只对设置了过期时间的key进行LRU(默认值) 
    2、allkeys-lru : 删除lru算法的key   
    3、volatile-random:随机删除即将过期key   
    4、allkeys-random:随机删除   
    5、volatile-ttl : 删除即将过期的   
    6、noeviction : 永不过期,返回错误

redis-cli命令使用帮助  当进入redis时:info命令可以查看redis所有状态信息
[root@web01 ~]# redis-cli  -h
redis-cli 3.2.12

Usage: redis-cli [OPTIONS] [cmd [arg [arg ...]]]
  -h <hostname>      Server hostname (default: 127.0.0.1).
  -p <port>          Server port (default: 6379).
  -s <socket>        Server socket (overrides hostname and port).
  -a <password>      Password to use when connecting to the server.
  -r <repeat>        Execute specified command N times.

1、Redis配置密码 (安全)
/etc/redis.cof
requirepass 123123 #打开注释设置密码

redis-cli -h 10.10.10.20 -a 123123 #使用-a命令带密码 连接redis
#或者
[root@web01 ~]# redis-cli -h 10.10.10.20   
10.10.10.20:6379> auth 123123
OK

2、进入Redis后配置密码
10.10.10.20:6379> config set requirepass 123456 #设置密码
OK
10.10.10.20:6379> keys *
(error) NOAUTH Authentication required. #不认证会报错
10.10.10.20:6379> auth 123456 #认证密码
OK
10.10.10.20:6379> keys * #正常使用
#当退出后在次连接时、仍需要密码验证

10.10.10.20:6379> config get requirepass #查看密码
1) "requirepass"
2) "123456"


127.0.0.1:6379> TYPE others:name_id_map  #查看key的类型
hash


Redis基本操作与使用
 
命令 功能
SET 设置key
GET 获取key的值
EXISTS 判断key是否存在
KEYS * 显示所有的key
DEL 删除指定的key
TYPE 获取key的类型
SELECT 选择数据库(配置文件里配置的16)支持17个数据库
 
10.10.10.20:6379> SET mykey lin  -ex 2 #设置一个key 2秒过期
OK

ex 过期时间秒
px 过期时间毫米
nx 如果设置为True 则只有name存在的时候,当前的set操作才执行
xx 如果设置为True 则只有name存在的时候,当前set才执行

10.10.10.20:6379> get name
"linyaohong"
10.10.10.20:6379> set name 123 nx
(nil)
10.10.10.20:6379> get name #name还是linyaohong
"linyaohong"

10.10.10.20:6379> set name 123 xx
OK
10.10.10.20:6379> get name
"123"

10.10.10.20:6379> set name2 123 xx  #name2不存在 则不设置
(nil)
10.10.10.20:6379> get name2
(nil)

10.10.10.20:6379> SET mykey lin
OK
10.10.10.20:6379> SELECT 1  #选择数据库 1 不选择默认在 0
OK
10.10.10.20:6379[1]> KEYS * #当选择了1的时候,查询key查询不到,因为默认是在0 上创建的
(empty list or set)
10.10.10.20:6379[1]> SELECT 0 
OK
10.10.10.20:6379> KEYS *
1) "mykey"
10.10.10.20:6379> SET mykey lin  -ex 2 #设置一个key 2秒过期
OK

10.10.10.20:6379> TYPE mykey     #查询key的类型
string

10.10.10.20:6379> GET mykey      #获取一个key的内容
"lin"

10.10.10.20:6379> KEYS *         #查看所有的key(慎用)
1) "mykey"
10.10.10.20:6379> KEYS mykey     #查看mykey
1) "mykey"
10.10.10.20:6379> KEYS mykey2    #查看一个不存在的kye返回empty空
(empty list or set)

10.10.10.20:6379> EXISTS mykey   #判断一个key是否存在、存在则返回1
(integer) 1
10.10.10.20:6379> EXISTS mykey2  #判断一个key是否存在、不存在则返回0
(integer) 0


10.10.10.20:6379> DEL mykey      #删除一个key,存在返回1
(integer) 1
10.10.10.20:6379> DEL mykey2     #删除一个不存在的kye,不存在则返回0
(integer) 0

Redis数据类型---字符串类型

官方文档:http://redis.cn/commands/append.html
 
redis——字符串类型
命令 功能
SET 设置key
GET 获取key的值
DEL 删除指定的key
APPEND 追加内容得到value
STRLEN 获取字符串key的长度
MSET 设置多个key
MGET 获取多个key
其他用法
INCR 自增(可做计数器)
INCRBY 指定步长自增
DECR 自减
DECRBY 指定步长自减
INCRBYFLOAT 自增浮点类型
 
10.10.10.20:6379> KEYS *             #查看所有的key
1) "mykey"
10.10.10.20:6379> GET mykey          #获取key的内容
"lin"
10.10.10.20:6379> APPEND mykey 123   #key的value追加内容
(integer) 6
10.10.10.20:6379> GET mykey          #再次获取key的内容追加了123
"lin123"
10.10.10.20:6379> STRLEN mykey       #获取一个kye的长度
(integer) 6
10.10.10.20:6379> INCR num  #自增、每次增加一个
(integer) 1
10.10.10.20:6379> INCR num
(integer) 2
10.10.10.20:6379> INCR num
(integer) 3
10.10.10.20:6379> GET num
"3"

10.10.10.20:6379> INCRBY num 10   #步长10、自增
(integer) 13
10.10.10.20:6379> INCRBY num 10
(integer) 23
10.10.10.20:6379> GET num
"23"

10.10.10.20:6379> DECRBY num 2  #步长2递减
(integer) 21
10.10.10.20:6379> DECRBY num 2
(integer) 19
10.10.10.20:6379> GET num  
"19"

10.10.10.20:6379> DECR num      #递减
(integer) 18
10.10.10.20:6379> DECR num
(integer) 17
10.10.10.20:6379> GET num
"17"

#自增浮点类型
10.10.10.20:6379> INCRBYFLOAT num2  1.2 #自增浮点类型
"1.2"
10.10.10.20:6379> INCRBYFLOAT num2  1.2
"2.4"
10.10.10.20:6379> INCRBYFLOAT num2  1.2
"3.6"




10.10.10.20:6379> MSET  k1 v1 k2 v2 k3 v3 #设置多个key
OK
10.10.10.20:6379> KEYS k*
1) "k1"
2) "k3"
3) "k2"
10.10.10.20:6379> MGET k1 k2 k3  #获取多个key
1) "v1"
2) "v2"
3) "v3"

Redis数据类型---散列类型(Hash)---Hash类型的键最多2的32次方-1个

官方文档:
http://redis.cn/commands/hdel.html
 
redis——散列类型(Hash)
命令 功能
HKEYS   KHESYS key查看key里所有的key
HVALS   KHESYS key查看key里所有的value
HSET

  设置 key 指定的哈希集中指定字段的值。

  如果 key 指定的哈希集不存在,会创建一个新的哈希集并与 key 关联。

  如果字段在哈希集中存在,它将被重写

HGET   返回 key 指定的哈希集中该字段所关联的值
HGETALL   返回key里所有的元素
HDEL

  从 key 指定的哈希集中移除指定的域。在哈希集中不存在的域将被忽略。

  如果 key 指定的哈希集不存在,它将被认为是一个空的哈希集,该命令将返回0

HMSET   key连续多个、设置 key 指定的哈希集中指定字段的值。该命令将重写所有在哈希集中    存在的字段。如果 key 指定的哈希集不存在,会创建一个新的哈希集并与 key 关联
HMGET

  返回 key 指定的哈希集中指定字段的值。

  对于哈希集中不存在的每个字段,返回 nil 值。因为不存在的keys被认为是一个空的哈希集,对一个不存在的 key 执行 HMGET 将返回一个只含有 nil 值的列表

 
10.10.10.20:6379> HSET car name BMW
(integer) 1
10.10.10.20:6379> HSET car price 5000
(integer) 1
10.10.10.20:6379> HSET car color red
(integer) 1
10.10.10.20:6379> KEYS *
1) "car"
10.10.10.20:6379> HKEYS car  #查看car里所有的key
1) "name"
2) "price"
3) "color"
10.10.10.20:6379> HVALS car  #查看car里所有的value
1) "BMW"
2) "5000"
3) "red"

10.10.10.20:6379> HGET car name
"BMW"
10.10.10.20:6379> HGET car color
"red"

10.10.10.20:6379> HSET car name BYD #如果name存在、则更新、不存在则设置
(integer) 0
10.10.10.20:6379> HGET car name
"BYD
10.10.10.20:6379> HMSET book price 10 name nginx year 2019 #设置 key 指定的哈希集中指定字段的值
OK
10.10.10.20:6379> HMGET book price name  #返回 key 指定的哈希集中该字段所关联的值
1) "10"
2) "nginx"

10.10.10.20:6379> HMGET book price name color #对一个不存在的 key 执行 HMGET 将返回一个只含有 nil 值的列表
1) "10"
2) "nginx"
3) (nil)

10.10.10.20:6379> HGETALL book #返回 key 指定的哈希集中所有的字段和值
1) "price"
2) "10"
3) "name"
4) "nginx"
5) "year"
6) "2019"
10.10.10.20:6379> HDEL book color   #从 key 指定的哈希集中移除指定的域。在哈希集中不存在的域将被忽略。如果 key 指定的哈希集不存在,它将被认为是一个空的哈希集,该命令将返回0
(integer) 0
10.10.10.20:6379> HDEL book year #删除key  book 里的name
(integer) 1
10.10.10.20:6379> HGETALL book #查看year已经被删除
1) "price"
2) "10"
3) "name"
4) "nginx"
10.10.10.20:6379> HEXISTS book year #返回hash里面field是否存在1 hash里面包含该field   0 hash里面不包含该field或者key不存在
(integer) 0
10.10.10.20:6379> HEXISTS book name
(integer) 1

#END
10.10.10.20:6379> DEL book  #删除这个key
(integer) 1

Redis数据类型---列表类型 ---元素可以重复

官方文档:http://redis.cn/commands/lpush.html
 
redis——列表类型
命令 功能
LPUSH

  将所有指定的值插入到存于 key 的列表的头部。如果 key 不存在,那么在进行 push 操作前会创建一个空列表。 如果 key 对应的值不是一个 list 的话,那么会返回一个错误。

  可以使用一个命令把多个元素 push 进入列表,只需在命令末尾加上多个指定的参数。元素是从最左端的到最右端的、一个接一个被插入到 list 的头部。 所以对于这个命令例子 LPUSH mylist a b c,返回的列表是 c 为第一个元素, b 为第二个元素, a 为第三个元素

RPUSH

  向存于 key 的列表的尾部插入所有指定的值。如果 key 不存在,那么会创建一个空的列表然后再进行 push 操作。 当 key 保存的不是一个列表,那么会返回一个错误。

  可以使用一个命令把多个元素打入队列,只需要在命令后面指定多个参数。元素是从左到右一个接一个从列表尾部插入。 比如命令 RPUSH mylist a b c 会返回一个列表,其第一个元素是 a ,第二个元素是 b ,第三个元素是 c

LINDEX

  返回列表里的元素的索引 index 存储在 key 里面。 下标是从0开始索引的,所以 0 是表示第一个元素, 1 表示第二个元素,并以此类推。 负数索引用于指定从列表尾部开始索引的元素。在这种方法下,-1 表示  最后一个元素,-2 表示倒数第二个元素,并以此往前推。

  当 key 位置的值不是一个列表的时候,会返回一个error

LPOP   移除并且返回 key 对应的 list 的第一个元素
RPOP   移除并返回存于 key 的 list 的最后一个元素
LRANGE

  返回存储在 key 的列表里指定范围内的元素。 start 和 end 偏移量都是基于0的下标,即list的第一个元素下标是0(list的表头),第二个元素下标是1,以此类推。

  偏移量也可以是负数,表示偏移量是从list尾部开始计数。 例如, -1 表示列表的最后一个元素,-2 是倒数第二个,以此类推

 LRANGE helpusers_1 0 -1 #获取列表所有的值

LREM

  从存于 key 的列表里移除前 count 次出现的值为 value 的元素。 这个 count 参数通过下面几种方式影响这个操作:

 count > 0: 从头往尾移除值为 value 的元素。
 count < 0: 从尾往头移除值为 value 的元素。
 count = 0: 移除所有值为 value 的元素。

  比如, LREM list -2 “hello” 会从存于 list 的列表里移除最后两  个出现的 “hello”。

  需要注意的是,如果list里没有存在key就会被当作空list处理,所以当 key 不存在的时候,这个命令会返回 0

 
10.10.10.20:6379> LPUSH mylist 01
(integer) 1
10.10.10.20:6379> LPUSH mylist 02
(integer) 2
10.10.10.20:6379> LPUSH mylist 03
(integer) 3
10.10.10.20:6379> RPUSH mylist 01
(integer) 4
10.10.10.20:6379> RPUSH mylist 02
(integer) 5
10.10.10.20:6379> RPUSH mylist 03
(integer) 6
10.10.10.20:6379> LLEN mylist  长度
(integer) 6
 
10.10.10.20:6379> LINDEX mylist -1
"03"
10.10.10.20:6379> LINDEX mylist -2
"02"
10.10.10.20:6379> LINDEX mylist -3
"01"
10.10.10.20:6379> LINDEX mylist -4
"01"
10.10.10.20:6379> LINDEX mylist -5
"02"
10.10.10.20:6379> LINDEX mylist -6
"03"
10.10.10.20:6379> LINDEX mylist -7  #没有值
(nil)

#---------------------------------
10.10.10.20:6379> LINDEX mylist 0
"03"
10.10.10.20:6379> LINDEX mylist 1
"02"
10.10.10.20:6379> LINDEX mylist 2
"01"
10.10.10.20:6379> LINDEX mylist 3
"01"
10.10.10.20:6379> LINDEX mylist 4
"02"
10.10.10.20:6379> LINDEX mylist 5
"03"

LPOP 和 RPOP

如上图:移除并且返回 key 对应的 list 的第一个元素

 

LPUSHX:只有当 key 已经存在并且存着一个 list 的时候,在这个 key 下面的 list 的头部插入 value。 与 LPUSH 相反,当 key 不存在的时候不会进行任何操作

RPUSHX:将值 value 插入到列表 key 的表尾, 当且仅当 key 存在并且是一个列表。 和 RPUSH 命令相反, 当 key 不存在时,RPUSHX 命令什么也不做

 
10.10.10.20:6379> RPUSHX mylist01 03  #key   mylist01不存在
(integer) 0
10.10.10.20:6379> LPUSHX mylist01 03  #key   mylist01不存在
(integer) 0
10.10.10.20:6379> LRANGE mylist 0 -1
1) "02"
2) "01"
3) "01"
4) "02"
#
10.10.10.20:6379> LPUSHX mylist 03
(integer) 5
10.10.10.20:6379> RPUSHX mylist 03
(integer) 6
10.10.10.20:6379> LRANGE mylist 0 -1
1) "03"
2) "02"
3) "01"
4) "01"
5) "02"
6) "03"

# 以此弹出、列表为空后key也会被删除
10.10.10.20:6379> LPOP mylist
"03"
10.10.10.20:6379> LPOP mylist
"02"
10.10.10.20:6379> LPOP mylist
"01"
10.10.10.20:6379> LPOP mylist
"01"
10.10.10.20:6379> LPOP mylist
"02"
10.10.10.20:6379> LPOP mylist
"03"
10.10.10.20:6379> LPOP mylist
(nil)
#
10.10.10.20:6379> KEYS *
1) "key2"
2) "mykey"
3) "car"

LINDEX
 
10.10.10.20:6379> LINDEX mylist -1  #获取最后一个值
"04"


LTRIM key start stop

 
  LTRIM key start stop

修剪(trim)一个已存在的 list,这样 list 就会只包含指定范围的指定元素。start 和 stop 都是由0开始计数的, 这里的 0 是列表里的第一个元素(表头),1 是第二个元素,以此类推。

例如: LTRIM foobar 0 2 将会对存储在 foobar 的列表进行修剪,只保留列表里的前3个元素。

start 和 end 也可以用负数来表示与表尾的偏移量,比如 -1 表示列表里的最后一个元素, -2 表示倒数第二个,等等。

超过范围的下标并不会产生错误:如果 start 超过列表尾部,或者 start > end,结果会是列表变成空表(即该 key 会被移除)。 如果 end 超过列表尾部,Redis 会将其当作列表的最后一个元素。

LTRIM 的一个常见用法是和 LPUSH / RPUSH 一起使用。 例如:

  • LPUSH mylist someelement
  • LTRIM mylist 0 99

这一对命令会将一个新的元素 push 进列表里,并保证该列表不会增长到超过100个元素。这个是很有用的,比如当用 Redis 来存储日志。 需要特别注意的是,当用这种方式来使用 LTRIM 的时候,操作的复杂度是 O(1) , 因为平均情况下,每次只有一个元素会被移除。

 
10.10.10.20:6379> LRANGE mylist 0 -1
1) "5"
2) "4"
3) "3"
4) "2"
5) "1"
10.10.10.20:6379> LTRIM mylist 1 2
OK
10.10.10.20:6379> LRANGE mylist 0 -1
1) "4"
2) "3"


BRPOP key [key ...] timeout

BRPOP 是一个阻塞的列表弹出原语。 它是 RPOP 的阻塞版本,因为这个命令会在给定list无法弹出任何元素的时候阻塞连接。 该命令会按照给出的 key 顺序查看 list,并在找到的第一个非空 list 的尾部弹出一个元素。

请在 BLPOP 文档 中查看该命令的准确语义,因为 BRPOP 和 BLPOP 基本是完全一样的,除了它们一个是从尾部弹出元素,而另一个是从头部弹出元素
 

-- brpop key [key1 ...] timeout
    # rpop命令的阻塞版本
    命令会以从左到右的顺序,访问给定的各个列表,并弹出首个非空列表
    最右端的项;
    如果所有给定列表都为空,那么客户端将被阻塞,直到等待超时,或者
    有可弹出的项出现为止;
    设置timeout参数为0表示永远阻塞;
10.10.10.20:6379> LRANGE  list1 0 -1  #list1的内容
1) "a"
2) "b"
3) "c"
10.10.10.20:6379> LRANGE  list2 0 -1   #list2位空
(empty list or set)
10.10.10.20:6379> BRPOP list1 list2  10   #删除有值
1) "list1"
2) "c"
10.10.10.20:6379> BRPOP list1 list2  10 
1) "list1"
2) "b"
10.10.10.20:6379> BRPOP list1 list2  10 
1) "list1"
2) "a"
10.10.10.20:6379> BRPOP list1 list2  10  #当都没有值的时候、设置10秒
(nil)
(10.10s)
10.10.10.20:6379> BRPOP list1 list2  0   #当都没有值的时候、设置0秒,阻塞连接(会一直卡这里)
 

    使用场景:消息队列(负载均衡,高可用)
  lpush + lpop = stack(栈)   1-2-3顺序写入   3-2-1顺序弹出
  lpush + rpop = Queue(队列) 1-2-3顺序写入   1-2-3顺序弹出
  lpush + ltrim = Capped set(有限集合)  1-2-3-4-5 写入    srim  LTRIM mylist 1 2    保留4-3

  lpush + brpop = message Queue(消息队列)



Redis数据类型---列表--集合--有集合比较


 
 
   
Set(集合)

 
 
SET集合:无序
10.10.10.20:6379> SADD word a   #添加一个集合key word 并添加元素a
(integer) 1
10.10.10.20:6379> SADD word a b  c #同时添加多个元素,如果存在则忽略
(integer) 2
10.10.10.20:6379> SADD word a b c d e   #同时添加多个元素,如果存在则忽略
(integer) 2
10.10.10.20:6379> SREM word a  #从key里删除一个元素
(integer) 1
10.10.10.20:6379> SMEMBERS word  #查看集合key里所有的元素
1) "c"
2) "e"
3) "b"
4) "d"
10.10.10.20:6379> SCARD word  #获取集合里的元素数量
(integer) 4
10.10.10.20:6379> SISMEMBER word e #判断集和里有没有e这个元素,有则返回1 没有则返回0
(integer) 1
10.10.10.20:6379> SISMEMBER word x  #判断集和里有没有想x这个元素,有则返回1 没有则返回0
(integer) 0
10.10.10.20:6379> SADD word1  c d e f h #添加一个新的集合word1
(integer) 5
10.10.10.20:6379> SMEMBERS word1    #查看集合word1里所有的元素
1) "d"
2) "e"
3) "c"
4) "f"
5) "h"
#------------SDIFFSTORE(把两个集合的差集合并到一个新的集合、新集合可以是已经存在的,但是会清空原有数据)——---------------
10.10.10.20:6379> SMEMBERS setA
1) "1"
2) "2"
3) "3"
4) "4"
10.10.10.20:6379> SMEMBERS setB
1) "3"
2) "4"
3) "5"
4) "6"
10.10.10.20:6379> SDIFFSTORE setAB setA setB
(integer) 2
10.10.10.20:6379> SDIFFSTORE setBA setB setA
(integer) 2
10.10.10.20:6379> SMEMBERS setAB
1) "1"
2) "2"
10.10.10.20:6379> SMEMBERS setBA
1) "5"
2) "6"
#新集合可以是已经存在的,但是会清空原有数据
10.10.10.20:6379> SADD word a b c d #增加一个集合word
(integer) 4
10.10.10.20:6379> SMEMBERS word #查看集合word内容
1) "a"
2) "5"
3) "d"
4) "6"
5) "b"
6) "c"
10.10.10.20:6379> SDIFFSTORE word setB setA #把setB和setA的内容插入到word
(integer) 2
10.10.10.20:6379> SMEMBERS word #获取word值 原来的已经被新的覆盖
1) "5"
2) "6"

#--------交集-差集-并集-----------------------------------------------

10.10.10.20:6379> SADD setA 1 2 3 4
(integer) 4
10.10.10.20:6379> SADD setB 3 4 5 6
(integer) 4
10.10.10.20:6379> SDIFF setA setB  #差集
1) "1"
2) "2"
10.10.10.20:6379> SDIFF setB setA  #差集
1) "5"
2) "6"
10.10.10.20:6379> SINTER setB setA  #交集
1) "3"
2) "4"
10.10.10.20:6379> SUNION setA setB  #并集
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"
6) "6"
 

  SortedSet(有序集合)
 


ZAAD

将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
如果某个 member 已经是有序集的成员,那么更新这个 member 的 score 值,并通过重新插入这个 member 元素,来保证该 member 在正确的位置上。
score 值可以是整数值或双精度浮点数。
如果 key 不存在,则创建一个空的有序集并执行 ZADD 操作。
当 key 存在但不是有序集类型时,返回一个错误

 
# 添加单个元素
redis> ZADD myzset 10 google.com
(integer) 1

# 添加多个元素
redis> ZADD myzset 9 baidu.com 8 bing.com
(integer) 2

#列出所有元素
redis> ZRANGE myzset 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"

# 添加已存在元素,且 score 值不变
redis> ZADD myzset 10 google.com
(integer) 0
redis> ZRANGE myzset 0 -1 WITHSCORES  # 没有改变
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"

# 添加已存在元素,但是改变 score 值
redis> ZADD myzset 6 bing.com
(integer) 0
redis> ZRANGE myzset 0 -1 WITHSCORES  # bing.com 元素的 score 值被改变
1) "bing.com"
2) "6"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"
#---------------------------

ZCARD

返回有序集 key的元素个数
当 key 存在且是有序集类型时,返回有序集的基数。
当 key 不存在时,返回 0

 
10.10.10.20:6379> ZCARD myzset #当key存在的时候返回个数
(integer) 4
10.10.10.20:6379> ZCARD myzset01 #当kye不存在的时候返回0
(integer) 0

ZCOUNT

#返回有序集 key 中, score值在 min和max之间(默认包括 score 值等于 min 或 max )的成员的数量
返回值:score 值在 min 和 max 之间的成员的数量


 
10.10.10.20:6379> ZRANGE wage 0 -1 WITHSCORES
1) "jack"
2) "2000"
3) "peter"
4) "3000"
5) "tom"
6) "5000"
7) "lin"
8) "8000"
10.10.10.20:6379> ZCOUNT wage 2000 3000
(integer) 2
10.10.10.20:6379> ZCOUNT wage 5000 8000
(integer) 2
10.10.10.20:6379> ZCOUNT wage  8000 10000
(integer) 1
#---------------------------

ZINCRBY

为有序集 key 的成员 member 的 score 值加上增量 increment 。
可以通过传递一个负数值 increment ,让 score 减去相应的值,比如 ZINCRBY key -5 member ,就是让 member 的 score 值减去 5 。
当 key 不存在,或 member 不是 key 的成员时, ZINCRBY key increment member 等同于 ZADD key increment member 。
当 key 不是有序集类型时,返回一个错误。
score 值可以是整数值或双精度浮点数
返回值:member 成员的新 score 值,以字符串形式表示

 
10.10.10.20:6379> ZRANGE wage 0 -1 WITHSCORES #数据
1) "jack"
2) "2000"
3) "peter"
4) "3000"
5) "tom"
6) "5000"
7) "lin"
8) "8000"
10.10.10.20:6379> ZSCORE wage lin #查看集合里元素lin的score
"8000"
10.10.10.20:6379> ZINCRBY wage 10000 lin  #lin的score增加
"18000"
10.10.10.20:6379> ZINCRBY wage 4000 yaohong #当yaohong不存在时。等同于ZADD添加一个
"4000"
10.10.10.20:6379> ZRANGE wage 0 -1 WITHSCORES
 1) "jack"
 2) "2000"
 3) "peter"
 4) "3000"
 5) "yaohong"
 6) "4000"
 7) "tom"
 8) "5000"
 9) "lin"
10) "11000"


ZRANGE

指定区间内,带有 score 值(可选)的有序集成员的列表
其中成员的位置按 score 值递增(从小到大)来排序。
具有相同 score 值的成员按字典序(lexicographical order )来排列。
如果你需要成员按 score 值递减(从大到小)来排列,请使用 ZREVRANGE 命令

可以通过使用 WITHSCORES 选项,来让成员和它的 score 值一并返回,返回列表以 value1,score1, ..., valueN,scoreN 的格式表示。
客户端库可能会返回一些更复杂的数据类型,比如数组、元组等

 

ZREVRANGE

返回有序集 key 中,指定区间内的成员。
其中成员的位置按 score 值递减(从大到小)来排列。
具有相同 score 值的成员按字典序的逆序(reverse lexicographical order)排列。
除了成员按 score 值递减的次序排列这一点外, ZREVRANGE 命令的其他方面和 ZRANGE 命令一样

先看区别
10.10.10.20:6379> ZREVRANGE wage  0 -1 WITHSCORES
 1) "lin"
 2) "18000"
 3) "tom"
 4) "5000"
 5) "yaohong"
 6) "4000"
 7) "peter"
 8) "3000"
 9) "jack"
10) "2000"
10.10.10.20:6379> ZRANGE wage 0 -1 WITHSCORES
 1) "jack"
 2) "2000"
 3) "peter"
 4) "3000"
 5) "yaohong"
 6) "4000"
 7) "tom"
 8) "5000"
 9) "lin"
10) "18000"

 
10.10.10.20:6379> ZRANGE wage 0 -1
1) "jack"
2) "peter"
3) "ding"
4) "yaohong"
5) "tom"
6) "lin"
10.10.10.20:6379> ZRANGE wage 0 -1 WITHSCORES  # 显示整个有序集成员
 1) "jack"
 2) "2000"
 3) "peter"
 4) "3000"
 5) "yaohong"
 6) "4000"
 7) "tom"
 8) "5000"
 9) "lin"
10) "18000"
10.10.10.20:6379> ZRANGE wage 200 18000 WITHSCORES # 测试当给定区间不存在于有序集时的情况
(empty list or set)
#---------------------------------------------------------------
10.10.10.20:6379> ZRANGE wage 0 1 WITHSCORES
1) "jack"
2) "2000"
3) "peter"
4) "3000"
10.10.10.20:6379> ZRANGE wage 0 2 WITHSCORES
1) "jack"
2) "2000"
3) "peter"
4) "3000"
5) "ding"
6) "4000"
10.10.10.20:6379> ZRANGE wage 0 3 WITHSCORES
1) "jack"
2) "2000"
3) "peter"
4) "3000"
5) "ding"
6) "4000"
7) "yaohong"
8) "4000"
 

ZREVRANK key member

返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递减(从大到小)排序。
排名以 0 为底,也就是说, score 值最大的成员排名为 0 。

ZRANK key member

返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。
排名以 0 为底,也就是说, score 值最小的成员排名为 0 
 

10.10.10.20:6379> ZRANGE wage 0 -1  WITHSCORES
 1) "jack"
 2) "2000"
 3) "peter"
 4) "3000"
 5) "ding"
 6) "4000"
 7) "yaohong"
 8) "4000"
 9) "tom"
10) "5000"
11) "lin"
12) "18000"
10.10.10.20:6379> ZRANGE wage 0 -1
1) "jack"
2) "peter"
3) "ding"
4) "yaohong"
5) "tom"
6) "lin"
10.10.10.20:6379> ZRANK wage  ding    #其中有序集成员按 score 值递增(从小到大)顺序排列
(integer) 2
10.10.10.20:6379> ZREVRANK wage ding  #其中有序集成员按 score 值递减(从大到小)排序。
(integer) 3


ZREM

移除有序集 key 中的一个或多个成员,不存在的成员将被忽略。
当 key 存在但不是有序集类型时,返回一个错误
 

10.10.10.20:6379> ZRANGE wage 0 -1
1) "jack"
2) "peter"
3) "ding"
4) "yaohong"
5) "tom"
6) "lin"
10.10.10.20:6379> ZREM wage ding  #删除一个成员
(integer) 1
10.10.10.20:6379> ZRANGE wage 0 -1
1) "jack"
2) "peter"
3) "yaohong"
4) "tom"
5) "lin"
10.10.10.20:6379> ZREM wage ding1 #如果不存在返回0
(integer) 0


ZREMRANGEBYRANK key start stop

移除有序集 key 中,指定排名(rank)区间内的所有成员。

区间分别以下标参数 start 和 stop 指出,包含 start 和 stop 在内
 

ZREMRANGEBYSCORE key min max

移除有序集 key 中,所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员

 



ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]

返回有序集 key 中,所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列
 

ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]

返回有序集 key 中, score 值介于 max 和 min 之间(默认包括等于 max 或 min )的所有的成员。
有序集成员按 score 值递减(从大到小)的次序排列。

具有相同 score 值的成员按字典序的逆序(reverse lexicographical order )排列。
除了成员按 score 值递减的次序排列这一点外, ZREVRANGEBYSCORE 命令的其他方面和 ZRANGEBYSCORE 命令一样

 

10.10.10.20:6379> ZRANGE wage 0 -1 WITHSCORES
 1) "jack"
 2) "2000"
 3) "peter"
 4) "3000"
 5) "yaohong"
 6) "4000"
 7) "tom"
 8) "5000"
 9) "lin"
10) "18000"
10.10.10.20:6379> ZRANGEBYSCORE wage 3000 5000
1) "peter"
2) "yaohong"
3) "tom"
10.10.10.20:6379> ZREVRANGEBYSCORE wage 5000 3000
1) "tom"
2) "yaohong"
3) "peter"
#------------------------
10.10.10.20:6379> ZRANGEBYSCORE wage -inf +inf
1) "jack"
2) "peter"
3) "yaohong"
4) "tom"
5) "lin"
10.10.10.20:6379> ZRANGEBYSCORE wage -inf 3000
1) "jack"
2) "peter"
10.10.10.20:6379> ZRANGEBYSCORE wage (3000 (5000 #不包含3000和5000
1) "yaohong"
10.10.10.20:6379> ZRANGEBYSCORE wage 3000 5000
1) "peter"
2) "yaohong"
3) "tom"


ZSCORE key member

返回有序集 key 中,成员 member 的 score 值。
如果 member 元素不是有序集 key 的成员,或 key 不存在,返回 ni
 

10.10.10.20:6379> ZRANGE wage 0 -1 WITHSCORES
 1) "jack"
 2) "2000"
 3) "peter"
 4) "3000"
 5) "yaohong"
 6) "4000"
 7) "tom"
 8) "5000"
 9) "lin"
10) "18000"
10.10.10.20:6379> ZSCORE wage tom #返回值是字符串
"5000"
10.10.10.20:6379> ZSCORE wage tom1
(nil)


ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]
 

计算给定的一个或多个有序集的并集,其中给定 key 的数量必须以 numkeys 参数指定,并将该并集(结果集)储存到 destination 。

默认情况下,结果集中某个成员的 score 值是所有给定集下该成员 score 值之  

ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]
 

计算给定的一个或多个有序集的交集,其中给定 key 的数量必须以 numkeys 参数指定,并将该交集(结果集)储存到 destination 。

默认情况下,结果集中某个成员的 score 值是所有给定集下该成员 score 值之和.



 
温馨提示如有转载或引用以上内容之必要,敬请将本文链接作为出处标注,如有侵权我会在24小时之内删除!

欢迎使用手机扫描访问本站