Redis 基础学习

最近想解决 [一刻社区] 中的一个 Issue [“增加用户活跃度统计”],其中的要求就是:利用 redis 位计算算法实现用户活跃度计算,突然发现有点不知所以然,虽然之前也用过 redis ,但是总的来说自己连它的文档都没读过,哈哈,就借着这个机会把 redis 基础知识巩固一下,然后解决 Issue 真棒,哈哈。

启动

  1. 启动:redis-server.exe redis.windows.conf / redis-server
  2. 连接:redis-cli.exe -h 127.0.0.1 -p 6379

redis 命令

  1. 启动客户端后利用 redis-cli 连接本地服务
  2. ping 检测 redis 服务是否启动
  3. 执行远程 redis 服务:

    redis-cli -h [HOST] -p [PORT] -a [PASSWORD]

数据类型

  1. string(字符串)
  2. hash(哈希)
    1. key:value (键值对集合),适合存储对象
  3. list(列表)
    1. 简单的字符串列表,可以添加元素到列表的头部和尾部
  4. set(集合)
    1. string 类型的无序集合
    2. 集合是通过哈希表实现的
  5. zset(有序集合)
    1. zset 和 set 一样也是 string 类型元素的集合,且不允许重复的成员
    2. 不同的是每个元素都会关联一个double 类型的分数。redis 正是通过分数来为集合中的成员进行从小到大的排序
    3. zset 的成员是唯一的,但分数 (score) 却可以重复

操作指南

key 操作

 -- SET KEY_NAME VALUE(设置给定 key 的值。如果 key 已经存储其他值, SET 就覆写旧值,且无视类型) > set name Lhao
 -- GET KEY_NAME (获取指定 key 的值。如果 key 不存在,返回 nil 。如果key 储存的值不是字符串类型,返回一   个错误) > get name // 输出:Lhao
 -- DUMP KEY_NAME (序列化 name,输出序列化之后的值) > dump name // 输出:"\x00\x04Lhao\t\x00\xd3JL\xcf\xafsi\x8f"
 -- EXISTS KEY_NAME (判断 key 是否存在) > exists name // 输出:1
 -- Expire KEY_NAME TIME_IN_SECONDS (设置有效时间,过期之后则删除,单位:s , 可对已存在的 key 进行操作) > expire name 10 // 输出:1
 -- Expireat KEY_NAME TIME_IN_UNIX_TIMESTAMP (指定过期时间戳) > set name Lhao // 上面设置了过期时间,已经没了 ,哈哈 > expireat name 1551341040 // 输出:1
 -- KEYS PATTERN (用于查找所有符合给定模式 pattern 的 key ) > set name Lhao > keys * //(返回所有键名)输出:name > set naes haha > keys na* // 输出:name、naes
 -- SELECT index (切换到指定的数据库,数据库索引号 index 用数字值指定,以 0 作为起始索引值) > select 0 
 -- MOVE KEY_NAME DESTINATION_DATABASE (将当前数据库的 key 移动到给定的数据库 db 当) > move name 1 // (移动 name 到 1 数据库中) > exists name // 输出:0 > select 1 > exists name // 输出:1
 > expire name 10
 -- TTL KEY_NAME (以秒为单位返回 key 的剩余过期时间) > ttl name // 输出:8
 -- PERSIST KEY_NAME (移除给定 key 的过期时间,使得 key 永不过期) > persist name // 输出:1 > ttl name // 输出:-1 (表示不过期)
 -- DEL KEY_NAME (删除已存在的键。不存在的 key 会被忽略) > del name // 输出:1
 > set name Lhao > set age 24
 -- RANDOMKEY (从当前数据库中随机返回一个 key) > randomkey // 输出:age
 -- FLUSHDB (清空当前数据库中的所有 key) > flushdb
 > set name Lhao
 -- RENAME OLD_KEY_NAME NEW_KEY_NAME (修改 key 的名称) > rename name newname > get name // 输出:nli (不存在) > set namecopy wjh > rename newname namecopy > get namecopy // 输出:Lhao
 > set name Lhao
 -- RENAMENX OLD_KEY_NAME NEW_KEY_NAME (用于在新的 key 不存在时修改 key 的名称) > renamenx namecop name // 输出:0 (此时修改 key 名不成功)
 -- TYPE KEY_NAME (返回 key 所储存的值的类型) > type name // 输出:string

