此处将为大家介绍关于Redis5种主要数据类型和命令的详细内容，并且为您解答有关redis的五种数据类型命令的相关问题，此外，我们还将为您介绍关于Redis5种数据类型、Redis5种数据类型命令、r

此处将为大家介绍关于Redis 5种主要数据类型和命令的详细内容，并且为您解答有关redis的五种数据类型命令的相关问题，此外，我们还将为您介绍关于Redis 5种数据类型、Redis 5种数据类型命令、redis 5种数据类型增删改查、Redis _ lesson3 redis 常见的5种数据类型 与 常见的Redis-cli 返回值的有用信息。

• Redis 5种主要数据类型和命令（redis的五种数据类型命令）
• Redis 5种数据类型
• Redis 5种数据类型命令
• redis 5种数据类型增删改查
• Redis _ lesson3 redis 常见的5种数据类型 与 常见的Redis-cli 返回值

Redis 5种主要数据类型和命令（redis的五种数据类型命令）

[转载]https://www.cnblogs.com/mingtianct/p/6291593.html

Redis 5种数据类型

基于redis5

1:字符串类型

它可以存储任何类型的字符串,包括json字符串,二进制数据,允许最大容量为512MB

1:赋值和取值

set name 123rrr

get name

2:增加指定的整数(可以指定+多少)

INCR count   自动+1
INCRBY count 2  指定加多少

3:减少指定整数(自动-1:指定加多少)

decr count
decrby count  2

4:增加浮点数

incrbyfloat count2 0.1

5:向尾部追加值(如果键不存在,就直接设置成追加的值)

append name ss

6:获取字符串长度(中文占3个)

strlen name

 7:同时获取多个键

mget count2 name1 name

8:同时设置多个键值对

mset wanfei 123 wanlong 444

2:散列类型（hash）

散列类型（hash）的键值也是一种字典结构，其存储了字段（field）和字段值的映射，但字段值只能是字符串，不支持其他数据类型,一个散列类型键可以包含至多232−1个字段。

1:设置键

hset post:1 title redis入门
hset post:1 created_by 1

2:获取某个字段(获取文章1 的标题)

hget post:1 title

 3:获取键的所有字段和值

hgetall post:1

   获取所有的键不需要值

hkeys post:1

   获取所有的值

hvals post:1

4:获取多个字段的值

hmget post:1 title created_by

5:设置多个字段值

hmset post:1 deleted_at 222 updated_at 333

6:判断键的字段是否存在(不存在返回0)

hexists post:1 title

7:增加字段值数字

hincrby post:1 click 1

8:删除字段

hdel post:1 title click

3:列表类型

列表类型（list）可以存储一个有序的字符串列表，常用的操作是向列表两端添加元素，或者获得列表的某一个片段。列表类型内部是使用双向链表（doublelinkedlist）实现的
借助列表类型，Redis还可以作为队列使用，4.4节会详细介绍。与散列类型键最多能容纳的字段数量相同，一个列表类型键最多能容纳232−1个元素。

 1:向列表的左边添加值(添加完会返回列表中现在的个数) (列表中元素是可以重复的)

lpush posts post:1 

2:向列表的右边添加值 

rpush posts posts:2

3:向列表中添加多个

lpush posts posts:1 post:2 post:3

4:弹出列表中的值(弹出之后列表中就没有这个值了)

左侧的第一个   lpop posts
右侧的第一个   rpop posts

5:获取列表中元素的个数

llen posts

6:获取列表中指定位置到指定位置的元素(获取了不会删除这些)

lrange posts 0 2   redis的下标也是从0开始 一共获取了3个

没有从右边开始截取的命令,但是可以用负数

lrange posts -3 -1

从倒数第3个截取到倒数第一个

lrange posts 0 -1  可以列出所有的键

7:删除元素

lrem posts -2 post:7   从右边找 删除两个元素为post:7的

lrem posts 2 post:1    从左边找 删除两个元素为post:1的

（1）当count>0时LREM命令会从列表左边开始删除前count个值为value的元素。
（2）当count<0时LREM命令会从列表右边开始删除前count个值为value的元素。
（3）当count=0是LREM命令会删除所有值为value的元素

