Redis经常使用命令与经常使用配置速查手册

时间 2019-11-09

标签 redis 经常使用命令配置速查手册栏目 Redis 繁體版

原文原文链接

在bin下的可执行文件

redis-server ：Redis的服务端
redis-cli ：命令行客户端
redis-benchmark ：Redis性能测试工具
redis-check-aof ：AOF文件修复工具
redis-check-dump ：RDB文件检测工具
redis-sentinel : 用于作主备

启动和中止redis

启动方式有如下几种
- 不加载配置启动：redis-server
- 加载配置启动：redis-server /etc/redis.conf
- 使用docker启动：run -d --rm -v /root/test/redis.conf:/redis.conf --name redis-test -p 6379:6379 redis:5.0.0
中止方式有如下几种
- 命令行连上redis之后运行shutdown
- 直接结束redis进程：kill ...
- 中止docker启动的redis：docker stop redis-test

命令返回值类型

状态回复
- 写一个SET命令回复ok
- 写PING命令回复“pong”
错误回复
- 都以 (error) 开头
整数回复
- 都以 (integer) 开头，例如递增命令
字符串回复
- GET一个key（键）返回一个value（值）
多行字符串回复
- 每行都会以序列号开头
- 例如命令KEYS *获取目前数据库中的key名
回复空结果
- GET一个不存在的key，或者GET一个值为空的key，则返回（nil）

配置选项

能够动态设置（启动服务的时候设置，或启动后修改），或者经过配置文件设置。动态的设置会覆盖配置文件的设置
能够经过命令 CONFIG GET 配置名称 来得到当前值，通常返回结果中第一行是配置名称，第二行是值
经过CONFIG SET 配置名 value修改配置的值

经常使用简单命令

链接操做经常使用命令

#关闭链接
>quit

#简单密码认证
>auth xxxxx

#返回redis服务器的各类信息和统计数据
#info [section]
> INFO CPU
# CPU
used_cpu_sys:0.082652
used_cpu_user:0.125159
used_cpu_sys_children:0.000949
used_cpu_user_children:0.002533
复制代码

以人类可读的方式，返回全部的链接客户端信息和统计数据

> client list 
id=3 addr=127.0.0.1:57516 fd=8 name= age=101 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=26 qbuf-free=32742 obl=0 oll=0 omem=0 events=r cmd=client
复制代码

将数据同步保存到磁盘，而后关闭服务中止进程

>shutdown
复制代码

实时打印出redis服务器接收到的指令

>monitor
OK

复制代码

持久化经常使用命令

将数据同步保存到磁盘

> save
OK
复制代码

将数据异步保存到磁盘

> bgsave                             
Background saving started
复制代码

返回最近一次成功将数据保存到磁盘的Unix时戳

> lastsave
(integer) 1557285566
复制代码

配置相关经常使用命令

config get parameter #取得运行redis服务器的配置参数node
config set parameter value #设置redis服务器的配置参数redis
得到当前日志级别配置算法

> CONFIG GET loglevel
1) "loglevel"
2) "notice"  
复制代码

得到端口配置

> CONFIG GET port
1) "port"
2) "6379"
复制代码

修改日志级别（支持的日志级别 debug、verbose、notice、warning）

>CONFIG SET loglevel debug
OK
复制代码

将内存中的redis配置写入磁盘的redis.conf文件

>config rewrite
复制代码

慢日志相关命令

重置慢日志记录

> SLOWLOG RESET
OK
复制代码

查询慢日志内容

查询前10个慢日志（默认为10个）
> SLOWLOG GET 10
(empty list or set)
复制代码

返回慢日志条数

> SLOWLOG LEN
(integer) 0
复制代码

数据库操做经常使用命令

进入数据库，在redis中数据库以数字命名，第一个数据库的编号是0，例如进入数据库1

127.0.0.1:6379> SELECT 1
OK
127.0.0.1:6379[1]> 
复制代码

查询当前库全部KEY

>KEYS *
复制代码

随机返回一个key

