Redis命令参考手册(五大基本数据类型)(1)，2024最新Golang面试题目-优快云博客

本文链接：https://blog.youkuaiyun.com/2401_84263262/article/details/137888408

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Golang全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注go）

正文

\color{#e31c07}{hstrlen}

hstrlen](#colore31c07hstrlen_566)

\color{#e31c07}{hincrby}

hincrby](#colore31c07hincrby_582)

\color{#e31c07}{hincrbyfloat}

hincrbyfloat](#colore31c07hincrbyfloat_631)

\color{#e31c07}{hmset}

hmset](#colore31c07hmset_684)

\color{#e31c07}{hmget}

hmget](#colore31c07hmget_705)

\color{#e31c07}{hkeys}

hkeys](#colore31c07hkeys_726)

\color{#e31c07}{hvals}

hvals](#colore31c07hvals_750)

\color{#e31c07}{hgetall}

hgetall](#colore31c07hgetall_776)

[列

表

\color{purple}{列表}

列表](#colorpurple_800)

- [l

\color{#e333cd}{lpush}

lpush](#colore333cdlpush_801)

\color{#e333cd}{lpushx}

lpushx](#colore333cdlpushx_824)

\color{#e333cd}{rpush}

rpush](#colore333cdrpush_845)

\color{#e333cd}{rpushx}

rpushx](#colore333cdrpushx_868)

\color{#e333cd}{lpop}

lpop](#colore333cdlpop_887)

\color{#e333cd}{rpop}

rpop](#colore333cdrpop_902)

\color{#e333cd}{rpoplpush}

rpoplpush](#colore333cdrpoplpush_918)

\color{#e333cd}{lrem}

lrem](#colore333cdlrem_964)

\color{#e333cd}{llen}

llen](#colore333cdllen_1027)

\color{#e333cd}{lindex}

lindex](#colore333cdlindex_1044)

\color{#e333cd}{linsert}

linsert](#colore333cdlinsert_1073)

\color{#e333cd}{lset}

lset](#colore333cdlset_1115)

\color{#e333cd}{lrange}

lrange](#colore333cdlrange_1153)

\color{#e333cd}{ltrim}

ltrim](#colore333cdltrim_1185)

\color{#e333cd}{blpop}

blpop](#colore333cdblpop_1259)

\color{#e333cd}{brpop}

brpop](#colore333cdbrpop_1352)

\color{#e333cd}{brpoplpush}

brpoplpush](#colore333cdbrpoplpush_1382)

[集

合

\color{blue}{集合}

集合](#colorblue_1411)

- [s

\color{#08edd8}{sadd}

sadd](#color08edd8sadd_1412)

\color{#08edd8}{sismember}

sismember](#color08edd8sismember_1439)

\color{#08edd8}{spop}

spop](#color08edd8spop_1458)

\color{#08edd8}{srangemember}

srangemember](#color08edd8srangemember_1484)

\color{#08edd8}{srem}

srem](#color08edd8srem_1569)

\color{#08edd8}{smove}

smove](#color08edd8smove_1602)

\color{#08edd8}{scard}

scard](#color08edd8scard_1629)

\color{#08edd8}{smembers}

smembers](#color08edd8smembers_1650)

\color{#08edd8}{sinter}

sinter](#color08edd8sinter_1675)

\color{#08edd8}{sinterstore}

sinterstore](#color08edd8sinterstore_1699)

\color{#08edd8}{sunion}

sunion](#color08edd8sunion_1723)

\color{#08edd8}{sunionstore}

sunionstore](#color08edd8sunionstore_1743)

\color{#08edd8}{sdiff}

sdiff](#color08edd8sdiff_1768)

\color{#08edd8}{sdiffstore}

sdiffstore](#color08edd8sdiffstore_1792)

[有

序

集

合

\color{purple}{有序集合}

有序集合](#colorpurple_1819)

- [z

\color{#0c2bcf}{zadd}

zadd](#color0c2bcfzadd_1820)

\color{#0c2bcf}{zscore}

zscore](#color0c2bcfzscore_1874)

\color{#0c2bcf}{zincrby}

zincrby](#color0c2bcfzincrby_1894)

\color{#0c2bcf}{zcard}

zcard](#color0c2bcfzcard_1914)

\color{#0c2bcf}{zcount}

zcount](#color0c2bcfzcount_1940)

\color{#0c2bcf}{zrange}

zrange](#color0c2bcfzrange_1964)

\color{#0c2bcf}{zrevrange}

zrevrange](#color0c2bcfzrevrange_2007)

\color{#0c2bcf}{zrangebyscore}

zrangebyscore](#color0c2bcfzrangebyscore_2034)

\color{#0c2bcf}{zrevrangebyscore}

zrevrangebyscore](#color0c2bcfzrevrangebyscore_2085)

\color{#0c2bcf}{zrank}

zrank](#color0c2bcfzrank_2118)

\color{#0c2bcf}{zrevrank}

zrevrank](#color0c2bcfzrevrank_2141)

\color{#0c2bcf}{zrem}

zrem](#color0c2bcfzrem_2166)

\color{#0c2bcf}{zremrangebyrank}

zremrangebyrank](#color0c2bcfzremrangebyrank_2207)

\color{#0c2bcf}{zremrangebyscore}

zremrangebyscore](#color0c2bcfzremrangebyscore_2234)

\color{#0c2bcf}{zrangebylex}

zrangebylex](#color0c2bcfzrangebylex_2260)

\color{#0c2bcf}{zlexcount}

zlexcount](#color0c2bcfzlexcount_2300)

\color{#0c2bcf}{zremramgebylex}

zremramgebylex](#color0c2bcfzremramgebylex_2322)

参

考

资

料

\color{blue}{参考资料}

参考资料
http://redisdoc.com/index.html

字

符

串

\color{#1411d9}{字符串}

字符串

\color{#06f218}{set}

set

set key value [EX seconds] [PX milliseconds] [NX|XX]
将字符串value关联到key。如果key已经持有其他值，set就覆写旧值，无视类型。
当set命令对一个带有生存时间TTL的键进行设置之后，该键原有的TTL被清除。

可选参数
从 Redis 2.6.12 版本开始， SET 命令的行为可以通过一系列参数来修改：

EX seconds：将键的过期时间涉设置为seconds秒，执行set key value EX seconds的效果等同于setex key seconds value
PX milliseconds：将键的过期时间设置为milliseconds毫秒，执行set key value PX milliseconds的效果等同于执行psetex key milliseconds value
NX：只在键不存在时，才对键进行设置操作。执行 SET key value NX的效果等同于执行 SETNX key value
XX：只在键已经存在时，才对键进行设置操作。

因为 SET 命令可以通过参数来实现 SETNX 、 SETEX 以及 PSETEX 命令的效果，所以 Redis 将来的版本可能会移除并废弃 SETNX 、 SETEX 和 PSETEX 这三个命令

返回值
在 Redis 2.6.12 版本以前，SET命令总是返回 OK。

从 Redis 2.6.12 版本开始，SET命令只在设置操作成功完成时才返回OK ；如果命令使用了NX 或者XX 选项，但是因为条件没达到而造成设置操作未执行，那么命令将返回空批量回复（NULL Bulk Reply）

代码示例

对不存在的键进行设置

set key ‘value’ # ok
get key # ‘value’

对已存在的键进行设置

set key ‘new-value’ # ok
get key # ‘new-value’

使用 ex 选项

SET key-with-expire-time “hello” EX 10086 # ok
get key-with-expire-time # ‘hello’
TTL key-with-expire-time # (integer) 10057

使用 px 选项

SET key-with-pexpire-time “moto” PX 123321 # ok
GET key-with-pexpire-time # “moto”
PTTL key-with-pexpire-time # (integer) 111939

使用 NX 选项

SET not-exists-key “value” NX # ok 键不存在，设置成功
GET not-exists-key # ‘value’
SET not-exists-key “new-value” NX # nil 键已经存在，设置失败
GET not-exists-key # ‘value’ 维持原值不变

使用 XX 选项

EXISTS exists-key # (integer) 0
SET exists-key “value” XX # nil 因为键不存在，设置失败
SET exists-key “value” # ok 先给键设置一个值
SET exists-key “new-value” XX # nil 设置新值成功
GET exists-key # ‘new-value’

\color{#06f218}{setnx}

setnx

setnx key value
只在键key 不存在的情况下，将键 key 的值设置为 value 。
若键 key 已经存在，则 SETNX 命令不做任何动作。
SETNX 是 『SET if Not eXists』 (如果不存在，则 SET)的简写。

返回值
命令在设置成功时返回 1 ，设置失败时返回 0 。

代码示例

EXISTS job # (integer)0 job 不存在
SETNX job ‘programmer’ # (integer)1 job设置成功
SETNX job ‘coder’ # (integer)0 尝试覆盖job 失败
GET job # ‘programmer’ 没有被覆盖

\color{#06f218}{setex}

setex

setex key seconds value
将键key 的值设置为 value，并将键 key 的生存时间设置为 seconds秒钟。
如果键key已经存在，那么 SETEX命令将覆盖已有的值。
SETEX命令的效果和以下两个命令的效果类似：

SET key value
EXPIRE key seconds # 设置生存时间

SETEX 和这两个命令的不同之处在于 SETEX 是一个原子（atomic）操作，它可以在同一时间内完成设置值和设置过期时间这两个操作，因此 SETEX 命令在储存缓存的时候非常实用

返回值
命令在设置成功时返回 OK。当 seconds 参数不合法时，命令将返回一个错误。

代码示例

在键 key 不存在的情况下执行 SETEX

SETEX cache_user_id 60 10086 # ok
GET cache_user_id # 10086
TTL cache_user_id # (integer)49 剩余生存时间

键 key 已经存在，使用 SETEX 覆盖旧值

set cd ‘timeless’ # ok
setex cd 3000 ‘goodby’ # ok
get cd # ‘goodby’
ttl cd # (integer)2997

\color{#06f218}{psetex}

psetex

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

返回值
命令在设置成功时返回 OK 。

代码示例

PSETEX mykey 1000 “Hello”
PTTL mykey # (integer)999
GET mykey # ‘Hello’

\color{#06f218}{get}

get

GET key
返回与键 key 相关联的字符串值。

返回值
如果键key 不存在，那么返回特殊值 nil；否则，返回键 key的值。
如果键key的值并非字符串类型，那么返回一个错误，因为GET 命令只能用于字符串值

代码示例

对不存在的键 key 或是字符串类型的键 key 执行 GET 命令：

GET db # nil
SET db redis # ok
GET db # “redis”

对不是字符串类型的键 key 执行 GET 命令：

DEL db # (integer)1
LPUSH db redis mongodb mysql # (integer)3
GET db # (error) ERR Operation against a key holding the wrong kind of value

\color{#06f218}{getset}

getset

GETSET key value
将键key 的值设为 value ，并返回键 key 在被设置之前的旧值。

返回值
返回给定键 key的旧值。
如果键 key没有旧值，也即是说，键 key 在被设置之前并不存在，那么命令返回 nil 。
当键 key 存在但不是字符串类型时，命令返回一个错误。

代码示例

GETSET db mongodb # nil 没有旧值返回nil
GET db # ‘mongodb’
GETSET DB redis # ‘mongodb’ 返回旧值mongodb
GET db # ‘redis’

\color{#06f218}{strlen}

strlen

strlen key
返回键key存储的字符串值得长度

返回值
STRLEN 命令返回字符串值的长度。
当键 key 不存在时，命令返回 0 。
当 key 储存的不是字符串值时，返回一个错误。

代码示例

获取字符串值的长度

set mykey “hello world” # ok
strlen mykey # (integer)11

不存在的键长度为0

strlen nonexisting # (integer) 0

\color{#06f218}{append}

append

append key value
如果键key已经存在并且它的值是一个字符串，append命令将把value追加到键key现有值的末尾。
如果键key不存在，append就简单的将key的值设为value，就像执行set key value

返回值
追加value之后，键key的值的长度

示例代码

对不存在的 key 执行 APPEND

exists myname # (integer)0 myname不存在
append myname ‘刘三’ # 不存在的 key 进行 APPEND ，等同于 SET myphone “nokia”

(integer) 2 返回字符串的长度

对已存在的字符串进行 APPEND

APPEND myname “思” # 长度从 2个字符增加到3个字符
GET myphone # ‘刘三思’

\color{#06f218}{setrange}

setrange

setrange key offset value
从偏移量offset开始，用 value 参数覆写(overwrite)键 key 储存的字符串值。
不存在的键key 当作空白字符串处理。

SETRANGE 命令会确保字符串足够长以便将 value 设置到指定的偏移量上，如果键key 原来储存的字符串长度比偏移量小(比如字符串只有 5 个字符长，但你设置的offset 是 10 )，那么原字符和偏移量之间的空白将用零字节(zerobytes, "\x00")进行填充。

因为 Redis 字符串的大小被限制在 512 兆(megabytes)以内，所以用户能够使用的最大偏移量为 2^29-1(536870911) ，如果你需要使用比这更大的空间，请使用多个key。

当生成一个很长的字符串时， Redis 需要分配内存空间，该操作有时候可能会造成服务器阻塞(block)。在2010年出产的Macbook Pro上，设置偏移量为 536870911(512MB 内存分配)将耗费约 300 毫秒，设置偏移量为 134217728(128MB 内存分配)将耗费约 80 毫秒，设置偏移量 33554432(32MB 内存分配)将耗费约 30 毫秒，设置偏移量为 8388608(8MB 内存分配)将耗费约 8 毫秒。

返回值
setrange命令会返回被修改之后，字符串值的长度。

代码示例

对非空字符串执行setrange 命令

set greeting ‘hi xixi’ # ok
setrange greeting 3 ‘redis’ # 8
get greeting # ‘hello redis’

对空字符串/不存在的键执行 setrange 命令

exists emptystr # (inerger) 0
setrange emptystr 5 ‘redis’ # (integer)10 对不存在的 key 使用 SETRANGE
get emptystr # “\x00\x00\x00\x00\x00redis” 空白处被\x00填充

\color{#06f218}{getrange}

getrange

返回键 key 储存的字符串值的指定部分(这是一个闭区间)，字符串的截取范围由start 和 end 两个偏移量决定 (包括start 和 end在内)。
负数偏移量表示从字符串的末尾开始计数，-1表示最后一个字符，-2表示倒数第二个字符，以此类推。
GETRANGE通过保证子字符串的值域(range)不超过实际字符串的值域来处理超出范围的值域请求。

GETRANGE 命令在 Redis 2.0 之前的版本里面被称为 SUBSTR 命令。

返回值
GETRANGE 命令会返回字符串值的指定部分(闭区间)

代码示例

set k1 ‘hello myboy’
getrange k1 0 4 # ‘hello’ 返回索引0-4的字符包括4
getrange k1 -1 -5 # 为空不支持回绕操作
getrange k1 -3 -1 # ‘boy’ 负数索引
getrange k1 0 -1 # 返回键k1对应的值
getrange k1 0 11111 # 值域超过实际字符的长度超过部分自定被忽略返回对应的值

\color{#06f218}{incr}

incr

incr key
为键 key储存的数字值加上一。
如果键 key不存在，那么它的值会先被初始化为0 ，然后再执行INCR 命令。
如果键 key储存的值不能被解释为数字，那么 INCR 命令将返回一个错误。
本操作的值限制在 64 位(bit)有符号数字表示之内。

INCR 命令是一个针对字符串的操作。因为 Redis 并没有专用的整数类型，所以键 key 储存的值在执行 INCR 命令时会被解释为十进制 64 位有符号整数。

返回值
INCR命令会返回键key 在执行加一操作之后的值。

代码示例

set page 20
incr page # (integet) 21
get page # ‘21’ 数字值在 Redis 中以字符串的形式保存

\color{#06f218}{incrby}

incrby

incrby key increment
为键 key 储存的数字值加上增量increment 。
如果键 key不存在，那么键key 的值会先被初始化为 0 ，然后再执行INCRBY命令。
如果键 key 储存的值不能被解释为数字，那么 INCRBY 命令将返回一个错误。
本操作的值限制在 64 位(bit)有符号数字表示之内。

关

于

递

增

(

)

递

减

(

)

操

作

的

更

多

信

息

，

请

参

见

命

令

的

文

档

\color{#f34}{关于递增(increment) / 递减(decrement)操作的更多信息，请参见 INCR 命令的文档}

关于递增(increment)/递减(decrement)操作的更多信息，请参见INCR命令的文档

返回值
在加上增量 increment 之后，键key 当前的值。

代码示例

键存在并且值为数字

set rank 50
incrby increment 20
get rank

键不存在

exists counter
incrby counter 30
get counter # ‘30’

键存在，但值无法被解释为数字：

set book ‘xxxxx’
incrby book 10 # (error) ERR value is not an integer or out of range

\color{#06f218}{incrbyfloat}

incrbyfloat

incrbyfloat key increment
为键key 储存的值加上浮点数增量increment。
如果键key不存在，那么 INCRBYFLOAT 会先将键key 的值设为 0 ，然后再执行加法操作。
如果命令执行成功，那么键 key 的值会被更新为执行加法计算之后的新值，并且新值会以字符串的形式返回给调用者。

无论是键 key 的值还是增量 increment ，都可以使用像 2.0e7 、 3e5 、 90e-2 那样的指数符号(exponential notation)来表示，但是，执行 INCRBYFLOAT 命令之后的值总是以同样的形式储存，也即是，它们总是由一个数字，一个（可选的）小数点和一个任意长度的小数部分组成（比如 3.14 、 69.768 ，诸如此类)，小数部分尾随的 0 会被移除，如果可能的话，命令还会将浮点数转换为整数（比如 3.0 会被保存成 3 ）。
此外，无论加法计算所得的浮点数的实际精度有多长， INCRBYFLOAT 命令的计算结果最多只保留小数点的后十七位。
当以下任意一个条件发生时，命令返回一个错误：

键 key 的值不是字符串类型(因为 Redis 中的数字和浮点数都以字符串的形式保存，所以它们都属于字符串类型）；
键 key 当前的值或者给定的增量 increment 不能被解释(parse)为双精度浮点数。

返回值
在加上增量 increment之后，键key的值。

代码示例

set num 3.0
incrbyfloat num 2.1
get num # 5.1

\color{#06f218}{decr}

decr

decr key
为键key储存的数字值减去一。
如果键key不存在，那么键 key 的值会先被初始化为0 ，然后再执行DECR操作。
如果键 key 储存的值不能被解释为数字，那么 DECR 命令将返回一个错误。
本操作的值限制在 64 位(bit)有符号数字表示之内。

关

于

递

增

(

)

递

减

(

)

操

作

的

更

多

信

息

，

请

参

见

命

令

的

文

档

。

\color{#f34}{关于递增(increment) / 递减(decrement)操作的更多信息，请参见 INCR 命令的文档。}

关于递增(increment)/递减(decrement)操作的更多信息，请参见INCR命令的文档。

返回值
DECR命令会返回键 key 在执行减一操作之后的值。

代码示例

对储存数字值的键 key 执行 DECR 命令

SET failure_times 10 # ok
DECR failure_times # 9

对不存在的键执行 DECR 命令

EXISTS count
DECR count # -1

\color{#06f218}{decrby}

decrby

decrby key decrement
将键 key 储存的整数值减去减量 decrement。
如果键key不存在，那么键 key 的值会先被初始化为 0，然后再执行DECRBY 命令。
如果键 key储存的值不能被解释为数字，那么 DECRBY命令将返回一个错误。
本操作的值限制在 64 位(bit)有符号数字表示之内。

返回值
decrby命令会返回键在执行减法操作之后的值

代码示例

对已经存在的键执行 DECRBY 命令

set count 100
decrby count 20 # 80

对不存在的键执行 DECRBY 命令

exists pages
decrby pages 10 # (integer) -10

\color{#06f218}{mset}

mset

mset key value [key value]
同时为多个键设置值。
如果某个给定键已经存在，那么 MSET将使用新值去覆盖旧值，如果这不是你所希望的效果，请考虑使用 MSETNX 命令，这个命令只会在所有给定键都不存在的情况下进行设置。

MSET是一个原子性(atomic)操作，所有给定键都会在同一时间内被设置，不会出现某些键被设置了但是另一些键没有被设置的情况。

返回值
MSET 命令总是返回OK 。

代码示例

同时对多个键进行设置

MSET date “2012.3.30” time “11:00 a.m.” weather “sunny” # ok
MGET data time weather

1) “2012.3.30”

2) “11:00 a.m.”

3) “sunny”

覆盖已有的值

MGET k1 k2

1) “hello”

2) “world”

MSET k1 “good” k2 “bye”

MGET k1 k2

1) “good”

2) “bye”

\color{#06f218}{msetnx}

msetnx

msetnx key value [key value]
当且仅当所有给定键都不存在时，为所有给定键设置值。
即使只有一个给定键已经存在， MSETNX 命令也会拒绝执行对所有键的设置操作。
MSETNX是一个原子性(atomic)操作，所有给定键要么就全部都被设置，要么就全部都不设置，不可能出现第三种状态。

返回值
当所有给定键都设置成功时，命令返回 1 ；如果因为某个给定键已经存在而导致设置未能成功执行，那么命令返回 0 。

代码示例

对不存在的键执行 MSETNX 命令

MSETNX rmdbs “MySQL” nosql “MongoDB” key-value-store “redis”
MGET rmdbs nosql key-value-store

1) “MySQL”

2) “MongoDB”

3) “redis”

对某个已经存在的键进行设置

MSETNX rmdbs “Sqlite” language “python” # rmdbs 键已经存在，操作失败
EXISTS language # 因为 MSETNX 命令没有成功执行所以 language 键没有被设置
GET rmdbs # rmdbs 键也没有被修改

MySQL

\color{#06f218}{mget}

mget

mget key [key,key...]
返回给定的一个或多个字符串键的值。
如果给定的字符串键里面，有某个键不存在，那么这个键的值将以特殊值nil表示。

返回值
MGET 命令将返回一个列表，列表中包含了所有给定键的值。

示例代码

SET redis redis.com
SET mongodb mongodb.org
MGET redis mongodb
MGET redis mongodb mysql # 不存在的 mysql 返回 nil

1) “redis.com”

2) “mongodb.org”

3) (nil)

哈

希

表

\color{#1411d9}{哈希表}

哈希表

\color{#e31c07}{hset}

hset

hset hash field value
将哈希表hash中域field 的值设置为value 。
如果给定的哈希表并不存在，那么一个新的哈希表将被创建并执行 HSET 操作。
如果域field 已经存在于哈希表中，那么它的旧值将被新值value覆盖。

返回值
当 HSET 命令在哈希表中新创建field域并成功为它设置值时，命令返回1；如果域 field已经存在于哈希表，并且 HSET 命令成功使用新值覆盖了它的旧值，那么命令返回0。

代码示例

设置一个新域

hset website google ‘www.google.com’ # (integer)1
hget website google # ‘www.google.com’

对一个已存在的域进行更新

HSET website google “www.google.net”
HGET website google # “www.google.net”

\color{#e31c07}{hsetnx}

hsetnx

当且仅当域 field尚未存在于哈希表的情况下，将它的值设置为value 。
如果给定域已经存在于哈希表当中，那么命令将放弃执行设置操作。
如果哈希表hash不存在，那么一个新的哈希表将被创建并执行HSETNX命令

返回值
HSETNX 命令在设置成功时返回 1 ，在给定域已经存在而放弃执行设置操作时返回0 。

代码示例

域尚未存在，设置成功

HSETNX database key-value-store Redis # (integer) 1
HGET database key-value-store # “Redis”

域已经存在，设置未成功，域原有的值未被改变

HSETNX database key-value-store Riak # (integer) 0
HGET database key-value-store # “Redis”

\color{#e31c07}{hget}

hget

hget hash field
返回哈希表中给定域的值

返回值
HGET 命令在默认情况下返回给定域的值。
如果给定域不存在于哈希表中，又或者给定的哈希表并不存在，那么命令返回 nil 。

代码示例

域存在的情况

hset homepage redis reids.com # (integer) 1
hget homepage redis # “redis.com”

域不存在的情况

hget site mysql #(nil)

\color{#e31c07}{hexists}

hexists

检查给定域field 是否存在于哈希表 hash当中。

返回值
HEXISTS命令在给定域存在时返回1 ，在给定域不存在时返回0。

代码示例

给定域不存在

hexists phone myphone # (integer)0

给定域存在

hset phone myphone 110 # (integet) 1
hexists phone myphone # (integer) 1

\color{#e31c07}{hdel}

hdel

hdel key value [field...]

删除哈希表 key中的一个或多个指定域，不存在的域将被忽略

在Redis2.4以下的版本里， HDEL 每次只能删除单个域，如果你需要在一个原子时间内删除多个域，请将命令包含在 MULTI / EXEC 块内。

HGETALL abbr

1) “a”

2) “apple”

3) “b”

4) “banana”

5) “c”

6) “cat”

7) “d”

8) “dog”

删除单个域

HDEL abbr a # (integer) 1

删除不存在的域

HDEL abbr not-exists-field #(integer) 0

删除多个域

HDEL abbr b c #(integer) 2

HGETALL abbr

1) “d”

2) “dog”

\color{#e31c07}{hlen}

hlen

hlen key
返回哈希表 key中域的数量。

返回值
哈希表中域的数量。
当key不存在时，返回 0。

hset db redis redis.com
hset db mysql mysql.com
hlen db
hset db mongodb mongodb.org
hlen db

\color{#e31c07}{hstrlen}

hstrlen

返回哈希表key 中，与给定域field相关联的值的字符串长度（string length）。

如果给定的键或者域不存在，那么命令返回 0 。

redis> HMSET myhash f1 “HelloWorld” f2 “99” f3 “-256”
OK
redis> HSTRLEN myhash f1
(integer) 10
redis> HSTRLEN myhash f2
(integer) 2
redis> HSTRLEN myhash f3
(integer) 4

\color{#e31c07}{hincrby}

hincrby

incrby key field increment
为哈希表key 中的域field 的值加上增量increment 。
增量也可以为负数，相当于对给定域进行减法操作。
如果 key不存在，一个新的哈希表被创建并执行 HINCRBY命令。
如果域 field不存在，那么在执行命令前，域的值被初始化为0。
对一个储存字符串值的域 field 执行 HINCRBY 命令将造成一个错误。
本操作的值被限制在 64 位(bit)有符号数字表示之内。

increment 为正数

redis> HEXISTS counter page_view # 对空域进行设置
(integer) 0

redis> HINCRBY counter page_view 200
(integer) 200

redis> HGET counter page_view
“200”

increment 为负数

redis> HGET counter page_view
“200”

redis> HINCRBY counter page_view -50
(integer) 150

redis> HGET counter page_view
“150”

尝试对字符串值的域执行HINCRBY命令

redis> HSET myhash string hello,world # 设定一个字符串值
(integer) 1

redis> HGET myhash string
“hello,world”

redis> HINCRBY myhash string 1 # 命令执行失败，错误。
(error) ERR hash value is not an integer

redis> HGET myhash string # 原值不变
“hello,world”

\color{#e31c07}{hincrbyfloat}

hincrbyfloat

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

如果哈希表中没有域field ，那么 HINCRBYFLOAT 会先将域 field的值设为 0 ，然后再执行加法操作。
如果键key 不存在，那么 HINCRBYFLOAT会先创建一个哈希表，再创建域 field ，最后再执行加法操作。
当以下任意一个条件发生时，返回一个错误：
域field的值不是字符串类型(因为 redis 中的数字和浮点数都以字符串的形式保存，所以它们都属于字符串类型）
域field 当前的值或给定的增量 increment不能解释(parse)为双精度浮点数(double precision floating point number)
HINCRBYFLOAT命令的详细功能和INCRBYFLOAT key increment 命令类似，请查看 INCRBYFLOAT key increment命令获取更多相关信息。

值和增量都是普通小数

redis> HSET mykey field 10.50
(integer) 1
redis> HINCRBYFLOAT mykey field 0.1
“10.6”

值和增量都是指数符号

redis> HSET mykey field 5.0e3
(integer) 0
redis> HINCRBYFLOAT mykey field 2.0e2
“5200”

对不存在的键执行 HINCRBYFLOAT

redis> EXISTS price
(integer) 0
redis> HINCRBYFLOAT price milk 3.5
“3.5”
redis> HGETALL price

“milk”
“3.5”

对不存在的域进行 HINCRBYFLOAT

redis> HGETALL price

“milk”
“3.5”
redis> HINCRBYFLOAT price coffee 4.5 # 新增 coffee 域
“4.5”
redis> HGETALL price
“milk”
“3.5”
“coffee”
“4.5”

\color{#e31c07}{hmset}

hmset

hmset key field value [field value...]
同时将多个field-value (域-值)对设置到哈希表 key 中。
此命令会覆盖哈希表中已存在的域。
如果 key不存在，一个空哈希表被创建并执行 HMSET 操作。

返回值
如果命令执行成功，返回OK。
当 key 不是哈希表(hash)类型时，返回一个错误。

示例代码

redis> HMSET website google www.google.com yahoo www.yahoo.com
OK

redis> HGET website google
“www.google.com”

redis> HGET website yahoo
“www.yahoo.com”

\color{#e31c07}{hmget}

hmget

HMGET key field [field …]
返回哈希表 key中，一个或多个给定域的值。
如果给定的域不存在于哈希表，那么返回一个 nil 值。
因为不存在的key被当作一个空哈希表来处理，所以对一个不存在的key 进行HMGET 操作将返回一个只带有 nil值的表。

返回值
一个包含多个给定域的关联值的表，表值的排列顺序和给定域参数的请求顺序一样。

示例代码

redis> HMSET pet dog “doudou” cat “nounou” # 一次设置多个域
OK

redis> HMGET pet dog cat fake_pet # 返回值的顺序和传入参数的顺序一样

“doudou”
“nounou”
(nil) # 不存在的域返回nil值

\color{#e31c07}{hkeys}

hkeys

HKEYS key
返回哈希表 key 中的所有域。
返回值
一个包含哈希表中所有域的表。
当 key 不存在时，返回一个空表。
示例代码

哈希表非空

redis> HMSET website google www.google.com yahoo www.yahoo.com
OK
redis> HKEYS website

“google”
“yahoo”

空哈希表/key不存在

redis> EXISTS fake_key
(integer) 0

redis> HKEYS fake_key
(empty list or set)

\color{#e31c07}{hvals}

hvals

HVALS key
返回哈希表 key 中所有域的值。

返回值：
一个包含哈希表中所有值的表。
当 key 不存在时，返回一个空表。

示例代码

非空哈希表

redis> HMSET website google www.google.com yahoo www.yahoo.com
OK

redis> HVALS website

“www.google.com”
“www.yahoo.com”

空哈希表/不存在的key

redis> EXISTS not_exists
(integer) 0

redis> HVALS not_exists
(empty list or set)

\color{#e31c07}{hgetall}

hgetall

hgetall key
返回哈希表 key 中，所有的域和值。
在返回值里，紧跟每个域名(field name)之后是域的值(value)，所以返回值的长度是哈希表大小的两倍。

返回值
以列表形式返回哈希表的域和域的值。
若 key 不存在，返回空列表。

示例代码

redis> HSET people jack “Jack Sparrow”
(integer) 1

redis> HSET people gump “Forrest Gump”
(integer) 1

redis> HGETALL people

“jack” # 域
“Jack Sparrow” # 值
“gump”
“Forrest Gump”

列

表

\color{purple}{列表}

列表

\color{#e333cd}{lpush}

lpush

lpush key value [value]
将一个或多个值 value插入到列表 key 的表头
如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表头：比如说，对空列表 mylist 执行命令 LPUSH mylist a b c ，列表的值将是 c b a，这等同于原子性地执行 LPUSH mylist a 、 LPUSH mylist b 和 LPUSH mylist c 三个命令。
如果 key不存在，一个空列表会被创建并执行 LPUSH 操作。
当 key 存在但不是列表类型时，返回一个错误。

返回值
执行lpush命令后，列表的长度

代码示例

加入单个元素

lpush languages python

加入重复元素

lpush languages python

加入多个元素

lpush mylist a b c

\color{#e333cd}{lpushx}

lpushx

lpushx key value
将值value插入到列表key 的表头，当且仅当key存在并且是一个列表。
和 LPUSH key value [value …] 命令相反，当key不存在时，LPUSHX 命令什么也不做。

返回值
lpushx 命令执行后，返回表的长度

示例代码

对空列表执行

llen greet # 0 greet是一个空列表
lpushx greet hello # 尝试lpushx 失败因为列表为空

对非空列表执行lpushx

lpush greet ‘hello’
lpushx greet ‘hi’
lrange greet 0 -1

\color{#e333cd}{rpush}

rpush

将一个或多个值value插入到列表key的表尾(最右边)。

如果有多个 value 值，那么各个value 值按从左到右的顺序依次插入到表尾：比如对一个空列表mylist 执行 RPUSH mylist a b c，得出的结果列表为 a b c ，等同于执行命令 RPUSH mylist a 、 RPUSH mylist b 、 RPUSH mylist c。
如果key 不存在，一个空列表会被创建并执行 RPUSH 操作
当 key存在但不是列表类型时，返回一个错误。

返回值
执行rpush操作后，表的长度

示例代码

添加单个元素

rpush languages C

添加重复元素

rpush languages C

添加多个元素

rpush mylist a b c

\color{#e333cd}{rpushx}

rpushx

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

返回值
rpushx执行后，返回的长度

代码示例

对空列表执行

llen greet # 0 greet是一个空列表
rpushx greet hello # 尝试lpushx 失败因为列表为空

对非空列表执行lpushx

rpush greet ‘hello’
rpushx greet ‘hi’
lrange greet 0 -1

\color{#e333cd}{lpop}

lpop

lpop key
移除并返回列表key的头元素

返回值
列表的头元素，当key不存在时，返回nil

示例代码

rpush course algorithm
rpush course c++
lpop course # 移除头元素 ‘algorithm’

\color{#e333cd}{rpop}

rpop

rpop key
移除并返回列表key的尾元素

返回值
列表的尾元素，当key不存在时，返回nil

示例代码

rpush mylist 1
rpush mylist 2
rpush mylist 3
rpop mylist # 3 返回并弹出尾部的元素

\color{#e333cd}{rpoplpush}

rpoplpush

rpoplpush source destination
命令 RPOPLPUSH 在一个原子时间内，执行以下两个动作：

将列表 source中的最后一个元素(尾元素)弹出，并返回给客户端。
将source弹出的元素插入到列表destination ，作为 destination列表的的头元素。

举个例子，你有两个列表 source 和 destination ， source 列表有元素 a, b, c ， destination 列表有元素 x, y, z ，执行 RPOPLPUSH source destination 之后， source 列表包含元素 a, b ， destination 列表包含元素 c, x, y, z ，并且元素 c 会被返回给客户端。

如果source不存在，值nil 被返回，并且不执行其他动作。
如果 source 和 destination 相同，则列表中的表尾元素被移动到表头，并返回该元素，可以把这种特殊情况视作列表的旋转(rotation)操作。

返回值
被弹出的元素

代码示例

source destination不同

lpush source 1 2 3
rpoplpush source des
lrange des 0 -1 # 1

source destination 相同

rpoplpush source source # 2
lrange source 0 -1 # 2 3

模式：安全的队列
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 命令那样一下子将所有列表元素都从服务器传送到客户端中(两种方式的总复杂度都是 O(N))。

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

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

这个模式使得我们可以很容易实现这样一类系统：有 N 个客户端，需要连续不断地对一些元素进行处理，而且处理的过程必须尽可能地快。一个典型的例子就是服务器的监控程序：它们需要在尽可能短的时间内，并行地检查一组网站，确保它们的可访问性。

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

\color{#e333cd}{lrem}

lrem

lrem key count value
根据参数count的值，移除列表中与参数value相同的元素
count的值可以是以下几种：

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

返回值
被移除元素的数量。因为不存在的 key 被视作空表(empty list)，所以当 key 不存在时， LREM 命令总是返回 0 。

代码示例

先创建一个表，内容排列是

morning hello morning helllo morning

redis> LPUSH greet “morning”
(integer) 1
redis> LPUSH greet “hello”
(integer) 2
redis> LPUSH greet “morning”
(integer) 3
redis> LPUSH greet “hello”
(integer) 4
redis> LPUSH greet “morning”
(integer) 5

redis> LRANGE greet 0 4 # 查看所有元素

“morning”
“hello”
“morning”
“hello”
“morning”

redis> LREM greet 2 morning # 移除从表头到表尾，最先发现的两个 morning
(integer) 2 # 两个元素被移除

redis> LLEN greet # 还剩 3 个元素
(integer) 3

redis> LRANGE greet 0 2

“hello”
“hello”
“morning”

redis> LREM greet -1 morning # 移除从表尾到表头，第一个 morning
(integer) 1

redis> LLEN greet # 剩下两个元素
(integer) 2

redis> LRANGE greet 0 1

“hello”
“hello”

redis> LREM greet 0 hello # 移除表中所有 hello
(integer) 2 # 两个 hello 被移除

redis> LLEN greet
(integer) 0

\color{#e333cd}{llen}

llen

llen key
返回列表key的长度。
如果key不存在，则 key被解释为一个空列表，返回 0 .
如果key不是列表类型，返回一个错误。

返回值
列表 key 的长度

示例代码

llen job # 0
lpush job ‘run’ ‘eat’
llen job # 2

\color{#e333cd}{lindex}

lindex

lindx key index
返回列表 key 中，下标为 index的元素。
下标(index)参数start和 stop都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1表示列表的第二个元素，以此类推。
你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
如果 key 不是列表类型，返回一个错误。

返回值
列表中下标为 index的元素。如果 index 参数的值不在列表的区间范围内(out of range)，返回 nil 。

示例代码

redis> LPUSH mylist “World”
(integer) 1

redis> LPUSH mylist “Hello”
(integer) 2

redis> LINDEX mylist 0
“Hello”

redis> LINDEX mylist -1
“World”

redis> LINDEX mylist 3 # index不在 mylist 的区间范围内
(nil)

\color{#e333cd}{linsert}

linsert

linsert key before |after pivot value
pivot：表示在列表中寻找的目的元素
将值 value 插入到列表key当中，位于值pivot之前或之后。
当 pivot不存在于列表 key时，不执行任何操作。
当key不存在时，key 被视为空列表，不执行任何操作。
如果key 不是列表类型，返回一个错误。

返回值
如果命令执行成功，返回插入操作完成之后，列表的长度。如果没有找到pivot ，返回-1 。如果 key 不存在或为空列表，返回 0 。

代码示例

redis> RPUSH mylist “Hello”
(integer) 1

redis> RPUSH mylist “World”
(integer) 2

redis> LINSERT mylist BEFORE “World” “There”
(integer) 3

redis> LRANGE mylist 0 -1

“Hello”
“There”
“World”

对一个非空列表插入，查找一个不存在的 pivot

redis> LINSERT mylist BEFORE “go” “let’s”
(integer) -1 # 失败

对一个空列表执行 LINSERT 命令

redis> EXISTS fake_list
(integer) 0

redis> LINSERT fake_list BEFORE “nono” “gogogog”
(integer) 0 # 失败

\color{#e333cd}{lset}

lset

lset key index value
将列表 key下标为index的元素的值设置为 value 。
当index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误。
关于列表下标的更多信息，请参考 LINDEX key index 命令。
返回值
操作成功返回 ok ，否则返回错误信息。
示例代码

对空列表(key 不存在)进行 LSET

redis> EXISTS list
(integer) 0

redis> LSET list 0 item
(error) ERR no such key

对非空列表进行 LSET

redis> LPUSH job “cook food”
(integer) 1

redis> LRANGE job 0 0

“cook food”

redis> LSET job 0 “play game”
OK

redis> LRANGE job 0 0

“play game”

index 超出范围

redis> LLEN list # 列表长度为 1
(integer) 1

redis> LSET list 3 ‘out of range’
(error) ERR index out of range

\color{#e333cd}{lrange}

lrange

lrange key start stop
返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。
下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

注意LRANGE命令和编程语言区间函数的区别
假如你有一个包含一百个元素的列表，对该列表执行 LRANGE list 0 10 ，结果是一个包含11个元素的列表，这表明 stop 下标也在 LRANGE 命令的取值范围之内(闭区间)，这和某些语言的区间函数可能不一致，比如Ruby的 Range.new 、 Array#slice 和Python的 range() 函数。
超出范围的下标
超出范围的下标值不会引起错误。
如果 start 下标比列表的最大下标 end ( LLEN list 减去 1 )还要大，那么 LRANGE 返回一个空列表。
如果 stop 下标比 end 下标还要大，Redis将 stop 的值设置为 end 。

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

示例代码

redis> RPUSH fp-language lisp
(integer) 1

redis> LRANGE fp-language 0 0

“lisp”

redis> RPUSH fp-language scheme
(integer) 2

redis> LRANGE fp-language 0 1

“lisp”
“scheme”

\color{#e333cd}{ltrim}

ltrim

ltrim key start stop
对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。
举个例子，执行命令LTRIM list 0 2 ，表示只保留列表 list 的前三个元素，其余元素全部删除。
下标(index)参数start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
当 key 不是列表类型时，返回一个错误。

注意LTRIM命令和编程语言区间函数的区别
假如你有一个包含一百个元素的列表 list，对该列表执行LTRIM list 0 10 ，结果是一个包含11个元素的列表，这表明 stop 下标也在 LTRIM 命令的取值范围之内(闭区间)，这和某些语言的区间函数可能不一致，比如Ruby的 Range.new 、 Array#slice 和Python的 range() 函数。
超出范围的下标
超出范围的下标值不会引起错误。
如果start 下标比列表的最大下标 end (LLEN list 减去 1)还要大，或者 start > stop ， LTRIM 返回一个空列表(因为 LTRIM 已经将整个列表清空)。
如果 stop下标比 end 下标还要大，Redis将 stop 的值设置为 end 。

返回值
命令执行成功时，返回ok 。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Go）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
reet -1 morning # 移除从表尾到表头，第一个 morning
(integer) 1

redis> LLEN greet # 剩下两个元素
(integer) 2

redis> LRANGE greet 0 1

“hello”
“hello”

redis> LREM greet 0 hello # 移除表中所有 hello
(integer) 2 # 两个 hello 被移除

redis> LLEN greet
(integer) 0

\color{#e333cd}{llen}

llen

llen key
返回列表key的长度。
如果key不存在，则 key被解释为一个空列表，返回 0 .
如果key不是列表类型，返回一个错误。

返回值
列表 key 的长度

示例代码

llen job # 0
lpush job ‘run’ ‘eat’
llen job # 2

\color{#e333cd}{lindex}

lindex

返回值
列表中下标为 index的元素。如果 index 参数的值不在列表的区间范围内(out of range)，返回 nil 。

示例代码

redis> LPUSH mylist “World”
(integer) 1

redis> LPUSH mylist “Hello”
(integer) 2

redis> LINDEX mylist 0
“Hello”

redis> LINDEX mylist -1
“World”

redis> LINDEX mylist 3 # index不在 mylist 的区间范围内
(nil)

\color{#e333cd}{linsert}

linsert

返回值
如果命令执行成功，返回插入操作完成之后，列表的长度。如果没有找到pivot ，返回-1 。如果 key 不存在或为空列表，返回 0 。

代码示例

redis> RPUSH mylist “Hello”
(integer) 1

redis> RPUSH mylist “World”
(integer) 2

redis> LINSERT mylist BEFORE “World” “There”
(integer) 3

redis> LRANGE mylist 0 -1

“Hello”
“There”
“World”

对一个非空列表插入，查找一个不存在的 pivot

redis> LINSERT mylist BEFORE “go” “let’s”
(integer) -1 # 失败

对一个空列表执行 LINSERT 命令

redis> EXISTS fake_list
(integer) 0

redis> LINSERT fake_list BEFORE “nono” “gogogog”
(integer) 0 # 失败

\color{#e333cd}{lset}

lset

对空列表(key 不存在)进行 LSET

redis> EXISTS list
(integer) 0

redis> LSET list 0 item
(error) ERR no such key

对非空列表进行 LSET

redis> LPUSH job “cook food”
(integer) 1

redis> LRANGE job 0 0

“cook food”

redis> LSET job 0 “play game”
OK

redis> LRANGE job 0 0

“play game”

index 超出范围

redis> LLEN list # 列表长度为 1
(integer) 1

redis> LSET list 3 ‘out of range’
(error) ERR index out of range

\color{#e333cd}{lrange}

lrange

注意LRANGE命令和编程语言区间函数的区别
假如你有一个包含一百个元素的列表，对该列表执行 LRANGE list 0 10 ，结果是一个包含11个元素的列表，这表明 stop 下标也在 LRANGE 命令的取值范围之内(闭区间)，这和某些语言的区间函数可能不一致，比如Ruby的 Range.new 、 Array#slice 和Python的 range() 函数。
超出范围的下标
超出范围的下标值不会引起错误。
如果 start 下标比列表的最大下标 end ( LLEN list 减去 1 )还要大，那么 LRANGE 返回一个空列表。
如果 stop 下标比 end 下标还要大，Redis将 stop 的值设置为 end 。

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

示例代码

redis> RPUSH fp-language lisp
(integer) 1

redis> LRANGE fp-language 0 0

“lisp”

redis> RPUSH fp-language scheme
(integer) 2

redis> LRANGE fp-language 0 1

“lisp”
“scheme”

\color{#e333cd}{ltrim}

ltrim

注意LTRIM命令和编程语言区间函数的区别
假如你有一个包含一百个元素的列表 list，对该列表执行LTRIM list 0 10 ，结果是一个包含11个元素的列表，这表明 stop 下标也在 LTRIM 命令的取值范围之内(闭区间)，这和某些语言的区间函数可能不一致，比如Ruby的 Range.new 、 Array#slice 和Python的 range() 函数。
超出范围的下标
超出范围的下标值不会引起错误。
如果start 下标比列表的最大下标 end (LLEN list 减去 1)还要大，或者 start > stop ， LTRIM 返回一个空列表(因为 LTRIM 已经将整个列表清空)。
如果 stop下标比 end 下标还要大，Redis将 stop 的值设置为 end 。

返回值
命令执行成功时，返回ok 。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Go）
[外链图片转存中…(img-mOekgkko-1713357982306)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

Redis命令参考手册(五大基本数据类型)(1)，2024最新Golang面试题目

正文

对不存在的键进行设置

对已存在的键进行设置

使用 ex 选项

使用 px 选项

使用 NX 选项

使用 XX 选项

在键 key 不存在的情况下执行 SETEX

键 key 已经存在， 使用 SETEX 覆盖旧值

对不存在的键 key 或是字符串类型的键 key 执行 GET 命令：

对不是字符串类型的键 key 执行 GET 命令：

获取字符串值的长度

不存在的键长度为0

对不存在的 key 执行 APPEND

(integer) 2 返回字符串的长度

对已存在的字符串进行 APPEND

对非空字符串执行setrange 命令

对空字符串/不存在的键执行 setrange 命令

键存在 并且值为数字

键不存在

键存在，但值无法被解释为数字：

对储存数字值的键 key 执行 DECR 命令

对不存在的键执行 DECR 命令

对已经存在的键执行 DECRBY 命令

对不存在的键执行 DECRBY 命令

同时对多个键进行设置

1) “2012.3.30”

2) “11:00 a.m.”

3) “sunny”

覆盖已有的值

1) “hello”

2) “world”

1) “good”

2) “bye”

对不存在的键执行 MSETNX 命令

1) “MySQL”

2) “MongoDB”

3) “redis”

对某个已经存在的键进行设置

MySQL

1) “redis.com”

2) “mongodb.org”

3) (nil)

设置一个新域

对一个已存在的域进行更新

域尚未存在， 设置成功

域已经存在， 设置未成功， 域原有的值未被改变

域存在的情况

域不存在的情况

给定域不存在

给定域存在

1) “a”

2) “apple”

3) “b”

4) “banana”

5) “c”

6) “cat”

7) “d”

8) “dog”

删除单个域

删除不存在的域

删除多个域

1) “d”

2) “dog”

increment 为正数

increment 为负数

尝试对字符串值的域执行HINCRBY命令

值和增量都是普通小数

值和增量都是指数符号

对不存在的键执行 HINCRBYFLOAT

对不存在的域进行 HINCRBYFLOAT

哈希表非空

空哈希表/key不存在

非空哈希表

空哈希表/不存在的key

加入单个元素

加入重复元素

加入多个元素

对空列表执行

键 key 已经存在，使用 SETEX 覆盖旧值

键存在并且值为数字

域尚未存在，设置成功

域已经存在，设置未成功，域原有的值未被改变