8:获取指定下标的元素

lindex posts 3 左边的第4个下标0
lindex post -3 右边第3个 

9:设置下标的元素的值

lset posts 0 post:0  左边第一个

10:只保留某些元素

ltrim posts 0 5   只保留这6个元素,其他全部删除

11:插到指定元素的前面后面

linsert posts after post:5 post:6      从左开始查找post:5元素然后将post:6插到它后头
linsert posts brefore post:5 post:6    从左开始查找post:5元素然后将post:6插到它前面

12:将列表元素移动到宁一个列表中(posts右边第一个移动到postTemp中的左边)

rpoplpush posts postsTemp

4:集合类型 (set)

集合类型的常用操作是向集合中加入或删除元素、判断某个元素是否存在等，由于集合类型在Redis内部是使用值为空的散列表（hashtable）实现的,集合的值不能重复

 1:添加

sadd posts post:1

2:删除值

srem posts post:1 post:2

3:获取所有值

smembers posts

4:比较两个集合,找不不一样的值 :场景  找出标签是 JAVA,Golang,Sql 这三个标签的文章

sdiff post:java post:net (post:java 有的post:net 没有的)

sdiff post:java post:net post:php (post:java 有的post:net 没有的,再拿这些不同的值和post:php比较 如果post:php 有就删除,剩下的就是只有post:java有的他们都没有的)

5:计算多个集合的交集

sinter post:java post:net    (post:java有的post:net也有的)

sinter post:java post:net post:php   (3个都有的)

6:计算几个集合所有的元素不重复

sunion post:java post:net post:php

7:集合的个数

scard post:java

8:将集合运算的结果存到集合中(会返回计算的结果个数)

sdiffstore destination post:java post:net  (不同) (存到destination中)
sinterstore destination post:java post:net  (交集)
sunionstore destinaction post:java post:net (并集)

9:随机从集合中取出元素(不会删除) (后面是每次随机取出多少个) 如果是-100 而且元素个数还没有100个就会出现重复的

srandmember post:java 1

10:随机弹出某个元素

spop post:java

5:有序集合zset

1 有序集合类型（sortedset）的特点从它的名字中就可以猜到，
2 它与介绍的集合类型的区别就是有序二字。
3 在集合类型的基础上有序集合类型为集合中的每个元素都关联了一个分数，
4 这使得我们不仅可以完成插入、删除和判断元素是否存在等集合类型支持的操作，
5 还能够获得分数最高（或最低）的合可以（通过更改这个元素的分数）。
6 有序集合要比列表类型更耗费内存。
7 有序集合类型算得上是Redis的5种数据类型中最高级的类型了，
8 在学习时可以与列表类型和集合类型对照理解

1:增加修改元素(添加多个,分数-值)

ZADD result 89 Tom 67 Peter 100 David

ZADD result 80 Tom 修改Tom的分数

zadd result +inf ymh 添加一个无限大的值,如果多个的话就按添加的顺序,后加的大
zadd result -inf wlphp 添加一个无限小的值,如果多个的话,先加的小

 2:获取元素的分数

zscore result wlphp

 3:按顺序找元素

zrange result 0 2  从小到大 第0个到第2个

zrevrange result 0 2 从大到小 最后一个到倒数第3个

zrange result 0 -1  从小到大排列所有的

zrange result 0 -1  withscores 会将分数值一起输出

如果两个元素的分数相同，Redis会按照字典顺序（即0<9<A<Z<a<z这样的顺序) 中文依旧,转成UTF8 编码之后还是这种顺序

4:获取指定分数之间的元素

zrangebyscore result 50 80   (50分到80分的)