>randomkey
复制代码

查询KEY总数直接获取redis内置的键总数变量

>dbsize
复制代码

获取数据库中的全部key

127.0.0.1:6379[1]> KEYS *
(empty list or set)
127.0.0.1:6379[1]> 
复制代码

清空当前数据库中的全部KEY

>FLUSHDB
复制代码

清空全部数据库中的全部KEY

>FLUSHALL
复制代码

迁移KEY

#Dump+restore能够实如今不一样的redis实例之间进行数据迁移的功能，整个迁移的过程分为两步;
#1)在源redis上，dump命令会将键值序列化，格式采用的是RDB格式
#2)在目标redis上，restore命令将上面序列化的值进行复原，其中ttl参数表明过时时间，ttl=0表明没有过时时间
192.168.225.129:6379> get redis
"world"
192.168.225.129:6379> dump redis
"\x00\x05world\a\x00\xe6\xe3\xe9w\xd8c\xa7\xd8"
目标redis
192.168.225.128:6379> get redis
(nil)
192.168.225.128:6379> restore redis 0 "\x00\x05world\a\x00\xe6\xe3\xe9w\xd8c\xa7\xd8"
OK
192.168.225.128:6379> get redis
"world"

#migrate,其实是吧dump、restore、del 3个命令进行组合，从而简化步骤。
#Migrate host port key [ key ......] destination-db timeout [replace]
#源redis中执行（将键flower迁移至目标192.168.225.128:6379的库0中，超时时间为1000毫秒，replace表示目标库若是存在键flower，则覆盖）
192.168.225.129:6379> migrate 192.168.225.128 6379 flower 0 1000 replace
复制代码

主备经常使用命令

将该redis实例做为slave，清空当前数据并从master实例复制数据过来。
语法slaveof <masterip> <masterport>

>slaveof 192.168.0.100 6379
复制代码

将slave提高为master，该操做将删除原有的slaveof <masterip> <masterport>配置与readonly配置

>slaveof no one
复制代码

配置文件redis.conf

基本配置

#监听端口
port 6379

#以守护进程方式启动
daemonize yes

#监听的ip
bind 127.0.0.1

#设置redis公开哪一个IP给访问者(在nat网络环境下使用)
cluster-announce-ip "192.168.0.8"

#客户端不操做等待多久自动断开，设置0为不自动断开
timeout 0

#日志级别
# Specify the server verbosity level.
# This can be one of:
# debug (a lot of information, useful for development/testing)
# verbose (many rarely useful info, but not a mess like the debug level)
# notice (moderately verbose, what you want in production probably)
# warning (only very important / critical messages are logged)
loglevel notice

#设置pid文件存放路径
pidfile "/cache1/redis/data/redis.pid"

#指定日志记录方式，能够写一个路径，也能够放空输出到stdout。可是若是以守护进程方式运行但又放空的话，日志会写给/dev/null
logfile ""

#限制可设置数据库的数量，默认只容许16个，第一个数据库的编号是0
databases 16

#容许使用的最大内存（须要配合maxmemory-policy使用），设置为0表示不限制；当redis内存数据集快到达maxmemory时，redis会实行数据淘汰策略
maxmemory 0

#Redis提供6种数据淘汰策略：
#volatile-lru:从已设置过时时间的内存数据集中挑选最近最少使用的数据 淘汰；
#volatile-ttl: 从已设置过时时间的内存数据集中挑选即将过时的数据 淘汰；
#volatile-random:从已设置过时时间的内存数据集中任意挑选数据 淘汰；
#allkeys-lru:从内存数据集中挑选最近最少使用的数据 淘汰；
#allkeys-random:从数据集中任意挑选数据 淘汰；
#no-enviction(驱逐)：禁止驱逐数据。（默认淘汰策略。当redis内存数据达到maxmemory，在该策略下，直接返回OOM错误）
maxmemory-policy volatile-lru

