Redis 基础学习

@这是小豪的第十篇文章

最近想解决 一刻社区 中的一个 Issues “增加用户活跃度统计”,其中的要求就是:利用 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 (哈希)

    • key:value (键值对集合),适合存储对象
  3. list (列表)

    • 简单的字符串列表,可以添加元素到列表的头部和尾部
  4. set (集合)

    • string 类型的无序集合
    • 集合是通过哈希表实现的
  5. zset (有序集合)
    • zset 和 set 一样也是 string 类型元素的集合,且不允许重复的成员
    • 不同的是每个元素都会关联一个double 类型的分数。redis 正是通过分数来为集合中的成员进行从小到大的排序
    • 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 namecopy name // 输出:0 (此时修改 key 名不成功)
    
    -- TYPE KEY_NAME (返回 key 所储存的值的类型)
    > type name // 输出:string
  • 字符串 操作

    知乎:setbit\getbit 用法

    > 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 一样。
    > append 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 的各种类型做了一下介绍以及一些操作方法,至于具体的应用以及高阶的操作,后面等我学了再放上来,哈哈。

finecho # Lhao

本帖由系统于 1周前 自动加精
讨论数量: 5

在超哥公众号看到过,话说老哥,头像撞了T.T

还好我的头像是鼠标画出来的

2个月前
-- RENAMENX OLD_KEY_NAME NEW_KEY_NAME (用于在新的 key 不存在时修改 key 的名称)
> renamenx namecop name // 输出:0 (此时修改 key 名不成功)

我这边会报错

file :grin:

> appen name " love" //  输出:8
> get name // 输出:Lhaolove

这里应该是 append 吧

2个月前

@郝合心 哈哈,报错是因为 namecopy 写成了 namecop ,好多笔误噢,还是不仔细 :joy:

2个月前

@Lhao 扎心了 老哥

2个月前

@郝合心 扎心了扎心了

2个月前

请勿发布不友善或者负能量的内容。与人为善,比聪明更重要!