zrangebyscore result 50 (80  在分数前加个( 就表示不包含这个值,意思就是大于等于50 小于80分的

zrangebyscore result 50 +inf  50分到无穷大分数,意思就是大于50分的

zrangebyscore result -inf 50  50分到无穷小分数,意思就是小于50分的

zrangebyscore result -inf +inf  无穷小到无穷大, 所有的

5:分页功能(牛皮)

 跟mysql 无太大差别 limit offset count   下标,取多少个

zrangebyscore result -inf +inf limit 0 2  

zrevrangebyscore result 100 -inf limit 0 2 低于100分的头两人

zrevrangebyscore是把分数按大到小排序的

 6:分数++ 比如张安琪很老实给他加个两分,突然狂皮再减去两分

zincrby result 2 zhanganqi
zincrby result -2 zhanganqi

如果指定的元素不存在，Redis在执行命令前会先建立它并将它的分数赋为0再执行操作

7:获取有序集合的元素个数

zcard result

 8:获取指定分数范围内元素的个数

zcount result 10 20

9:删除元素

zrem result wlphp ymh

zremrangebyrank result 0 1  按照排名范围删除元素

zremrangebyscore result 10 50 按照分数范围删除元素

 10:获取元素排名

zrank result ymh (从小到大)

zrevrank result ymh (从大到小)

 11:获取两个有序集合的交集

aggregate min 就会比较两个集合的值去最小的值,max就取最大的值

zinterstore des 2 result1  result aggregate max

zinterstore des 2 result1  result aggregate max weights 0.1 0.5   计算两个结果的交接  都取最大的值 第一个集合的结果*0.1 第二个*0.5,如果权重一个是0.1 一个是1 的话就会都*1 

计算有序集合的交集，并将结果保存起来

语法：ZINTERSTORE destination numkeys [WEIGHTS weight weight...] [AGGREGATE SUM | MIN | MAX]

destination ：代表计算结果保存的地方

Numkeys： 代表你要计算几个集合的交集

WEIGHTS ：代表权重，它可以设置每个元素的权重，也就是在每个元素参与计算时，元素的分数会乘以你指定的一个权重。

[AGGREGATE SUM | MIN | MAX]：代表元素如果有交集，是计算它的和、最大值还是最小值。

!!!

Redis 5种数据类型命令

在 Redis 数据类型 中我写了 Redis 的 5 种数据类型和一些简单的基础命令. 这一章再写一些更加深入的命令.

字符串

字符串可以存储以下三种类型的值:

• 字符串
• 整数
• 浮点数

整数的取值范围和系统的长整数 (long integer) 的取值范围相同 (在 322 位系统中, 整数就是 32 位有符号整数, 在 64 位系统中, 整数就是 64 位有符号整数), 而浮点数取值范围和精度则与 IEEE 754 标准的双精度浮点数 (double) 相同.

可以通过给定一个任意的数值, 对存储着整数或浮点数的字符串执行自增或自减操作, 在有需要的时候, Redis 还会将整数转换成浮点数.

如果用户对一个不存在的键或者一个保存了空串的键执行自增或自减操作, 那么这个键的值当作是 0 来处理. 如果值无法被解释为整数或者浮点数的字符串键执行自增或自减操作, Redis 就会返回一个错误.

自增自减命令

INCR key-name 将键存储的值加上 1, 返回执行完加 1 操作后的值.
INCRBY key-name amount 将键存储的值加上整数 amount . 返回加上 amount 后的值.
DECR key-name 将键存储的值减去 1, 返回执行完减 1 操作后的值.
DECRBY key-name amount 将键存储的值减去整数 amount. 返回减去 amount 后的值.
INCRBYFLOAT key-name amount 将键存储的值加上浮点数 amount. 返回加上 amount 后的值.

INCRBYFLOAT 如果 amount 为 3.0 则会将浮点数转换为整数也就是 3.

处理子串的命令

APPEND key-name value 将值 value 追加到指定的 key-name 当前存储的值得末尾, 返回追加后的长度. 如果不存在则同等于 key-name value.
SETRANGE key-name offset value 字符串替换. 返回替换后的字符串长度. 从 offset 偏移量开始, 替换为 value.
GETRANGE key-name start end 从 start 开始到 end 结束, 返回指定部分的字符串.

GETRANGE 包含 start 和 end. 如果读取字符串的时候, 超出字符串末尾的数据, 只会获取到最后.

如果我们要判断指定 key 是否存在可以使用 EXISTS, 若 key 存在返回 1, 否则返回 0.

列表

LRANGE key-name start end 返回列表从 start 偏移量到 end 偏移量范围内的所有元素.
LTRIM key--name start end 对列表进行修剪, 只保留从 start 偏移量到 end 偏移量范围内的元素.

阻塞式的列表弹出以及在列表之间移动元素的命令

BLPOP

BLPOP key-name [key-name] timeout 

阻塞行为

如果所有给定 key 都不存在或包含空列表, 那么 BLPOP 命令将阻塞连接, 直到等待超时, 或有另一个客户端对给定 key 的任意一个执行 LPUSH key value [value …] 或 RPUSH key value [value …] 命令为止.

超时参数 timeout 接受一个以秒为单位的数字作为值. 超时参数设为 0 表示阻塞时间可以无限期延长.

非阻塞行为

当 BLPOP 被调用时, 如果给定 key 内至少有一个非空列表, 那么弹出遇到的第一个非空列表的头元素, 并和被弹出元素所属的列表的名字一起, 组成结果返回给调用者.

当存在多个给定 key 时, BLPOP 按给定 key 参数排列的先后顺序, 依次检查各个列表.

假设现在有 job、 command 和 request 三个列表, 其中 job 不存在, command 和 request 都持有非空列表. 考虑以下命令:

BLPOP job command request 0

BLPOP 保证返回的元素来自 command, 因为它是按 ”查找 job -> 查找 command -> 查找 request “ 这样的顺序, 第一个找到的非空列表.

redis> DEL job command request           # 确保key都被删除
(integer) 0

redis> LPUSH command "update system..."  # 为command列表增加一个值
(integer) 1

redis> LPUSH request "visit page"        # 为request列表增加一个值
(integer) 1

redis> BLPOP job command request 0       # job 列表为空，被跳过，紧接着 command 列表的第一个元素被弹出。
1) "command"                             # 弹出元素所属的列表
2) "update system..."                    # 弹出元素所属的值