字符串 操作

 > flushdb
 > set title "my name is Lhao" > get title // 输出:my name is Lhao
 -- GETRANGE KEY_NAME start end (用于获取存储在指定 key 中字符串的子字符串。字符串的截取范围由 start 和 end 两个偏移量决定(包括 start 和 end 在内)) > getrange title 0 4 // 输出:my na
 -- GETSET KEY_NAME VALUE (用于设置指定 key 的值,并返回 key 的旧值) > getset title "new title" // 输出:my name is Lhao > get title // 输出:new title
 -- MGET KEY1 KEY2 .. KEYN (返回所有(一个或多个)给定 key 的值。 如果给定的 key 里面,有某个 key 不存在,那么这个 key 返回特殊值 nil ) > mget title name  // 输出:     1) (nil)     2) "new title"
 -- SETEX KEY_NAME TIMEOUT VALUE (为指定的 key 设置值及其过期时间。如果 key 已经存在, SETEX 命令将会替换旧的值) > setex name 60 liuhao
 > del name
 -- SETNX KEY_NAME VALUE(SET if Not eXists) 命令在指定的 key 不存在时,为 key 设置指定的值 > setnx name Lhao // 输出:1 > setnx title Lhao // 输出:0
 -- SETRANGE KEY_NAME OFFSET VALUE (用指定的字符串覆盖给定 key 所储存的字符串值,覆盖的位置从偏移量 offset 开始) > setrange name 3 Lhao // 输出:7 > get name // 输出:LhaLhao
 -- STRLEN KEY_NAME (用于获取指定 key 所储存的字符串值的长度。当 key 储存的不是字符串值时,返回一个错误) > strlen name // 输出:7
 -- 用于同时设置一个或多个 key-value 对 (MSET key1 value1 key2 value2 .. keyN valueN ) > mset name Lhao age 24 // 输出:ok > mget name age  // 输出:     1) "Lhao"     2) "24"
 -- MSETNX key1 value1 key2 value2 .. keyN valueN (用于所有给定 key 都不存在时,同时设置一个或多个 key-value 对) > msetnx name Lhao age 24 // 输出:0 > msetnx name Lhao25 sex men //输出:0 > get sex // 输出:nli
 -- INCR KEY_NAME     // 将 key 中储存的数字值增一。    // 如果 key 不存在,那么 key 的值会先被初始化为 0 ,然后再执行 INCR 操作。    // 如果值包含错误的类型,或字符串类型的值不能表示为数字,那么返回一个错误。    // 本操作的值限制在 64 位(bit)有符号数字表示之内。 > incr name // 输出:(error) ERR value is not an integer or out of range > incr money // 输出:1
 -- DECRBY KEY_NAME DECREMENT_AMOUNT (将 key 中储存的数字加上指定的增量值) > incrby money 80 // 输出:81
 -- DECR KEY_NAME (将 key 中储存的数字值减一) > decr money // 输出:80
 -- DECRBY KEY_NAME DECREMENT_AMOUNT (将 key 所储存的值减去指定的减量值) > decrby money 10 // 输出:70
 -- APPEND KEY_NAME NEW_VALUE    // 为指定的 key 追加值。    // 如果 key 已经存在并且是一个字符串, APPEND 命令将 value 追加到 key 原来的值的末尾。    // 如果 key 不存在, APPEND 就简单地将给定 key 设为 value ,就像执行 SET key value 一样。 > appen name " love" //  输出:8 > get name // 输出:Lhaolove