#为了防止某个脚本执行时间过长致使Redis没法提供服务（好比陷入死循环），Redis提供了lua-time-limit参数限制脚本的最长运行时间，默认为5秒钟。当脚本运行时间超过这一限制后，Redis将开始接受其余命令但不会执行（以确保脚本的原子性，由于此时脚本并无被终止），而是会返回“BUSY”错误。
lua-time-limit 5000

#设置最多同时可链接的客户端数量。默认为0没有限制，该配置关系到Redis进程可以打开的文件描述符数量
#若是到达了限制，Redis会关闭全部新链接并返回错误“max number of clients reached”
maxclients 10000

#读入多个配置文件，当有标准配置模板可是每一个redis实例又须要个性设置的时候颇有用
include /path/to/local.conf
include /path/to/other.conf

复制代码

慢查询相关配置

#单位为微秒，当命令执行时间超过该值则会被redis记录为慢查询
#配置为负数则禁用慢查询日志
#配置为0则记录全部命令
slowlog-log-slower-than 10000

#设置慢查询日志的长度，若是已满则会删掉最旧的保留最新的
#能够用命令 SLOWLOG RESET 来释放内存
slowlog-max-len 128
复制代码

缓冲区相关配置

Redis为了解决输出缓冲区消息大量堆积的隐患，设置了一些保护机制，主要采用两种限制措施：docker

大小限制，当某一客户端缓冲区超过设定值后直接关闭链接；
持续性限制，当某一客户端缓冲区持续一段时间占用过大空间时关闭链接。

该配置项格式以下： client-output-buffer-limit <class> <hard limit> <soft limit> <soft seconds>数据库

具体参数含义以下：安全

class ：客户端种类，normal、slave、pubsub。
mormal：普通的客户端
slave：从库的复制客户端
pub/sub: 发布与订阅的客户端的
hard limit: 缓冲区大小的硬限制。
soft limit: 缓冲区大小的软限制。
soft seconds：缓冲区大小达到了（超过）soft limit值的持续时间，单位秒。

client-output-buffer-limit normal 0 0 0
client-output-buffer-limit replica 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60
复制代码

与RDB快照有关的配置

快照方法在redis进程异常死掉时，最近的数据会丢失（丢失数据的多少视你save策略的配置）这是它最大的缺点。当业务量很大时，将丢失不少数据bash

# save <seconds> <changes>

#900秒内有一个key被修改，就保存快照（持久化落盘）到磁盘上的数据库文件里
save 900 1

#300秒内有10个更改就快照
save 300 10

#69秒内有1万个更改就快照
save 60 10000

#存储本地数据库时是否使用压缩，默认yes，使用LZF算法。压缩消耗cpu，不压缩消耗磁盘空间
rdbcompression yes

# The filename where to dump the DB。本地数据库的磁盘中的文件名
dbfilename dump.rdb

#从版本RDB版本5开始，一个CRC64的校验就被放在了文件末尾。
#这会让格式更加耐攻击，可是当存储或者加载rbd文件的时候会有一个10%左右的性能降低， 
#因此，为了达到性能的最大化，你能够关掉这个配置项。 
#没有校验的RDB文件会有一个0校验位，来告诉加载代码跳过校验检查。 
rdbchecksum yes

#指定本地存储数据库的路径，默认当前目录
dir ./

#若是配置 yes 当后台持久化失败，Redis会中止接受更新操做。若是持久化进程再次工做则会恢复容许更新操做
#若是配置 no 当后台持久化失败，Redis更新操做仍然继续处理
stop-writes-on-bgsave-error yes

复制代码

与AOF持久化相关的配置