相同的 key 被多个客户端同时阻塞

相同的 key 可以被多个客户端同时阻塞.

不同的客户端被放进一个队列中, 按『先阻塞先服务』(first-BLPOP, first-served)的顺序为 key 执行 BLPOP 命令.

客户端1 执行参考如下:

blpop job 35

客户端2 执行参考如下:

blpop job 30

key job 是不存在的, 客户端1 超时时间为 35 秒, 客户端2 超时时间为 30 秒. 执行结果如下:

客户端2 先被打印, 然后在打印客户端1, 因为客户端2 的超时时间是 30 秒.

127.0.0.1:6379> blpop job 30
(nil)
(30.04s)

127.0.0.1:6379> blpop job 35
(nil)
(35.09s)

如果两个客户端的超时时间都为 0 会是怎样的呢?

这个时候就会像前面提到的, 按『先阻塞先服务』的顺序为 key 执行 BLPOP 命令.

RPOPLPUSH

RPOPLPUSH source-key dest-key

命令 RPOPLPUSH 在一个原子时间内, 执行以下两个动作:

• 将列表 source-key 中的最后一个元素(尾元素)弹出, 并返回给客户端.
• 将 source-key 弹出的元素插入到列表 dest-key, 作为 dest-key 列表的的头元素.

如果 source-key 不存在, 值 nil 被返回, 并且不执行其他动作.

如果 source-key 和 dest-key 相同(同一个key), 则列表中的表尾元素被移动到表头, 并返回该元素, 可以把这种特殊情况视作列表的旋转(rotation)操作.

模式: 安全的队列

Redis 的列表经常被用作队列(queue), 用于在不同程序之间有序地交换消息(message). 一个客户端通过 LPUSH key value [value …] 命令将消息放入队列中, 而另一个客户端通过 RPOP key 或者 BRPOP key [key …] timeout 命令取出队列中等待时间最长的消息.

不幸的是, 上面的队列方法是『不安全』的, 因为在这个过程中, 一个客户端可能在取出一个消息之后崩溃, 而未处理完的消息也就因此丢失.