哈希 操作

 > flushdb
 -- HSET KEY_NAME FIELD VALUE (用于为哈希表中的字段赋值;如果哈希表不存在,一个新的哈希表被创建并进行 HSET 操作;如果字段已经存在于哈希表中,旧值将被覆盖) > hset user name Lhao // 输出:1
 -- HGET KEY_NAME FIELD_NAME (用于返回哈希表中指定字段的值) > hget user name // 输出:Lhao
 > hset user name wjh // 输出:0 > hget user name // 输出:wjh
 -- HMSET KEY_NAME FIELD1 VALUE1 ...FIELDN VALUEN (用于同时将多个 field-value (字段-值)对设置到哈希表中) > hmset user name Lhao age 24 // 输出:ok > hmget user name age // 输出:     1) "Lhao"     2) "24"
 -- HDEL KEY_NAME FIELD1.. FIELDN(用于删除哈希表 key 中的一个或多个指定字段,不存在的字段将被忽略) > hdel user name // 输出:1
 -- HEXISTS KEY_NAME FIELD_NAME (用于查看哈希表的指定字段是否存在) > hexists user name // 输出:0
 -- HGETALL KEY_NAME (用于返回哈希表中,所有的字段和值;在返回值里,紧跟每个字段名(field name)之后是字段的值(value),所以返回值的长度是哈希表大小的两倍) > hgetall user // 输出:     1) "age"     2) "24"
 -- HINCRBY KEY_NAME FIELD_NAME INCR_BY_NUMBER(用于为哈希表中的字段值加上指定增量值) > hincrby user age 1 // 输出:25
 -- HKEYS key (用于获取哈希表中的所有域(field)) > hkeys user // 输出:    1) "age"
 -- HLEN KEY_NAME (用于获取哈希表中字段的数量) > hlen user //  输出:1
 -- HSETNX KEY_NAME FIELD VALUE(用于为哈希表中不存在的的字段赋值) > hsetnx user name hao // 输出:1 > hsetnx user age 24 // 输出:0
 -- HVALS KEY_NAME FIELD VALUE(返回哈希表所有域(field)的值) > hvals user  // 输出:    1) "25"    2) "Lhao"