Append-only方法能够作到所有数据不丢失，但redis的性能就要差些。原理是以日志的形式来记录每一个写操做，将redis执行过的全部写指令记录下来(读操做不记录)，只许追加文件但不能够改写文件，redis启动之初会读取该文件从新构建数据，换言之，redis重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工做。服务器
rewrite重写机制是什么： AOF采用文件追加方式，文件会愈来愈大为避免出现此种状况，新增了重写机制, 当AOF文件的大小超过所设定的阈值时，Redis就会启动AOF文件的内容压缩，只保留能够恢复数据的最小指令集.可使用命令bgrewriteaof网络
重写原理 AOF文件持续增加而过大时，会fork出一条新进程来将文件重写(也是先写临时文件最后再rename)，遍历新进程的内存中数据，每条记录有一条的Set语句。重写aof文件的操做，并无读取旧的aof文件，而是将整个内存中的数据库内容用命令的方式重写了一个新的aof文件，这点和快照有点相似app

#开启AOF
appendonly yes
#设置AOF文件名
appendfilename "appendonly.aof"

#AOF落盘方式可选参数有：
#always 老是写入aof文件，并完成磁盘同步
#everysec 每一秒写入aof文件，并完成磁盘同步
#no 写入aof文件，不等待磁盘同步
#从持久化角度讲，always是最安全的。从效率上讲，no是最快的。而redis默认设置进行了折中，选择了everysec。
appendfsync always

#在rewrite给AOF文件减肥的时候，appendfsync请求只写入缓冲区不落盘。（若是当前AOF文件很大，那么相应的rewrite时间会变长，appendfsync被阻塞的时间也会更长，这时候服务异常会丢失这段时间内的数据）
no-appendfsync-on-rewrite yes

#当AOF文件大小超过上次rewrite后的100%（一倍）而且文件大于64M时触发rewrite
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

#redis在恢复时忽略最后一条可能存在问题的指令，默认值yes。在aof写入时忽然断电可能会出现指令写错(写了一半)，这种状况下yes会log并继续，而no会直接恢复失败
aof-load-truncated yes
复制代码

安全相关配置

#当以sentinel主备redis运行时或者cluster运行时，slave实例须要访问master，因此须要在slave实例配置master实例的密码
masterauth "d9s@@ddd"

#本Redis的密码
requirepass "saseawe"

#将危险的命令重命名，或者禁用
#例如禁用FLUSHALL
rename-command FLUSHALL ""

#重命名FLUSHDB，重命名后必须用新命令来操做，不然服务器会报错 unknown command
rename-command FLUSHDB  qf69aZbLAX3cf3ednHM3SOlbpH71yEXLAX3cf3e

复制代码

主从相关配置

#配置在备库，配置主库的ip与端口。表备库从哪一个主库复制来数据。若是本来已有数据的备库开启了该设置，则会清空备库自身数据后再开始复制
slaveof 192.168.0.100 6379

# 做为从服务器，默认状况下是只读的（yes），能够修改为NO，用于写（不建议）
slave-read-only yes

#slave与master链接中断时
#yes 表明slave会继续应答来自client的请求，即便这些数据已过时（由于链接中断没法从master更新数据）
#no 除了INFO与SLAVEOF外的全部客户端请求都只响应"SYNC with master in progress"的应答，直到该slave与master的链接重建成功或该slave被提高为master
slave-serve-stale-data yes

#Redis部署为Replication模式后，slave会以预约周期（默认10s）发PING包给master，该配置能够更改这个默认周期
repl-ping-slave-period 10

#有2种状况的超时均由该配置指定：1) Bulk transfer I/O timeout; 2) master data or ping response timeout。
# 须要特别注意的是：若修改默认值，则用户输入的值必须大于repl-ping-slave-period的配置值，不然在主从链路延时较高时，会频繁timeout。
repl-timeout 30

#当配置yes时会禁用NO_DELAY，TCP协议栈会合并小包统一发送，这样能够减小主从节点间的包数量并节省带宽，但会增长数据同步到slave的时间
#当配置no时启用NO_DELAY，TCP协议栈不会延迟小包的发送时机，这样数据同步的延时会减小，会消耗更多带宽
#在带宽充足的状况下建议配置为no，以下降同步时延
repl-disable-tcp-nodelay no

#存在多个slave的状况下，当master宕机时Redis seninel将选拔priority值最小的slave提高为master
#若是该配置为 0 则永远不会被sentinel提高为master
slave-priority 4
复制代码