使用 RPOPLPUSH 命令(或者它的阻塞版本 BRPOPLPUSH source destination timeout` )可以解决这个问题.

因为它不仅返回一个消息, 同时还将这个消息添加到另一个备份列表当中, 如果一切正常的话, 当一个客户端完成某个消息的处理之后, 可以用 LREM key count value 命令将这个消息从备份表删除.

最后, 还可以添加一个客户端专门用于监视备份表, 它自动地将超过一定处理时限的消息重新放入队列中去(负责处理该消息的客户端可能已经崩溃), 这样就不会丢失任何消息了.

模式: 循环列表

通过使用相同的 key 作为 RPOPLPUSH 命令的两个参数, 客户端可以用一个接一个地获取列表元素的方式, 取得列表的所有元素, 而不必像 LRANGE key start stop 命令那样一下子将所有列表元素都从服务器传送到客户端中.

以上的模式甚至在以下的两个情况下也能正常工作:

• 有多个客户端同时对同一个列表进行旋转(rotating), 它们获取不同的元素, 直到所有元素都被读取完, 之后又从头开始.
• 有客户端在向列表尾部(右边)添加新元素.

这个模式使得我们可以很容易实现这样一类系统: 有 N 个客户端, 需要连续不断地对一些元素进行处理, 而且处理的过程必须尽可能地快.

一个典型的例子就是服务器的监控程序: 它们需要在尽可能短的时间内, 并行地检查一组网站, 确保它们的可访问性.

注意, 使用这个模式的客户端是易于扩展(scala)且安全(reliable)的, 因为就算接收到元素的客户端执行失败, 元素还是保存在列表里面, 不会丢失, 等到下个迭代来临的时候, 别的客户端又可以继续处理这些元素了.

集合

SCARD key-name 返回集合 key 的基数. 当 key 不存在时, 返回 0.

随机返回元素

SRANDMEMBER key-name [count]

如果命令执行时, 只提供了 key 参数, 那么返回集合中的一个随机元素.

count 参数分为如下两种:

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

SPOP key-name [count]

移除并返回集合中的一个随机元素. 当 key 不存在或 key 是空集时, 返回 nil.

组合或处理多个集合

SMOVE source-key dest-key member

如果 source-key 集合不存在或不包含指定的 member 元素, 则 SMOVE 命令不执行任何操作, 仅返回 0(零). 否则, member` 元素从 source-key 集合中被移除, 并添加到 dest-key 集合中.

当 dest-key 集合已经包含 member 元素时, SMOVE 命令只是简单地将 source-key 集合中的 member 元素删除.

SDIFF key [key …]

返回那些存在于第一个集合, 但不存在于其他集合中的元素.

不存在的 key 被视为空集.

SDIFFSTORE destination key [key …]

这个命令的作用和 SDIFF key [key …] 类似, 但它将结果保存到 destination 集合, 而不是简单地返回结果集.

如果 destination 集合已经存在, 则将其覆盖.

destination 可以是 key 本身.

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

SINTER key [key …]

返回存在所有集合中的元素.

SUNION key [key …]

返回一个集合的全部成员, 该集合是所有给定集合的并集.

不存在的 key 被视为空集.

散列

HMSET key field value [field value …] 设置多个键值.
HVALS key  返回所有的值.
HKEYS key  返回所有的键.
HGETALL key 返回所有的键值.

HMGET key field [field …]

返回哈希表 key 中, 一个或多个给定域的值.

如果给定的域不存在于哈希表, 那么返回一个 nil 值.

因为不存在的 key 被当作一个空哈希表来处理, 所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表.

HEXISTS hash field

检查给定域 field 是否存在于哈希表 hash 当中. 给定域存在时返回 1, 在给定域不存在时返回 0.

HINCRBY key field increment

为哈希表 key 中的域 field 的值加上增量 increment.

增量也可以为负数, 相当于对给定域进行减法操作.

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

如果域 field 不存在, 那么在执行命令前, 域的值被初始化为 0.

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

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

HINCRBYFLOAT key field increment

为哈希表 key 中的域 field 加上浮点数增量 increment.

如果哈希表中没有域 field, 那么 HINCRBYFLOAT 会先将域 field 的值设为 0, 然后再执行加法操作.

如果键 key 不存在, 那么 HINCRBYFLOAT 会先创建一个哈希表, 再创建域 field, 最后再执行加法操作.

当以下任意一个条件发生时, 返回一个错误：

• 域 field 的值不是字符串类型 (因为 redis 中的数字和浮点数都以字符串的形式保存，所以它们都属于字符串类型)
• 域 field 当前的值或给定的增量 increment 不能解释 (parse) 为双精度浮点数(double precision floating point number).

有序集合

ZADD key score member [[score member] [score member] …]

将一个或多个 member 元素及其 score 值加入到有序集 key 当中.

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

score 值可以是整数值或双精度浮点数.

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

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

返回被成功添加的新成员的数量, 不包括那些被更新的, 已经存在的成员.

ZREM key member [member …] 移除有序集 key 中的一个或多个成员, 不存在的成员将被忽略. 被成功移除的成员的数量, 不包括被忽略的成员.
ZCARD key 当 key 存在且是有序集类型时, 返回有序集的基数. 当 key 不存在时, 返回 0.
ZCOUNT key min max 返回有序集 key 中, score 值在 min 和 max 之间的成员的数量.
ZRANK key member 返回有序集 key 中成员 member 的排名. 其中有序集成员按 score 值递增(从小到大)顺序排列.
ZREVRANK key member 返回有序集 key 中成员 member 的排名.其中有序集成员按 score 值递减(从大到小)排序.
ZSCORE key member 返回有序集 key 中, 成员 member 的 score 值. 如果 member 元素不是有序集 key 的成员, 或 key 不存在, 返回 nil.

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

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

具有相同 score 值的成员按字典序(lexicographical order)来排列(该属性是有序集提供的, 不需要额外的计算).

可选的 LIMIT 参数指定返回结果的数量及区间(就像SQL中的 SELECT LIMIT offset, count ), 注意当 offset 很大时, 定位 offset 的操作可能需要遍历整个有序集.

可选的 WITHSCORES 参数决定结果集是单单返回有序集的成员, 还是将有序集成员及其 score 值一起返回.

ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count] 从大到小.