列表 操作

 > flushdb
 -- LPUSH KEY_NAME VALUE1.. VALUEN (将一个或多个值插入到列表头部。 如果 key 不存在,一个空列表会被创建并执行 LPUSH 操作。 当 key 存在但不是列表类型时,返回一个错误。) > lpush users Lhao wjh // 输出:2
 -- LRANGE KEY_NAME START END (返回列表中指定区间内的元素,区间以偏移量 START 和 END 指定。 其中 0 表示列表的第一个元素, 1 表示列表的第二个元素,以此类推。 你也可以使用负数下标,以 -1 表示列表的最后一个元素, -2 表示列表的倒数第二个元素,以此类推) > lrange users 0 0 // 输出:wjh > lrange users 0 -1 // 输出:wjh、Lhao 
 -- BLPOP LIST1 LIST2 .. LISTN TIMEOUT (移出并获取列表的第一个元素, 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止) > blpop users 10  // 输出:    1) "users"    2) "wjh" > lrange users 0 -1 // 输出:Lhao
 -- BRPOPLPUSH LIST1 ANOTHER_LIST TIMEOUT (从列表中弹出第一个值,将弹出的元素插入到另外一个列表中并返回它; 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。) > brpoplpush users users_two 10 // 输出:Lhao > lrange users 0 -1 // 输出:(empty list or set) > lrange users_two 0 -1 // 输出:Lhao
 > lpush users wjh Lhao
 -- LINDEX KEY_NAME INDEX_POSITION (用于通过索引获取列表中的元素。你也可以使用负数下标,以 -1 表示列表的最后一个元素, -2 表示列表的倒数第二个元素,以此类推。) > lindex users 0 // 输出:lhao > lindex users -1 // 输出:wjh
 > del users
 -- RPUSH KEY_NAME VALUE1..VALUEN (用于将一个或多个值插入到列表的尾部(最右边);如果列表不存在,一个空列表会被创建并执行 RPUSH 操作。 当列表存在但不是列表类型时,返回一个错误) > rpush users Lhao wjh > lrange 0 -1 // 输出:Lhao wjh
 -- LINSERT key BEFORE|AFTER pivot value (用于在列表的元素前或者后插入元素。当指定元素不存在于列表中时,不执行任何操作;当列表不存在时,被视为空列表,不执行任何操作;如果 key 不是列表类型,返回一个错误) > linsert users before wjh love // 输出:3 > lrange 0 -1 // 输出:Lhao love wjh
 -- LLEN KEY_NAME (用于返回列表的长度。 如果列表 key 不存在,则 key 被解释为一个空列表,返回 0 。 如果 key 不是列表类型,返回一个错误) > llen users // 输出:3
 -- Lpop KEY_NAME (用于移除并返回列表的第一个元素) > lpop users // 输出:Lhao > lrange users 0 -1 // 输出:love wjh
 -- LPUSHX KEY_NAME VALUE1.. VALUEN (将一个值插入到已存在的列表头部,列表不存在时操作无效) > lpushx users Lhao // 输出:3 > lrange users 0 -1 // 输出:Lhao love wjh > lpushx user you // 输出:0 > lpush users Lhao Lhao // 输出:5 > lrange users 0 -1 // 输出:Lhao Lhao Lhao love wjh
 -- LREM KEY_NAME COUNT VALUE    // 根据参数 COUNT 的值,移除列表中与参数 VALUE 相等的元素    // count > 0 : 从表头开始向表尾搜索,移除与 VALUE 相等的元素,数量为 COUNT 。    // count < 0 : 从表尾开始向表头搜索,移除与 VALUE 相等的元素,数量为 COUNT 的绝对值。    // count = 0 : 移除表中所有与 VALUE 相等的值。
 > lrem users 2 Lhao // 输出:2 > lrange users 0 -1 // 输出:Lhao love wjh 
 -- LSET KEY_NAME INDEX VALUE (通过索引来设置元素的值;当索引参数超出范围,或对一个空列表进行 LSET 时,返回一个错误) > lset users 0 liuhao // 输出:ok > lrange users 0 -1 // 输出:liuhao love wjh
 > lpush fruit apple cherry strawbrerry
 -- LTRIM KEY_NAME START STOP (对一个列表进行修剪(trim),就是说,让列表只保留指定 区间内的元素,不在指定区间之内的元素都将被删除;下标 0 表示列表的第一个元素,以 1 表示列表的第二个元素,以此类推。 你也可以使用负数下标,以 -1 表示列表的最后一个元素, -2 表示列表的倒数第二个元素,以此类推。) > ltrim fruit 1 -1 // 输出:ok > lrange fruit 0 -1 // 输出:cherry apple
 -- RPOP KEY_NAME (用于移除列表的最后一个元素,返回值为移除的元素) > rpop fruit // 输出:apple > lrange fruit 0 -1 // 输出:cherry
 > lpush fruit apple cherry // 输出:3
 -- RPOPLPUSH SOURCE_KEY_NAME DESTINATION_KEY_NAME (用于移除列表的最后一个元素,并将该元素添加到另一个列表并返回) > rpoplpush fruit users // 输出:cherry > lrange users 0 -1 // 输出:cherry、apple