Redis-cluster相关配置

#开启集群模式
cluster-enabled yes
#集群的配置文件存放路径
cluster-config-file "nodes.conf"
#集群的超时时间
cluster-node-timeout 5000
复制代码

高级优化配置

# 当有大量数据时，适合用哈希编码hashtable（须要更多的内存），元素数量上限不能超过给定限制。你能够经过下面的选项来设定这些限制：
hash-max-ziplist-entries 512
hash-max-ziplist-value 64

#与哈希相相似，数据元素较少的状况下，能够用另外一种方式来编码ziplist从而节省大量空间。这种方式只有在符合下面限制的时候才能够用：
list-max-ziplist-entries 512
list-max-ziplist-value 64

# 数据全是64位无符号整型数字构成的字符串。下面这个配置项就是用来限制这种状况下使用这种编码的最大上限的。
set-max-intset-entries 512

# 与第1、第二种状况类似，有序序列也能够用一种特别的编码方式来处理，可节省大量空间。这种编码只适合长度和元素都符合下面限制的有序序列：
zset-max-ziplist-entries 128
zset-max-ziplist-value 64

# 默认是每秒钟进行10次哈希表刷新，用来刷新字典，而后尽快释放内存。
# 建议：若是你对延迟比较在乎的话就用 "activerehashing no";若是你不太在乎延迟而但愿尽快释放内存的话就设置 "activerehashing yes"。
activerehashing yes

# 对客户端输出缓冲进行限制能够强迫那些不从服务器读取数据的客户端断开链接。
# 对于normal client，第一个0表示取消hard limit，第二个0和第三个0表示取消soft limit，normal client默认取消限制，由于若是没有寻问，他们是不会接收数据的。
client-output-buffer-limit normal 0 0 0

# 对于slave client和MONITER client，若是client-output-buffer一旦超过256mb，又或者超过64mb持续60秒，那么服务器就会当即断开客户端链接。
client-output-buffer-limit slave 256mb 64mb 60

# 对于pubsub client，若是client-output-buffer一旦超过32mb，又或者超过8mb持续60秒，那么服务器就会当即断开客户端链接。
client-output-buffer-limit pubsub 32mb 8mb 60
复制代码

配置文件sentinel.conf

在一主多从的redis环境中，可使用多个sentinel（哨兵）来维护slave保证数据的安全哨兵会同时监控主数据库和从数据库，哨兵之间也会相互监控

具体配置以下

#以守护进程方式启动
daemonize yes

#监听端口默认26379
port 26379

#master数据库的ip与端口号，当master发生变化时sentinel会自动修改该配置
#末尾的2表明执行故障恢复操做前至少须要几个哨兵节点赞成，通常设置为N/2+1(N为哨兵总数)
sentinel monitor redis-master 192.168.1.51 7000 2

#指定了 Sentinel 认为服务器已经断线所需的毫秒数
sentinel down-after-milliseconds redis-master 5000

#等待该配置内的时间后master尚未恢复响应，则sentinel会排除掉故障的实例，一段时间后再探测若是已恢复则把以前故障的master做为slave处理
sentinel failover-timeout redis-master 900000

#选项指定了在执行故障转移时， 最多能够有多少个从服务器同时对新的主服务器进行同步， 这个数字越小， 完成故障转移所需的时间就越长。
sentinel parallel-syncs redis-master 2

#master的访问密码
sentinel auth-pass redis-master 123456

#log文件路径
logfile "./sentinel.log"
复制代码

Redis中的数据类型与数据操做命令

String 字符串类型

一个key最多只能存储512MB

Hash类型

又称为散列表。也是一个键值对的集合。适用于存储对象。将对象存入hash能节省内存

相关配置文件：
- hash-max-ziplist-entries 512 #hash类型存储的最大值，512个字节
- hash-max-ziplist-value 64 #hash类型存储的字段数目。默认64个

List类型