交集和并集

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

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

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

WEIGHTS
使用 WEIGHTS 选项, 你可以为每个给定有序集分别指定一个乘法因子(multiplication factor), 每个给定有序集的所有成员的 score 值在传递给聚合函数(aggregation function)之前都要先乘以该有序集的因子.

如果没有指定 WEIGHTS 选项, 乘法因子默认设置为 1.

AGGREGATE
使用 AGGREGATE 选项, 你可以指定并集的结果集的聚合方式.

默认使用的参数 SUM, 可以将所有集合中某个成员的 score 值之和作为结果集中该成员的 score 值; 使用参数 MIN, 可以将所有集合中某个成员的最小 score 值作为结果集中该成员的 score 值; 而参数 MAX 则是将所有集合中某个成员的最大 score 值作为结果集中该成员的 score 值.

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

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

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

并集和交集的主要区别

我们现在有三个有序集合, 如下:

ZRANGE test1 0 -1 WITHSCORES
"z"
"1"
"a"
"2"
"e"
"3"

ZRANGE test2 0 -1 WITHSCORES
"a"
"1"

ZRANGE test3 0 -1 WITHSCORES
"r"
"2"

使用交集结果如下:

ZINTERSTORE destination 3 test1 test2 test3
(integer) 0

ZINTERSTORE destination 2 test1 test2
(integer) 1

test1 和 test2 中都存在成员是 "a" 的数据, 所以当我们执行第二条命令的时候, "a" 的成员被添加到了 destination 有序集中, 并且分值为 3(默认使用 SUM).

而执行第一条命令时, 并没添加到 destination 有序集中. 原因是 test3 中没有成员 "a".

交集只会将给定有序集中的相同成员添加到 destination 有序集中.
并集和交集不同, 只要某个成员存在于任意一个给定的有序集中, 都会被添加到 destination 有序集中.

redis 5种数据类型增删改查

 1 #  字符串 string
 2 （1）添加数据
 3 set key value  # 添加一条
 4 mset key value [key value...]  # 添加多条
 5 append  key value  # 添加到末尾

 

 6 (2) 删除数据
 7 del key # 删除key
 8 flushdb  #删除当前数据库所有key
 9 flushall  # 删除所有