集合 操作

 > flushdb
 -- SADD KEY_NAME VALUE1..VALUEN(将一个或多个成员元素加入到集合中,已经存在于集合的成员元素将被忽略;假如集合 key 不存在,则创建一个只包含添加的元素作成员的集合;当集合 key 不是集合类型时,返回一个错误。) > sadd users wjh Lhao // 输出:2 > sadd users wjh // 输出:0 
 -- SMEMBERS key (返回集合中的所有的成员。 不存在的集合 key 被视为空集合) > smembers users // 输出:wjh Lhao
 -- SCARD KEY_NAME (返回集合中元素的数量) > scard users // 输出:2 
 > sadd usersTwo abing laoxia  > smembers usersTwo // 输出:abing laoxia
 -- SDIFF FIRST_KEY OTHER_KEY1..OTHER_KEYN (返回给定集合之间的差集。不存在的集合 key 将视为空集;差集的结果来自前面的 FIRST_KEY ,而不是后面的 OTHER_KEY1,也不是整个 FIRST_KEY OTHER_KEY1..OTHER_KEYN 的差集) > sdiff users usersTwo // 输出:wjh Lhao > sadd usersTwo Lhao > sdiff users usersTwo // 输出:wjh
 -- SDIFFSTORE DESTINATION_KEY KEY1..KEYN (将给定集合之间的差集存储在指定的集合中。如果指定的集合 key 已存在,则会被覆盖) > sdiffstore usersThree users usersTwo // 输出:1 > smembers usersThree // 输出:wjh
 > del users usersTwo usersThree
 > sadd users wjh Lhao > sadd usersTwo Lhao abing laoxia
 -- SINTER KEY KEY1..KEYN (返回给定所有给定集合的交集。 不存在的集合 key 被视为空集。 当给定集合当中有一个空集时,结果也为空集(根据集合运算定律)) > sinter users usersTwo // 输出:Lhao
 -- SINTERSTORE DESTINATION_KEY KEY KEY1..KEYN (将给定集合之间的交集存储在指定的集合中。如果指定的集合已经存在,则将其覆盖) > sinterstore usersThree users usersTwo  > smembers usersThree // 输出:Lhao
 -- SISMEMBER KEY VALUE (判断成员元素是否是集合的成员) > sismember users Lhao // 输出:1
 > sadd fruits apple cherry > sadd fruitsTwo strawbrerry
 -- SMOVE SOURCE DESTINATION MEMBER    // 将指定成员 member 元素从 source 集合移动到 destination 集合。    // SMOVE 是原子性操作。    // 如果 source 集合不存在或不包含指定的 member 元素,则 SMOVE 命令不执行任何操作,仅返回 0 。否则, member 元素从 source 集合中被移除,并添加到 destination 集合中去。    // 当 destination 集合已经包含 member 元素时, SMOVE 命令只是简单地将 source 集合中的 member 元素删除。    // 当 source 或 destination 不是集合类型时,返回一个错误。 > smove fruitsTwo fruits strawbrerry  // 输出:1 > smembers fruits // 输出:cherry、apple、strawbrerry
 -- SPOP key [count] (移除集合中的指定 key 的一个或多个随机元素,移除后会返回移除的元素) > spop fruits // 输出:cherry > smembers druits // 输出:strawbrerry、apple
 -- SRANDMEMBER KEY [count] (返回集合中一个或多个随机数) > srandmember fruit // 输出:apple 
 -- SREM KEY MEMBER1..MEMBERN (移除集合中的一个或多个成员元素,不存在的成员元素会被忽略) > srem fruits apple // 输出:1 > smembers fruits // 输出:strawbrerry
 -- SUNION KEY KEY1..KEYN (返回给定集合的并集。不存在的集合 key 被视为空集) > flushdb > sadd fruits apple cherry  > sadd fruitsTwo apple strawberry > sunion fruits fruitsTwo // 输出:cherry、strawberry、apple
 -- SUNIONSTORE DESTINATION KEY KEY1..KEYN (将给定集合的并集存储在指定的集合 destination 中。如果 destination 已经存在,则将其覆盖) > sunionstore fruitsThree fruits fruitsTwo > smembers fruitsThree // 输出:cherry、strawberry、apple
 -- SSCAN key cursor [MATCH pattern] [COUNT count] (用于迭代集合中键的元素) > sscan fruitsThree 0 match a* // (    输出:1) "0"         2) 1) "apple"    )

有序集合 操作