（列表类型，是一个简单的字符串列表，经过插入顺序排序，最多存储2的32次方减1个元素，经过双向链表实现，获取越接近两端的元素速度越快）（列表经过索引访问元素，若是列表不存在则会先建立）

相关命令

LPUSH 向列表左端添加元素，能够一次添加一个或多个

语法`LPUSH key value value ..."

例

#确认列表不存在
> EXISTS myList1
(integer) 0
#给列表添加3个元素
> LPUSH myList a b c 
(integer) 3
#再给列表添加3个元素，目前总共6个元素
> LPUSH myList c d e
(integer) 6
#查看从第一个元素到最后一个元素
> LRANGE myList 0 -1
1) "e"
2) "d"
3) "c"
4) "c"
5) "b"
6) "a"
复制代码

RPUSH 向列表右端添加元素

语法RPUSH key value ...

例

> RPUSH myList test1 test2 test3
(integer) 9
> LRANGE myList 0 -1
1) "e"
2) "d"
3) "c"
4) "c"
5) "b"
6) "a"
7) "test1"
8) "test2"
9) "test3"
复制代码

RPUSHX LPUSHX与上面同样，可是只有key存在的时候才添加元素

例

> RPUSHX myList test1 test2 test3
(integer) 12
> LPUSHX myList test1 test2 test3
(integer) 15
> LRANGE myList 0 -1
 1) "test3"
 2) "test2"
 3) "test1"
 4) "e"
 5) "d"
 6) "c"
 7) "c"
 8) "b"
 9) "a"
10) "test1"
11) "test2"
12) "test3"
13) "test1"
14) "test2"
15) "test3"
> LPUSHX myList2 test1 test2 test3
(integer) 0
复制代码

LPOP 将列表头部的一个元素弹出

语法 LPOP key

例

> LRANGE myList 0 -1
1) "test3"
2) "e"
3) "c"
4) "test3"
#弹出头部的test3
> LPOP myList 
"test3"
> LRANGE myList 0 -1
1) "test3"
2) "e"
3) "c"
4) "test3"
复制代码

RPOP 将列表尾巴的一个元素弹出
- 语法 RPOP key

LLEN 获得列表的长度，也就是列出元素的数量

语法LLEN key

例

> LRANGE myList 0 -1
 1) "test2"
 2) "test1"
 3) "e"
 4) "d"
 5) "c"
 6) "c"
 7) "b"
 8) "a"
 9) "test1"
10) "test2"
11) "test3"
12) "test1"
13) "test2"
14) "test3"
>LLEN myList
(integer) 14
#若是列表不存在就返回0
> LLEN myList4
(integer) 0
复制代码

LRANGE 获取列表片断,0表明列表的第一个元素，1表明列表的第二个元素，-1表明最后一个元素，复数表明从后往前数

语法LRANGE key start stop

例

> LRANGE myList 0 -1
 1) "test2"
 2) "test1"
 3) "e"
 4) "d"
 5) "c"
 6) "c"
 7) "b"
 8) "a"
 9) "test1"
10) "test2"
11) "test3"
12) "test1"
13) "test2"
14) "test3"
#获取第一个元素
> LRANGE myList 0 0
1) "test2"
127.0.0.1:6379> LRANGE myList 0 2
1) "test2"
2) "test1"
3) "e"
#获取元素只能从左到右，顺序错了就会报错
> LRANGE myList -1 -3
(empty list or set)
#获取末尾3个元素
> LRANGE myList -3 -1
1) "test1"
2) "test2"
3) "test3"
复制代码

LREM 删除列表中的指定参数，

语法 LREM key count value
count有如下几种：
- count 大于 0 从列表的头开始，向尾搜索，移除与value相等数量的元素，移除count个
- count 小于 0 从尾部向头部搜索，移除与value相等的元素，移除count个
- count 等于 0 移除列表中全部与value相等的值

例

#建立一个列表并赋值
> LPUSH myList2 a b c d a e b c d b e f b g e b
(integer) 16
> LLEN myList2
(integer) 16
#从头搜索删除2个b
> LREM myList2 2 b
(integer) 2
127.0.0.1:6379> LRANGE myList2 0 -1
 1) "e"
 2) "g"
 3) "f"
 4) "e"
 5) "b"
 6) "d"
 7) "c"
 8) "b"
 9) "e"
10) "a"
11) "d"
12) "c"
13) "b"
14) "a"
#从尾部搜索删除2个a
127.0.0.1:6379> LREM myList2 -2 a
(integer) 2
127.0.0.1:6379> LRANGE myList2 0 -1
 1) "e"
 2) "g"
 3) "f"
 4) "e"
 5) "b"
 6) "d"
 7) "c"
 8) "b"
 9) "e"
10) "d"
11) "c"
12) "b"
#删除列表里全部的e
127.0.0.1:6379> LREM myList2 0 e
(integer) 3
127.0.0.1:6379> LRANGE myList2 0 -1
1) "g"
2) "f"
3) "b"
4) "d"
5) "c"
6) "b"
7) "d"
8) "c"
9) "b"
复制代码

LINDEX 得到指定索引元素的值，根据索引找到值，命令后面要跟上一个整形数字，能够是正数也能够是负数

语法LINDEX key index start

例

> LRANGE myList2 0 -1
1) "g"
2) "f"
3) "b"
4) "d"
5) "c"
6) "b"
7) "d"
8) "c"
9) "b"
> LINDEX myList2 5
"b"
> LINDEX myList2 -3
"d"
> LINDEX myList2 0
"g"
复制代码

LSET 设置指定索引元素的值，根据索引设置值

语法LSET

例

> LRANGE myList2 0 -1
1) "g"
2) "f"
3) "b"
4) "d"
5) "c"
6) "b"
7) "d"
8) "c"
9) "b"
> LSET myList2 0 king
OK
> LRANGE myList2 0 -1
1) "king"
2) "f"
3) "b"
4) "d"
5) "c"
6) "b"
7) "d"
8) "c"
9) "b"
#超出范围
> LSET myList2 110 king
(error) ERR index out of range
#不存在的key
> LSET myList3 1 king
(error) ERR no such key
复制代码

LTRIM 只保留列表的片断，其余都删除,只保留起始点到结束点之间的元素，其余都删掉

语法LTRIM key start stop

例

> LRANGE myList3 0 -1
1) "log5"
2) "log4"
3) "log3"
4) "log2"
5) "log1"
127.0.0.1:6379> LTRIM myList3 0 1
OK
127.0.0.1:6379> LRANGE myList3 0 -1
1) "log5"
2) "log4"
复制代码

LINSERT 向列表插入元素，插入pivot以前或者以后，当pivot不存在时不作操做

语法LINSERT key BEFORE|AFTER pivot value

例

> LPUSH myList5 a b c d
(integer) 4
#将king插入b的前面
> LINSERT myList5 BEFORE 'b' 'king'
(integer) 5
> LRANGE myList5 0 -1
1) "d"
2) "c"
3) "king"
4) "b"
5) "a"
> LRANGE myList5 0 -1
1) "d"
2) "c"
3) "king"
4) "b"
5) "a"
> LINSERT myList5 AFTER 'd' 'queen'
(integer) 6
> LRANGE myList5 0 -1
1) "d"
2) "queen"
3) "c"
4) "king"
5) "b"
6) "a"
复制代码

Set集合类型
Zset有序集合类型

其余经常使用命令

KEYS 返回全部给定模式的key
- 语法KEYS pattern
- 通配符
  - * 匹配任意个字符
  - ？匹配一个任意字符
  - [] 匹配[]之间的一个字符
  - \ 转译特殊字符
EXISTS 检测指定key是否存在
语法EXISTS key
TYPE 返回key所存储的类型
语法TYPE key
返回类型
- 不存在的key返回none
- string
- hash
- set
- zset
- list
EXPIRE 设定key的过时时间，若是对已经带有国企时间的key使用命令则会重置时间。2.4版本中过时后的1秒内key还有效，2.6版本开始过时后的时间改成1毫秒内可访问
- 语法EXPIRE key seconds
- 例
```
#设置失败返回0
> EXPIRE cache_page 100
(integer) 0
> SET cache_page sl
OK
#设置成功返回1
> EXPIRE cache_page 100
(integer) 1
#使用TTL查看剩余时间
>TTL cache_page
(integer) 88
复制代码
```

EXPIREAT 设定key的过时时间，设置具体时间点（时间戳），而不是时间范围

语法EXPIREAT key timestamp

例

>SET cache_page1 'www.qq.com'
OK
>EXPIREAT cache_page1 1431868110
(integer) 1
#使用TTL查看剩余时间
>TTL cache_page1
(integer) 88
复制代码

PEXPIRE 设置key的过时时间，以毫秒为单位
- 语法PEXPIRE key milliseconds
- 使用PTTL查询剩余时间
PEXPIREAT 设置key的过时时间，设置具体时间戳，而不是范围
- 语法PEXPIREAT key timestamp
TTL 以秒为单位返回key的剩余过时时间
- 语法TTL key
- 若是key没有设置过时时间，会返回 -1
- 若是key不存在，会返回 -2
PTTL 以毫秒为单位返回key的剩余过时时间

PERSIST 将有过时时间的key转为永久不过时的key

语法PERSIST

例

> SET cache 'testCache'
OK
> TTL cache
(integer) -1
> EXPIRE cache 100
(integer) 1
> TTL cache
(integer) 96
> PERSIST cache
(integer) 1
> TTL cache
(integer) -1
复制代码

DEL 删除key

语法DEL key ...

例

#成功删除了几个key则返回数字几
>DEL cache1 cache2 cache3
(integer) 1
>DEL one two three four
(integer) 4
复制代码

RANDOMKEY 随机从当前数据库中返回一个key
- 语法 RANDOMKEY

RENAME 将一个key重命名

语法RENAME key key

例

> SET testRename1 'rename1'
OK
127.0.0.1:6379> RENAME testRename1 testRename2
OK
127.0.0.1:6379> GET testRename1
(nil)
127.0.0.1:6379> GET testRename2
"rename1"
127.0.0.1:6379> RENAME testRename2 testRename2
OK
#若是源key不存在会报错
> RENAME testRens testRename2
(error) ERR no such key
复制代码

RENAMENX 被重命名的新名称不存在的时候才有效
- 语法`RENAMENX key newkey'