10 
11 （3） 修改数据
12 rename key newkey   #改名
13 set key value  # 直接替换
14 （4）查看数据
15 get key  #查看一条
16 mget key [key...]  # 查看多条
17 keys * # 查看所有key

 

 1 #列表list
 2 (1) 添加数据
 3 lpush key value [value...]  # 头部插入

 4 rpush key value [value...]  # 尾部插入
 5 （2）删除数据
 6 lpop key # 删除左边第一个
 7 rpop  key  # 删除右边第一个
 8 lrem key count value # 删除指定数量的值 当count = 0 时 删除所有指定值

 9 （3）修改数据
10 lset key index newvalue  # 指定索引号修改
11 （4）查看数据
12 lindex key index # 返回指定索引值
13 lrange key start stop  # 查看索引范围内的值
14 llen key # 查看长度

 1 # 哈希 hash
 2 （1） 添加数据
 3 hset key field value  # 添加一条
 4 hmset key field value [field value...]
 5

 

 6 （2）删除数据
 7 hdel key field
 8 （3）修改数据
 9 ''''''覆盖''''''
10 （4）查看数据
11 hget key field  # 获取value
12 hmget key field [field...]  # 获取多个value
13 hvals key # 获取全部value
14 hkeys key  # 获取全部field
15 hgetall key  # 获取全部field 和 value
16 hlen key  # 查看有几个键值对

 1 # 集合 set
 2 (1)增
 3 sadd key member [member...]   #增加元素
 4 （2）删
 5 srem key member [member...] #移除元素
 6 spop key # 随机删除
 7 （3）改
 8 （4）查
 9 scard key # 返回key中元素个数
10 smemebers key # 获取集合中所有元素

11 （5）交集
12 sinter my_set1 my_set2 # 求交集
13 sinterstore newset my_set1 my_set2 # 交集合并到新集合
14 
15 （6）并集
16 sunion key1 key2  # 求并集
17 sunionstore newkey key1 key2 # 并集合并到新集合

18 （7）差集
19 sdiff key1 key2  # 差集
20 sdiffstore newkey key1 key2 # 差集合并到新集合

 1 # 有序集合 zset
 2 (1)增
 3 zadd key score member[ [score member] ..]
 4 （2）删
 5 zrem key member [member...]  #移除有序集合中的一个或多个元素，若member不存在则忽略；
 6 zremrangebyrank min max :
 7     # 删除集合中 score 在给定区间的元素
 8 （3）改
 9 （4）查
10 zscore key member  # 查看score值
11 zrange key start stop[withscores] #按索引返回key的成员， withscores表示显示score
12 zrangebyscore key min max  #返回集合中 score 在给定区间的元素

Redis _ lesson3 redis 常见的5种数据类型 与 常见的Redis-cli 返回值

Redis 中最常见的5种数据类型

1.String 字符串

2.Hash(哈希，类似于Java中的Map)

3.List 列表

4.Set 集合

5.ZSet sorted set 有序集合

1.String 字符串

Redis中最基础的数据类型，一个key 对应一个value

String是二进制安全的，可以包含任何数据类型，如jpg 或者序列化的对象

String是Redis基础数据类型，redis中的value字符串最多可以是512M

2.Hash(哈希，类似于Java中的Map)

Redis hash 为键值对集合

Redis hash string 类型的field -value 映射表， hash 特别适合存储对象

3.List 列表

Redis 里额表是最贱的的字符串列表。按照插入顺序排序，可以添加一个元素到头部（左边）或者尾部（右边）

底层是一个链表

4.Set 集合

Redis的Set 是String 的无须集合，通过HashTable实现的

5.ZSet sorted set 有序集合

今天关于Redis 5种主要数据类型和命令和redis的五种数据类型命令的分享就到这里，希望大家有所收获，若想了解更多关于Redis 5种数据类型、Redis 5种数据类型命令、redis 5种数据类型增删改查、Redis _ lesson3 redis 常见的5种数据类型 与 常见的Redis-cli 返回值等相关知识，可以在本站进行查询。