> flushdb
 -- ZADD KEY_NAME SCORE1 VALUE1.. SCOREN VALUEN    // 用于将一个或多个成员元素及其分数值加入到有序集当中。    // 如果某个成员已经是有序集的成员,那么更新这个成员的分数值,并通过重新插入这个成员元素,来保证该成员在正确的位置上。    // 分数值可以是整数值或双精度浮点数。    // 如果有序集合 key 不存在,则创建一个空的有序集并执行 ZADD 操作。    // 当 key 存在但不是有序集类型时,返回一个错误。 > zadd myzset 1 "one" // 输出:1 > zadd myzset 1 "uno" > zadd myzset 2 "two" 3 "three"
 -- ZRANGE key start stop [WITHSCORES]    // 返回有序集中,指定区间内的成员。    // 其中成员的位置按分数值递增(从小到大)来排序。    // 具有相同分数值的成员按字典序(lexicographical order )来排列。    // 如果你需要成员按值递减(从大到小)来排列,请使用 ZREVRANGE 命令。    // 下标参数 start 和 stop 都以 0 为底,也就是说,以 0 表示有序集第一个成员,以 1 表示有序集第二个成员,以此类推。    // 你也可以使用负数下标,以 -1 表示最后一个成员, -2 表示倒数第二个成员,以此类推 > zrange myzset 0 -1 WITHSCORES // 输出:     1) "one"     2) "1"     3) "uno"     4) "1"     5) "two"     6) "2"     7) "three"     8) "3"
 -- ZCARD KEY_NAME (用于计算集合中元素的数量) > zcard myzset // 输出:4
 -- ZCOUNT key min max (用于计算有序集合中指定分数区间的成员数量) > zcount myzset 1 3 // 输出:4
 -- ZINCRBY key increment member (对有序集合中指定成员的分数加上增量 increment) > zincrby myzset 2 "one" // 输出:3 > zrange myzset 0 -1 WITHSCORES // 输出:     1) "uno"     2) "1"     3) "two"     4) "2"     5) "one"     6) "3"     7) "three"     8) "3"
 > zadd mid_test 70 Lhao 70 wjh > zadd fin_test 80 Lhao 78 wjh
 -- ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX] (计算给定的一个或多个有序集的交集,其中给定 key 的数量必须以 numkeys 参数指定,并将该交集(结果集)储存到 destination 。) > zinterstore sum_point 2 mid_test fin_test > zrange sum_point 0 -1 WITHSCORES // 输出:     1) "wjh"     2) "148"     3) "Lhao"     4) "150"
 -- ZLEXCOUNT KEY MIN MAX (计算有序集合中指定字典区间内成员数量) > zadd newzset 0 a 0 b 0 c 0 d 0 e 0 f 0 g > zlexcount newzset - + // 输出:7 > zlexcount newzset [b [f // 输出:5
 -- ZRANGEBYLEX key min max [LIMIT offset count] (通过字典区间返回有序集合的成员) > zrangebylex newzset - [c // 输出:     1) "b"     2) "a"     3) "c" > zrangebylex newzset - (c  // 输出:     1) "b"     2) "a" > zrangebylex newzset [aaa (g  // 输出:     1) "b"     2) "a"     3) "c"     4) "d"     5) "e"     6) "f"
 > zadd salary 2500 jack 5000 tom 12000 peter
 -- ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]    // 返回有序集合中指定分数区间的成员列表。有序集成员按分数值递增(从小到大)次序排列。    // 具有相同分数值的成员按字典序来排列(该属性是有序集提供的,不需要额外的计算)。    // 默认情况下,区间的取值使用闭区间 (小于等于或大于等于),你也可以通过给参数前增加 ( 符号来使用可选的开区间 (小于或大于) > zrangebyscore salary -inf +inf #显示整个有序集 // 输出:     1) "jack"     2) "tom"     3) "peter" > zrangebyscore salary -inf +inf WITHSCORES # 显示整个有序集及成员的 score 值 // 输出:     1) "jack"     2) "2500"     3) "tom"     4) "5000"     5) "peter"     6) "12000" > zrangebyscore salary -inf 5000 WITHSCORES # 显示工资 <=5000 的所有成员 // 输出:     1) "jack"     2) "2500"     3) "tom"     4) "5000" > zrangebyscore salary (5000 400000 # 显示工资大于 5000 小于等于 400000 的成员 // 输出:    1) "peter"
 -- ZRANK key member (返回有序集中指定成员的排名。其中有序集成员按分数值递增(从小到大)顺序排列) > zrank salary tom // 输出:1 ( # tom 的薪水排名,第二)
 -- ZREM key member [member ...] (用于移除有序集中的一个或多个成员,不存在的成员将被忽略;当 key 存在但不是有序集类型时,返回一个错误) > zrem salary tom // 输出:1 > zrangebyscore salary -inf +inf WITHSCORES // 输出:     1) "jack"     2) "2500"     3) "peter"     4) "12000"
 > zadd myzset 0 aaaa 0 b 0 c 0 d 0 e 0 foo 0 zap 0 zip 0 ALPHA 0 alpha
 -- ZREMRANGEBYLEX key min max(用于移除有序集合中给定的字典区间的所有成员) > zremrangebylex myzset [alpha [omega // 输出:6 > zrange myzset 0 -1 // 输出:     1) "ALPHA"     2) "aaaa"     3) "zap"     4) "zip"
 > zadd salary 5000 tom
 -- ZREMRANGEBYRANK key start stop(用于移除有序集中,指定排名(rank)区间内的所有成员) > zremrangebyrank salary 0 1 // 输出:2 > zrange salary 0 -1 WITHSCORES  // 输出:     1) "peter"     2) "12000"
 > zadd salary 2500 jack 5000 tom
 -- ZREMRANGEBYSCORE key min max (用于移除有序集中,指定分数(score)区间内的所有成员) > zremrangebyscore salary 1500 3500 // 输出:1 > zrange salary 0 -1 WITHSCORES // 输出:     1) "tom"     2) "5000"     3) "peter"     4) "12000"
 > zadd salary 2500 jack
 -- ZREVRANGE key start stop [WITHSCORES](返回有序集中,指定区间内的成员;其中成员的位置按分数值递减(从大到小)来排列。具有相同分数值的成员按字典序的逆序(reverse lexicographical order)排列;除了成员按分数值递减的次序排列这一点外, ZREVRANGE 命令的其他方面和 ZRANGE 命令一样) > zrevrange salary 0 -1 WITHSCORES // 输出:     1) "peter"     2) "12000"     3) "tom"     4) "5000"     5) "jack"     6) "2500"
 -- ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count](返回有序集中指定分数区间内的所有的成员。有序集成员按分数值递减(从大到小)的次序排列) > zrevrangebyscore salary +inf -inf # 逆序排列所有成员 //输出:     1) "peter"     2) "tom"     3) "jack" > zrevrangebyscore salary 10000 200 # 逆序排列薪水介于 10000 和 2000 之间的成员 // 输出:     1) "tom"     2) "jack"
 -- ZREVRANK key member(返回有序集中成员的排名。其中有序集成员按分数值递减(从大到小)排序;排名以 0 为底,也就是说, 分数值最大的成员排名为 0 ;使用 ZRANK 命令可以获得成员按分数值递增(从小到大)排列的排名) > zrevrank salary peter // 输出:0 > zrevrank salary tom // 输出:1
 -- ZSCORE key member (返回有序集中,成员的分数值。 如果成员元素不是有序集 key 的成员,或 key 不存在,返回 nil ) > zscore salary peter // 输出:12000
 > zadd programmer 2000 peter 3500 jack 5000 tom > zadd manager 2000 herry 3500 mary 4000 bob
 -- ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX](计算给定的一个或多个有序集的并集,其中给定 key 的数量必须以 numkeys 参数指定,并将该并集(结果集)储存到 destination;默认情况下,结果集中某个成员的分数值是所有给定集下该成员分数值之和)
 > zunionstore salary 2 programmer manager WEIGHTS 1 3 # # 公司决定加薪。。。除了程序员。。。 > zrange salary 0 -1 WITHSCORES // 输出:      1) "peter"      2) "2000"      3) "jack"      4) "3500"      5) "tom"      6) "5000"      7) "herry"      8) "6000"      9) "mary"     10) "10500"     11) "bob"     12) "12000"

结束语

这里只是简单的对 redis 的各种类型做了一下介绍以及一些操作方法,至于具体的应用以及高阶的操作,后面等我学了再放上来,哈哈。

相关链接

  1. 一刻社区源码:https://github.com/overtrue/api.yike.io
  2. issue 地址:https://github.com/overtrue/api.yike.io/issues/5
  3. setbit/getbit 用法:https://www.zhihu.com/question/27672245

原文发布于微信公众号 - 假装我会写代码(bugszoo)

原文发表时间:2019-03-07

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券