DUMP 序列化给定的key，返回序列化以后的值

语法DEMP key

例

> SET testDump 'this is a test'
OK
> DUMP testDump
"\x00\x0ethis is a test\t\x00 \x88)\xc7\xcef\xce\xda"
复制代码

RESTORE 反序列化给定的key，返回反序列化后的值

语法RESTORE key ttl value

例

#反序列化的时候会设置过时时间
> RESTORE testDump3 50000 "\x00\x0ethis is a test\t\x00 \x88)\xc7\xcef\xce\xda"
OK
127.0.0.1:6379> GET testDump3
"this is a test"
127.0.0.1:6379> PTTL testDump3
(integer) 42520
复制代码

MOVE 将当前数据库中的key移动到另外的数据库，若是目标数据库已存在则会移动失败返回整形0，当移动一个不存在的数据库则会失败报错

语法MOVE key dbID

例

#打开0号数据库
127.0.0.1:6379> SELECT 0
OK
127.0.0.1:6379> SET testMove 'aaaa'
OK
127.0.0.1:6379> GET testMove
"aaaa"
#打开数据库1
127.0.0.1:6379> SELECT 1
OK
127.0.0.1:6379[1]> KEYS *
(empty list or set)
127.0.0.1:6379[1]> SELECT 0
OK
127.0.0.1:6379> MOVE testMove 1
(integer) 1
127.0.0.1:6379> GET testMove
(nil)
127.0.0.1:6379> SELECT 1
OK
127.0.0.1:6379[1]> GET testMove
"aaaa"
复制代码