Redis 命令详解
Redis 是一个开源的、基于内存的数据结构存储系统，可以用作数据库、缓存和消息中间件。本文档详细介绍 Redis 的常用命令及其作用。
文档说明
本文档按照以下结构组织每个 Redis 命令：
- 命令作用：详细说明命令的功能和用途
- 命令语法：完整的语法格式和参数说明
- 命令特性：描述命令的特殊性质和行为特点
- 使用示例：提供实际的使用示例
- 注意事项：重要的使用注意点和最佳实践
目录
连接和认证命令
AUTH
命令作用： AUTH 命令用于客户端身份验证，确保只有知道正确密码的客户端才能访问 Redis 服务器。这是 Redis 安全机制的重要组成部分，防止未授权访问。
命令语法：
AUTH password
参数说明：
password：Redis 服务器配置的认证密码
命令特性：
- 必须在连接建立后、执行其他命令前进行认证
- 认证成功后，当前连接会话将保持认证状态
- 如果密码错误，服务器会返回错误并拒绝后续命令
- 支持在运行时动态修改密码，新连接需要使用新密码
使用示例：
# 使用密码认证
AUTH mypassword
# 认证成功后的响应
OK
# 密码错误时的响应
(error) ERR invalid password
注意事项：
- 确保密码足够复杂，避免使用弱密码
- 在生产环境中必须启用认证机制
- 密码修改后需要重启客户端连接
PING
命令作用： PING 命令用于测试客户端与 Redis 服务器之间的连接是否正常。这是一个轻量级的健康检查命令，常用于监控和诊断网络连接状态。
命令语法：
PING [message]
参数说明：
message（可选）：自定义消息内容，如果提供则返回该消息
命令特性：
- 不消耗任何内存，执行速度极快
- 可以带参数或不带参数使用
- 返回结果简单明确，便于程序判断连接状态
- 常用于负载均衡器的健康检查
使用示例：
# 基本用法，返回 PONG
PING
# 返回: PONG
# 带消息参数，返回原消息
PING hello
# 返回: hello
# 在脚本中检查连接
if redis.ping() == "PONG":
print("连接正常")
注意事项：
- 定期使用 PING 命令检查连接状态
- 在网络不稳定的环境中，PING 可以帮助检测连接中断
- 某些 Redis 客户端库会自动发送 PING 命令保持连接活跃
SELECT
命令作用： SELECT 命令用于切换当前客户端连接的数据库索引。Redis 默认提供 16 个数据库（索引 0-15），每个数据库都是独立的命名空间，可以存储不同的数据集。
命令语法：
SELECT index
参数说明：
index：数据库索引号，范围 0-15（默认配置）
命令特性：
- 切换数据库后，所有后续命令都在新选择的数据库中执行
- 每个数据库都有独立的键空间，互不干扰
- 默认连接时使用数据库 0
- 数据库索引超出范围会返回错误
- 切换数据库不会影响已建立的连接
使用示例：
# 切换到数据库 0（默认）
SELECT 0
# 切换到数据库 1
SELECT 1
# 在数据库 1 中设置键值
SET name "张三"
# 切换回数据库 0
SELECT 0
# 数据库 0 中没有 name 键
GET name
# 返回: (nil)
注意事项：
- 在生产环境中建议使用不同的数据库分离不同的应用数据
- 某些 Redis 集群模式不支持 SELECT 命令
- 数据库切换是客户端级别的，不影响其他连接
QUIT
命令作用： QUIT 命令用于优雅地关闭当前客户端与 Redis 服务器的连接。这是一个标准的连接终止命令，确保连接被正确关闭并释放相关资源。
命令语法：
QUIT
参数说明：
- 无参数
命令特性：
- 立即关闭当前连接
- 服务器会发送 OK 响应确认关闭
- 连接关闭后无法继续发送命令
- 会触发服务器端的连接清理工作
- 比直接断开网络连接更优雅
使用示例：
# 关闭当前连接
QUIT
# 返回: OK
# 连接随后关闭
注意事项：
- 在应用程序中应该使用 QUIT 而不是直接关闭 socket
- 某些客户端库会自动处理连接关闭
- 连接池中的连接通常由池管理器负责关闭
字符串命令
SET
命令作用： SET 命令是 Redis 中最基础的数据存储命令，用于设置键值对。它支持多种选项来控制键的行为，如过期时间、条件设置等，是构建缓存、会话存储等应用的核心命令。
命令语法：
SET key value [EX seconds] [PX milliseconds] [NX|XX] [KEEPTTL]
参数说明：
key：要设置的键名value：要设置的值EX seconds：设置过期时间（秒）PX milliseconds：设置过期时间（毫秒）NX：仅当键不存在时设置（Not eXists）XX：仅当键存在时设置（eXists）KEEPTTL：保留原键的过期时间
命令特性：
- 原子性操作，要么全部成功要么全部失败
- 如果键已存在，会覆盖原值
- 支持字符串、数字、JSON 等任意数据
- 可以同时设置过期时间
- 支持条件设置，避免覆盖现有数据
使用示例：
# 基本设置
SET name "张三"
# 设置带过期时间（1小时）
SET session:user123 "active" EX 3600
# 设置带毫秒过期时间
SET temp:data "value" PX 5000
# 仅当键不存在时设置（实现分布式锁）
SET lock:resource "locked" NX EX 30
# 仅当键存在时更新
SET user:1001:name "新名字" XX
# 保留原键的过期时间
SET user:1001:name "新名字" KEEPTTL
注意事项：
- 大值会消耗更多内存，注意内存使用
- 过期时间精度为秒级，毫秒级更精确
- NX/XX 选项常用于实现分布式锁和条件更新
- 字符串最大长度为 512MB
GET
命令作用： GET 命令用于获取指定键对应的字符串值。这是读取 Redis 数据最常用的命令，配合 SET 命令实现基本的键值存储功能。
命令语法：
GET key
参数说明：
key：要获取的键名
命令特性：
- 时间复杂度 O(1)，执行速度极快
- 只能获取字符串类型的值
- 键不存在时返回 nil
- 不会修改键的过期时间
- 支持获取任意长度的字符串
使用示例：
# 获取基本值
GET name
# 返回: "张三"
# 获取不存在的键
GET nonexistent
# 返回: (nil)
# 获取数字字符串
GET counter
# 返回: "10"
# 在应用中使用
user_data = redis.get("user:1001:profile")
if user_data:
profile = json.loads(user_data)
注意事项：
- 只能获取字符串类型，其他类型需要使用对应命令
- 大值会影响网络传输性能
- 建议对 JSON 等结构化数据进行序列化存储
MSET
命令作用： MSET 命令用于原子性地设置多个键值对。相比多次调用 SET 命令，MSET 可以减少网络往返次数，提高性能，并且保证所有键值对要么全部设置成功，要么全部失败。
命令语法：
MSET key value [key value ...]
参数说明：
key：键名value：对应的值- 可以设置任意数量的键值对
命令特性：
- 原子性操作，所有键值对同时设置
- 如果任何键已存在，会被覆盖
- 不支持过期时间设置
- 减少网络往返，提高性能
- 参数数量必须为偶数
使用示例：
# 设置多个键值对
MSET name "张三" age "25" city "北京" email "zhangsan@example.com"
# 设置用户配置
MSET user:1001:theme "dark" user:1001:language "zh-CN" user:1001:timezone "Asia/Shanghai"
# 批量初始化数据
MSET counter:page:views 0 counter:user:signups 0 counter:orders 0
注意事项：
- 参数数量必须是偶数（键值对）
- 不支持过期时间，需要单独设置
- 大值会影响命令执行时间
- 建议在批量操作时使用
MGET
命令作用： MGET 命令用于一次性获取多个键的值。相比多次调用 GET 命令，MGET 可以减少网络往返次数，提高批量读取性能，是优化 Redis 查询性能的重要命令。
命令语法：
MGET key [key ...]
参数说明：
key：要获取的键名，可以指定多个
命令特性：
- 原子性操作，一次性获取所有键
- 不存在的键返回 nil
- 保持键的原始顺序
- 减少网络往返，提高性能
- 支持获取任意数量的键
使用示例：
# 获取多个键的值
MGET name age city email
# 返回: ["张三", "25", "北京", "zhangsan@example.com"]
# 获取用户配置
MGET user:1001:theme user:1001:language user:1001:timezone
# 批量获取计数器
MGET counter:page:views counter:user:signups counter:orders
# 返回: ["1000", "50", "25"]
# 处理结果
values = redis.mget("key1", "key2", "key3")
for i, value in enumerate(values):
if value:
print(f"key{i+1}: {value}")
注意事项：
- 不存在的键在结果中显示为 nil
- 结果数组与输入键的顺序一致
- 建议在需要批量读取时使用
- 大值会影响传输性能
INCR
命令作用： INCR 命令用于将键的值原子性地增加 1。这是 Redis 中实现计数器的核心命令，常用于页面访问统计、用户点赞数、库存计数等场景。
命令语法：
INCR key
参数说明：
key：要递增的键名
命令特性：
- 原子性操作，避免并发问题
- 如果键不存在，会先设置为 0 再递增
- 只能对整数进行操作
- 返回递增后的值
- 时间复杂度 O(1)
使用示例：
# 基本递增
INCR page:views
# 返回: 1
# 再次递增
INCR page:views
# 返回: 2
# 对不存在的键递增
INCR new:counter
# 返回: 1
# 在应用中使用
def increment_page_views(page_id):
return redis.incr(f"page:views:{page_id}")
# 实现分布式计数器
def get_next_id():
return redis.incr("global:id:counter")
注意事项：
- 只能对整数进行操作，非整数会报错
- 值超出 64 位整数范围会报错
- 常用于实现分布式计数器
- 配合 EXPIRE 可以实现带过期时间的计数器
DECR
命令作用： DECR 命令用于将键的值原子性地减少 1。与 INCR 相反，DECR 用于递减操作，常用于库存扣减、倒计时等场景。
命令语法：
DECR key
参数说明：
key：要递减的键名
命令特性：
- 原子性操作，避免并发问题
- 如果键不存在，会先设置为 0 再递减
- 只能对整数进行操作
- 返回递减后的值
- 支持负数结果
使用示例：
# 基本递减
SET stock:item1 10
DECR stock:item1
# 返回: 9
# 继续递减
DECR stock:item1
# 返回: 8
# 对不存在的键递减
DECR new:counter
# 返回: -1
# 实现库存扣减
def decrement_stock(item_id):
current = redis.decr(f"stock:{item_id}")
if current < 0:
# 库存不足，回滚
redis.incr(f"stock:{item_id}")
return False
return True
注意事项：
- 只能对整数进行操作
- 支持负数结果
- 常用于库存管理和倒计时
- 需要处理负数情况
INCRBY
命令作用： INCRBY 命令用于将键的值原子性地增加指定的数值。相比 INCR 只能增加 1，INCRBY 可以增加任意整数，提供更灵活的计数功能。
命令语法：
INCRBY key increment
参数说明：
key：要递增的键名increment：要增加的数值（整数）
命令特性：
- 原子性操作，避免并发问题
- 支持正数和负数增量
- 如果键不存在，会先设置为 0 再递增
- 返回递增后的值
- 支持大数值操作
使用示例：
# 增加指定数值
SET score:player1 100
INCRBY score:player1 50
# 返回: 150
# 使用负数减少
INCRBY score:player1 -20
# 返回: 130
# 对不存在的键操作
INCRBY new:counter 100
# 返回: 100
# 实现积分系统
def add_points(user_id, points):
return redis.incrby(f"points:{user_id}", points)
# 批量增加
def batch_increment(counters, increment):
pipe = redis.pipeline()
for counter in counters:
pipe.incrby(counter, increment)
return pipe.execute()
注意事项：
- 增量值必须是整数
- 支持负数实现递减效果
- 值超出范围会报错
- 常用于积分、分数等系统
DECRBY
命令作用： DECRBY 命令用于将键的值原子性地减少指定的数值。与 INCRBY 相反，DECRBY 用于递减操作，提供灵活的递减计数功能。
命令语法：
DECRBY key decrement
参数说明：
key：要递减的键名decrement：要减少的数值（整数）
命令特性：
- 原子性操作，避免并发问题
- 支持正数和负数减量
- 如果键不存在，会先设置为 0 再递减
- 返回递减后的值
- 支持大数值操作
使用示例：
# 减少指定数值
SET balance:user1 1000
DECRBY balance:user1 100
# 返回: 900
# 使用负数增加
DECRBY balance:user1 -50
# 返回: 950
# 对不存在的键操作
DECRBY new:counter 50
# 返回: -50
# 实现余额扣减
def deduct_balance(user_id, amount):
current = redis.decrby(f"balance:{user_id}", amount)
if current < 0:
# 余额不足，回滚
redis.incrby(f"balance:{user_id}", amount)
return False
return True
注意事项：
- 减量值必须是整数
- 支持负数实现递增效果
- 需要处理负数结果
- 常用于余额、库存管理
APPEND
命令作用： APPEND 命令用于在指定键的值后面追加字符串内容。如果键不存在，会先创建键并设置值为空字符串，然后追加内容。常用于日志记录、消息拼接等场景。
命令语法：
APPEND key value
参数说明：
key：要追加的键名value：要追加的字符串内容
命令特性：
- 原子性操作，避免并发问题
- 如果键不存在，会先创建空字符串
- 返回追加后的字符串长度
- 只能对字符串类型操作
- 时间复杂度 O(1)
使用示例：
# 基本追加
SET greeting "Hello"
APPEND greeting " World"
# 返回: 11 (字符串长度)
GET greeting
# 返回: "Hello World"
# 对不存在的键追加
APPEND new:log "First log entry"
# 返回: 16
GET new:log
# 返回: "First log entry"
# 继续追加
APPEND new:log " - Second entry"
# 返回: 30
# 实现日志记录
def log_event(event_type, message):
timestamp = datetime.now().isoformat()
log_entry = f"[{timestamp}] {event_type}: {message}\n"
return redis.append("system:log", log_entry)
注意事项：
- 只能对字符串类型操作
- 大值会影响内存使用
- 常用于日志和消息拼接
- 考虑使用列表类型存储大量追加数据
STRLEN
命令作用： STRLEN 命令用于获取指定键对应的字符串值的长度（字节数）。这是一个轻量级的查询命令，常用于数据验证、长度限制检查等场景。
命令语法：
STRLEN key
参数说明：
key：要查询长度的键名
命令特性：
- 时间复杂度 O(1)，执行速度极快
- 只能查询字符串类型的长度
- 键不存在时返回 0
- 返回字节数，不是字符数
- 不修改键的值
使用示例：
# 查询字符串长度
SET name "张三"
STRLEN name
# 返回: 6 (UTF-8 编码下中文字符占3字节)
# 查询英文长度
SET message "Hello World"
STRLEN message
# 返回: 11
# 查询不存在的键
STRLEN nonexistent
# 返回: 0
# 在应用中使用
def validate_input(key, max_length):
current_length = redis.strlen(key)
if current_length > max_length:
return False
return True
# 检查数据完整性
def check_data_size(data_key):
size = redis.strlen(data_key)
if size == 0:
return "数据为空"
elif size > 1024 * 1024: # 1MB
return "数据过大"
else:
return f"数据大小: {size} 字节"
注意事项：
- 返回的是字节数，不是字符数
- 中文字符在 UTF-8 编码下占 3 字节
- 只能查询字符串类型
- 常用于数据验证和监控
哈希命令
HSET
命令作用： HSET 命令用于设置哈希（Hash）数据结构中的字段值。哈希是 Redis 中用于存储对象属性的理想数据结构，特别适合存储用户信息、配置项等具有多个属性的数据。HSET 支持同时设置多个字段，提供高效的批量操作能力。
命令语法：
HSET key field value [field value ...]
参数说明：
key：哈希的键名field：字段名value：字段值- 可以同时设置多个字段值对
命令特性：
- 原子性操作，所有字段同时设置
- 如果字段已存在，会覆盖原值
- 如果哈希不存在，会自动创建
- 返回新设置的字段数量
- 支持任意数量的字段值对
使用示例：
# 设置单个字段
HSET user:1001 name "张三"
# 返回: 1
# 设置多个字段
HSET user:1001 name "张三" age 25 email "zhangsan@example.com"
# 返回: 3
# 更新已存在的字段
HSET user:1001 age 26
# 返回: 0 (没有新字段)
# 在应用中使用
def create_user_profile(user_id, profile_data):
fields = []
for key, value in profile_data.items():
fields.extend([key, str(value)])
return redis.hset(f"user:{user_id}", *fields)
注意事项：
- 字段值会被转换为字符串存储
- 大量字段会影响内存使用
- 建议使用有意义的字段名
- 配合过期时间使用可以自动清理数据
HGET
命令作用： HGET 命令用于获取哈希中指定字段的值。这是读取哈希数据最常用的命令，配合 HSET 实现哈希的基本读写操作。
命令语法：
HGET key field
参数说明：
key：哈希的键名field：要获取的字段名
命令特性：
- 时间复杂度 O(1)，执行速度极快
- 字段不存在时返回 nil
- 只能获取单个字段
- 不修改哈希数据
- 支持任意长度的字段名和值
使用示例：
# 获取单个字段
HGET user:1001 name
# 返回: "张三"
# 获取不存在的字段
HGET user:1001 phone
# 返回: (nil)
# 在应用中使用
def get_user_name(user_id):
return redis.hget(f"user:{user_id}", "name")
# 检查字段是否存在
def has_user_field(user_id, field):
value = redis.hget(f"user:{user_id}", field)
return value is not None
注意事项：
- 只能获取单个字段，批量获取使用 HMGET
- 字段不存在返回 nil
- 建议先检查字段是否存在
- 配合其他命令实现复杂查询
HMSET
命令作用： HMSET 命令用于同时设置多个哈希字段值。虽然功能与 HSET 相同，但 HMSET 是较老的命令，Redis 4.0.0 后建议使用 HSET 替代。HMSET 仍然被支持，但新代码应该使用 HSET。
命令语法：
HMSET key field value [field value ...]
参数说明：
key：哈希的键名field：字段名value：字段值- 可以设置多个字段值对
命令特性：
- 与 HSET 功能完全相同
- 已标记为废弃，建议使用 HSET
- 原子性操作
- 返回 OK 表示成功
- 向后兼容性良好
使用示例：
# 设置多个字段（旧方式）
HMSET user:1001 name "张三" age 25 email "zhangsan@example.com"
# 返回: OK
# 建议使用 HSET（新方式）
HSET user:1001 name "张三" age 25 email "zhangsan@example.com"
# 返回: 3
注意事项：
- 建议使用 HSET 替代 HMSET
- 功能完全相同，只是返回值不同
- 新项目应该使用 HSET
- 现有代码可以逐步迁移
HMGET
命令作用： HMGET 命令用于一次性获取哈希中多个字段的值。相比多次调用 HGET 命令，HMGET 可以减少网络往返次数，提高批量读取性能，是优化哈希查询的重要命令。
命令语法：
HMGET key field [field ...]
参数说明：
key：哈希的键名field：要获取的字段名，可以指定多个
命令特性：
- 原子性操作，一次性获取所有字段
- 不存在的字段返回 nil
- 保持字段的原始顺序
- 减少网络往返，提高性能
- 支持获取任意数量的字段
使用示例：
# 获取多个字段
HMGET user:1001 name age email
# 返回: ["张三", "25", "zhangsan@example.com"]
# 包含不存在的字段
HMGET user:1001 name phone email
# 返回: ["张三", (nil), "zhangsan@example.com"]
# 在应用中使用
def get_user_profile(user_id, fields):
values = redis.hmget(f"user:{user_id}", *fields)
return dict(zip(fields, values))
# 获取用户基本信息
profile = get_user_profile(1001, ["name", "age", "email"])
# 返回: {"name": "张三", "age": "25", "email": "zhangsan@example.com"}
注意事项：
- 不存在的字段在结果中显示为 nil
- 结果数组与输入字段的顺序一致
- 建议在需要批量读取时使用
- 配合字典处理结果更方便
HGETALL
命令作用： HGETALL 命令用于获取哈希中所有字段和值的列表。这个命令会返回一个包含所有字段值对的数组，常用于需要完整哈希数据的场景，如数据导出、缓存预热等。
命令语法：
HGETALL key
参数说明：
key：哈希的键名
命令特性：
- 返回所有字段值对的数组
- 数组格式为 [field1, value1, field2, value2, ...]
- 哈希不存在时返回空数组
- 时间复杂度 O(N)，N 为字段数量
- 会消耗较多内存和网络带宽
使用示例：
# 获取所有字段和值
HGETALL user:1001
# 返回: ["name", "张三", "age", "25", "email", "zhangsan@example.com"]
# 哈希不存在时
HGETALL nonexistent
# 返回: []
# 在应用中使用
def get_user_dict(user_id):
data = redis.hgetall(f"user:{user_id}")
# 将数组转换为字典
result = {}
for i in range(0, len(data), 2):
result[data[i]] = data[i+1]
return result
# 使用 HGETALL 获取完整用户信息
user_data = get_user_dict(1001)
# 返回: {"name": "张三", "age": "25", "email": "zhangsan@example.com"}
注意事项：
- 大哈希会消耗大量内存和网络带宽
- 建议在字段数量较少时使用
- 考虑使用 HSCAN 遍历大哈希
- 结果需要转换为字典格式使用
HDEL
命令作用： HDEL 命令用于删除哈希中指定的字段。这是一个原子性操作，可以同时删除多个字段，常用于清理不需要的数据或实现字段级别的数据管理。
命令语法：
HDEL key field [field ...]
参数说明：
key：哈希的键名field：要删除的字段名，可以指定多个
命令特性：
- 原子性操作，所有字段同时删除
- 返回实际删除的字段数量
- 不存在的字段会被忽略
- 如果所有字段都被删除，哈希键也会被删除
- 支持删除任意数量的字段
使用示例：
# 删除单个字段
HDEL user:1001 email
# 返回: 1
# 删除多个字段
HDEL user:1001 phone address
# 返回: 2
# 删除不存在的字段
HDEL user:1001 nonexistent
# 返回: 0
# 在应用中使用
def remove_user_fields(user_id, fields):
return redis.hdel(f"user:{user_id}", *fields)
# 清理敏感信息
removed_count = remove_user_fields(1001, ["password", "ssn", "credit_card"])
print(f"删除了 {removed_count} 个字段")
注意事项：
- 删除不存在的字段不会报错
- 返回实际删除的字段数量
- 删除所有字段后哈希键也会被删除
- 建议批量删除提高性能
HEXISTS
命令作用： HEXISTS 命令用于检查哈希中指定字段是否存在。这是一个轻量级的查询命令，常用于条件判断、数据验证等场景，避免获取不存在的字段值。
命令语法：
HEXISTS key field
参数说明：
key：哈希的键名field：要检查的字段名
命令特性：
- 时间复杂度 O(1)，执行速度极快
- 返回 1 表示字段存在，0 表示不存在
- 不修改哈希数据
- 哈希不存在时返回 0
- 只检查单个字段
使用示例：
# 检查字段是否存在
HEXISTS user:1001 name
# 返回: 1
# 检查不存在的字段
HEXISTS user:1001 phone
# 返回: 0
# 检查不存在的哈希
HEXISTS nonexistent field
# 返回: 0
# 在应用中使用
def has_user_field(user_id, field):
return redis.hexists(f"user:{user_id}", field) == 1
# 条件性获取字段
if has_user_field(1001, "email"):
email = redis.hget("user:1001", "email")
print(f"用户邮箱: {email}")
else:
print("用户未设置邮箱")
注意事项：
- 只检查单个字段，批量检查需要多次调用
- 建议在获取字段值前先检查存在性
- 配合其他命令实现复杂逻辑
- 常用于数据验证和条件判断
HKEYS
命令作用： HKEYS 命令用于获取哈希中所有字段名的列表。这个命令只返回字段名，不返回字段值，常用于获取哈希的结构信息、字段遍历等场景。
命令语法：
HKEYS key
参数说明：
key：哈希的键名
命令特性：
- 返回所有字段名的数组
- 哈希不存在时返回空数组
- 时间复杂度 O(N)，N 为字段数量
- 不返回字段值，节省网络带宽
- 字段名按插入顺序返回
使用示例：
# 获取所有字段名
HKEYS user:1001
# 返回: ["name", "age", "email"]
# 哈希不存在时
HKEYS nonexistent
# 返回: []
# 在应用中使用
def get_user_field_names(user_id):
return redis.hkeys(f"user:{user_id}")
# 遍历用户字段
field_names = get_user_field_names(1001)
for field in field_names:
value = redis.hget(f"user:1001", field)
print(f"{field}: {value}")
# 检查字段是否存在
def has_required_fields(user_id, required_fields):
existing_fields = set(redis.hkeys(f"user:{user_id}"))
return all(field in existing_fields for field in required_fields)
注意事项：
- 大哈希会返回大量字段名
- 只返回字段名，不返回字段值
- 考虑使用 HSCAN 遍历大哈希
- 常用于字段遍历和结构分析
HVALS
命令作用： HVALS 命令用于获取哈希中所有字段值的列表。这个命令只返回字段值，不返回字段名，常用于获取哈希的所有值、数据统计等场景。
命令语法：
HVALS key
参数说明：
key：哈希的键名
命令特性：
- 返回所有字段值的数组
- 哈希不存在时返回空数组
- 时间复杂度 O(N)，N 为字段数量
- 不返回字段名，节省网络带宽
- 字段值按插入顺序返回
使用示例：
# 获取所有字段值
HVALS user:1001
# 返回: ["张三", "25", "zhangsan@example.com"]
# 哈希不存在时
HVALS nonexistent
# 返回: []
# 在应用中使用
def get_user_values(user_id):
return redis.hvals(f"user:{user_id}")
# 统计字段值
values = get_user_values(1001)
print(f"用户有 {len(values)} 个字段")
# 检查是否包含特定值
def has_value(user_id, target_value):
values = redis.hvals(f"user:{user_id}")
return target_value in values
# 获取所有数值字段
def get_numeric_values(user_id):
values = redis.hvals(f"user:{user_id}")
numeric_values = []
for value in values:
try:
numeric_values.append(int(value))
except ValueError:
pass
return numeric_values
注意事项：
- 大哈希会返回大量字段值
- 只返回字段值，不返回字段名
- 考虑使用 HSCAN 遍历大哈希
- 常用于数据统计和值分析
HLEN
命令作用： HLEN 命令用于获取哈希中字段的数量。这是一个轻量级的统计命令，常用于数据监控、容量检查、业务逻辑判断等场景。
命令语法：
HLEN key
参数说明：
key：哈希的键名
命令特性：
- 时间复杂度 O(1)，执行速度极快
- 返回字段数量（整数）
- 哈希不存在时返回 0
- 不修改哈希数据
- 提供快速的数量统计
使用示例：
# 获取字段数量
HLEN user:1001
# 返回: 3
# 哈希不存在时
HLEN nonexistent
# 返回: 0
# 在应用中使用
def get_user_field_count(user_id):
return redis.hlen(f"user:{user_id}")
# 检查用户信息完整性
def is_user_profile_complete(user_id, required_field_count):
actual_count = redis.hlen(f"user:{user_id}")
return actual_count >= required_field_count
# 监控哈希大小
def monitor_hash_size(key, max_size):
current_size = redis.hlen(key)
if current_size > max_size:
print(f"警告: {key} 字段数量过多: {current_size}")
return current_size
# 批量检查多个用户
def check_users_completeness(user_ids, min_fields):
results = {}
for user_id in user_ids:
field_count = redis.hlen(f"user:{user_id}")
results[user_id] = field_count >= min_fields
return results
注意事项：
- 只返回字段数量，不返回字段名或值
- 哈希不存在时返回 0
- 常用于数据完整性检查
- 配合其他命令实现复杂逻辑
列表命令
LPUSH
命令作用： LPUSH 命令用于在列表的左侧（头部）插入一个或多个元素。这是实现栈（LIFO - Last In First Out）数据结构的关键命令，常用于消息队列、任务队列、历史记录等场景。
命令语法：
LPUSH key element [element ...]
参数说明：
key：列表的键名element：要插入的元素，可以指定多个
命令特性：
- 原子性操作，所有元素同时插入
- 新元素插入到列表头部（索引 0）
- 如果列表不存在，会自动创建
- 返回插入后列表的长度
- 支持插入任意数量的元素
使用示例：
# 插入单个元素
LPUSH tasks "task1"
# 返回: 1
# 插入多个元素
LPUSH tasks "task2" "task3" "task4"
# 返回: 4
# 查看列表内容
LRANGE tasks 0 -1
# 返回: ["task4", "task3", "task2", "task1"]
# 在应用中使用
def add_task(task_name):
return redis.lpush("task:queue", task_name)
# 批量添加任务
def add_tasks(task_list):
return redis.lpush("task:queue", *task_list)
# 实现消息队列
def send_message(channel, message):
return redis.lpush(f"messages:{channel}", message)
注意事项：
- 元素按插入顺序的逆序存储
- 大量元素会影响内存使用
- 常用于实现栈和消息队列
- 配合 LPOP 实现先进后出
RPUSH
命令作用： RPUSH 命令用于在列表的右侧（尾部）插入一个或多个元素。这是实现队列（FIFO - First In First Out）数据结构的关键命令，常用于任务队列、消息队列、日志记录等场景。
命令语法：
RPUSH key element [element ...]
参数说明：
key：列表的键名element：要插入的元素，可以指定多个
命令特性：
- 原子性操作，所有元素同时插入
- 新元素插入到列表尾部
- 如果列表不存在，会自动创建
- 返回插入后列表的长度
- 支持插入任意数量的元素
使用示例：
# 插入单个元素
RPUSH logs "log1"
# 返回: 1
# 插入多个元素
RPUSH logs "log2" "log3" "log4"
# 返回: 4
# 查看列表内容
LRANGE logs 0 -1
# 返回: ["log1", "log2", "log3", "log4"]
# 在应用中使用
def add_log(log_message):
return redis.rpush("system:logs", log_message)
# 批量添加日志
def add_logs(log_messages):
return redis.rpush("system:logs", *log_messages)
# 实现任务队列
def enqueue_task(task_data):
return redis.rpush("task:queue", json.dumps(task_data))
注意事项：
- 元素按插入顺序存储
- 大量元素会影响内存使用
- 常用于实现队列和日志系统
- 配合 LPOP 实现先进先出
LPOP
命令作用： LPOP 命令用于从列表的左侧（头部）弹出并返回一个或多个元素。这是实现栈和队列操作的关键命令，常用于任务处理、消息消费等场景。
命令语法：
LPOP key [count]
参数说明：
key：列表的键名count（可选）：要弹出的元素数量，默认为 1
命令特性：
- 原子性操作，元素被移除并返回
- 从列表头部弹出元素
- 列表为空时返回 nil
- 支持弹出多个元素
- 时间复杂度 O(N)，N 为弹出元素数量
使用示例：
# 弹出单个元素
LPOP tasks
# 返回: "task4"
# 弹出多个元素
LPOP tasks 2
# 返回: ["task3", "task2"]
# 列表为空时
LPOP empty_list
# 返回: (nil)
# 在应用中使用
def get_next_task():
return redis.lpop("task:queue")
# 批量处理任务
def process_tasks(batch_size=10):
tasks = redis.lpop("task:queue", batch_size)
if tasks:
for task in tasks:
process_single_task(task)
return len(tasks) if tasks else 0
# 实现消息消费
def consume_message():
message = redis.lpop("messages:channel1")
if message:
handle_message(message)
return message
注意事项：
- 元素被永久移除
- 列表为空时返回 nil
- 支持批量弹出提高性能
- 常用于任务队列和消息处理
RPOP
命令作用： RPOP 命令用于从列表的右侧（尾部）弹出并返回一个或多个元素。这是实现队列操作的关键命令，常用于任务处理、消息消费等场景。
命令语法：
RPOP key [count]
参数说明：
key：列表的键名count（可选）：要弹出的元素数量，默认为 1
命令特性：
- 原子性操作，元素被移除并返回
- 从列表尾部弹出元素
- 列表为空时返回 nil
- 支持弹出多个元素
- 时间复杂度 O(N)，N 为弹出元素数量
使用示例：
# 弹出单个元素
RPOP logs
# 返回: "log4"
# 弹出多个元素
RPOP logs 2
# 返回: ["log3", "log2"]
# 列表为空时
RPOP empty_list
# 返回: (nil)
# 在应用中使用
def get_latest_log():
return redis.rpop("system:logs")
# 清理旧日志
def cleanup_old_logs(count=100):
old_logs = redis.rpop("system:logs", count)
return len(old_logs) if old_logs else 0
# 实现任务处理
def process_task():
task = redis.rpop("task:queue")
if task:
execute_task(task)
return task
注意事项：
- 元素被永久移除
- 列表为空时返回 nil
- 支持批量弹出提高性能
- 常用于队列处理和日志清理
LRANGE
命令作用： LRANGE 命令用于获取列表中指定范围的元素。这是一个只读操作，不会修改列表内容，常用于数据查询、分页显示、数据导出等场景。
命令语法：
LRANGE key start stop
参数说明：
key：列表的键名start：起始索引（包含）stop：结束索引（包含）
命令特性：
- 支持负数索引，-1 表示最后一个元素
- 不修改列表内容
- 列表不存在时返回空数组
- 时间复杂度 O(S+N)，S 为起始位置，N 为元素数量
- 支持获取任意范围的元素
使用示例：
# 获取所有元素
LRANGE mylist 0 -1
# 返回: ["item1", "item2", "item3", "item4"]
# 获取前3个元素
LRANGE mylist 0 2
# 返回: ["item1", "item2", "item3"]
# 获取最后2个元素
LRANGE mylist -2 -1
# 返回: ["item3", "item4"]
# 获取中间元素
LRANGE mylist 1 2
# 返回: ["item2", "item3"]
# 在应用中使用
def get_recent_logs(count=10):
return redis.lrange("system:logs", -count, -1)
# 分页获取数据
def get_page_data(page, page_size):
start = (page - 1) * page_size
end = start + page_size - 1
return redis.lrange("data:list", start, end)
# 获取列表统计信息
def get_list_stats(key):
total = redis.llen(key)
if total > 0:
first = redis.lrange(key, 0, 0)[0]
last = redis.lrange(key, -1, -1)[0]
return {"total": total, "first": first, "last": last}
return {"total": 0}
注意事项：
- 支持负数索引
- 不修改列表内容
- 大范围查询会影响性能
- 常用于数据查询和分页
LLEN
命令作用： LLEN 命令用于获取列表的长度（元素数量）。这是一个轻量级的统计命令，常用于数据监控、容量检查、业务逻辑判断等场景。
命令语法：
LLEN key
参数说明：
key：列表的键名
命令特性：
- 时间复杂度 O(1)，执行速度极快
- 返回列表长度（整数）
- 列表不存在时返回 0
- 不修改列表内容
- 提供快速的数量统计
使用示例：
# 获取列表长度
LLEN mylist
# 返回: 4
# 列表不存在时
LLEN nonexistent
# 返回: 0
# 在应用中使用
def get_queue_length():
return redis.llen("task:queue")
# 检查队列是否为空
def is_queue_empty():
return redis.llen("task:queue") == 0
# 监控队列大小
def monitor_queue_size(max_size=1000):
current_size = redis.llen("task:queue")
if current_size > max_size:
print(f"警告: 队列大小超过限制: {current_size}")
return current_size
# 批量检查多个队列
def check_queues_status(queue_keys):
status = {}
for key in queue_keys:
status[key] = redis.llen(key)
return status
注意事项：
- 只返回长度，不返回元素内容
- 列表不存在时返回 0
- 常用于容量监控和状态检查
- 配合其他命令实现复杂逻辑
LINDEX
命令作用： LINDEX 命令用于获取列表中指定索引位置的元素。这是一个只读操作，不会修改列表内容，常用于随机访问、数据查询等场景。
命令语法：
LINDEX key index
参数说明：
key：列表的键名index：元素索引位置
命令特性：
- 支持负数索引，-1 表示最后一个元素
- 不修改列表内容
- 索引超出范围时返回 nil
- 时间复杂度 O(N)，N 为索引位置
- 只返回单个元素
使用示例：
# 获取第一个元素
LINDEX mylist 0
# 返回: "item1"
# 获取最后一个元素
LINDEX mylist -1
# 返回: "item4"
# 获取中间元素
LINDEX mylist 2
# 返回: "item3"
# 索引超出范围
LINDEX mylist 10
# 返回: (nil)
# 在应用中使用
def get_first_task():
return redis.lindex("task:queue", 0)
def get_last_log():
return redis.lindex("system:logs", -1)
# 随机访问数据
def get_data_at_position(position):
return redis.lindex("data:list", position)
# 检查特定位置的数据
def check_data_at_index(index, expected_value):
actual_value = redis.lindex("data:list", index)
return actual_value == expected_value
注意事项：
- 支持负数索引
- 索引超出范围返回 nil
- 不修改列表内容
- 常用于随机访问和查询
LINSERT
命令作用： LINSERT 命令用于在列表中指定元素的前面或后面插入新元素。这是一个精确插入操作，常用于数据维护、列表更新等场景。
命令语法：
LINSERT key BEFORE|AFTER pivot element
参数说明：
key：列表的键名BEFORE|AFTER：插入位置，BEFORE 表示在指定元素前面，AFTER 表示在后面pivot：参考元素element：要插入的新元素
命令特性：
- 原子性操作
- 如果参考元素不存在，返回 -1
- 返回插入后列表的长度
- 只插入单个元素
- 时间复杂度 O(N)，N 为列表长度
使用示例：
# 在指定元素前面插入
LINSERT mylist BEFORE "item2" "newitem"
# 返回: 5
# 在指定元素后面插入
LINSERT mylist AFTER "item2" "anotheritem"
# 返回: 6
# 参考元素不存在
LINSERT mylist BEFORE "nonexistent" "item"
# 返回: -1
# 在应用中使用
def insert_before_task(task_queue, reference_task, new_task):
return redis.linsert(task_queue, "BEFORE", reference_task, new_task)
def insert_after_task(task_queue, reference_task, new_task):
return redis.linsert(task_queue, "AFTER", reference_task, new_task)
# 维护有序列表
def maintain_sorted_list(key, new_value, reference_value):
result = redis.linsert(key, "AFTER", reference_value, new_value)
if result == -1:
# 参考元素不存在，添加到末尾
redis.rpush(key, new_value)
return result
注意事项：
- 参考元素不存在时返回 -1
- 只插入单个元素
- 时间复杂度较高，大列表慎用
- 常用于数据维护和列表更新
LREM
命令作用： LREM 命令用于从列表中删除指定数量的匹配元素。这是一个精确删除操作，可以控制删除的数量和方向，常用于数据清理、列表维护等场景。
命令语法：
LREM key count element
参数说明：
key：列表的键名count：删除数量count > 0：从头部开始删除指定数量的匹配元素count < 0：从尾部开始删除指定数量的匹配元素count = 0：删除所有匹配的元素
element：要删除的元素
命令特性：
- 原子性操作
- 返回实际删除的元素数量
- 支持指定删除数量
- 支持从不同方向删除
- 时间复杂度 O(N)，N 为列表长度
使用示例：
# 从头部删除1个匹配元素
LREM mylist 1 "item2"
# 返回: 1
# 从尾部删除1个匹配元素
LREM mylist -1 "item3"
# 返回: 1
# 删除所有匹配元素
LREM mylist 0 "item1"
# 返回: 2
# 在应用中使用
def remove_task(task_queue, task_name, count=1):
return redis.lrem(task_queue, count, task_name)
def remove_all_old_logs(log_key, old_log_pattern):
return redis.lrem(log_key, 0, old_log_pattern)
# 清理重复数据
def cleanup_duplicates(key, value):
# 先删除所有匹配的元素
removed = redis.lrem(key, 0, value)
# 再添加一个
if removed > 0:
redis.rpush(key, value)
return removed
# 批量清理
def batch_cleanup(key, values_to_remove):
total_removed = 0
for value in values_to_remove:
removed = redis.lrem(key, 0, value)
total_removed += removed
return total_removed
注意事项：
- 返回实际删除的元素数量
- 支持指定删除数量
- 时间复杂度较高，大列表慎用
- 常用于数据清理和维护
集合命令
SADD
命令作用： SADD 命令用于向集合（Set）中添加一个或多个成员。集合是 Redis 中用于存储唯一元素的数据结构，自动去重，常用于标签系统、用户分组、去重统计等场景。
命令语法：
SADD key member [member ...]
参数说明：
key：集合的键名member：要添加的成员，可以指定多个
命令特性：
- 原子性操作，所有成员同时添加
- 自动去重，重复成员只保留一个
- 如果集合不存在，会自动创建
- 返回新添加的成员数量（不包括重复的）
- 支持添加任意数量的成员
使用示例：
# 添加单个成员
SADD tags "redis"
# 返回: 1
# 添加多个成员
SADD tags "database" "nosql" "cache"
# 返回: 3
# 添加重复成员
SADD tags "redis" "database"
# 返回: 0 (没有新成员)
# 在应用中使用
def add_user_tags(user_id, tags):
return redis.sadd(f"user:{user_id}:tags", *tags)
# 实现标签系统
def tag_article(article_id, tags):
return redis.sadd(f"article:{article_id}:tags", *tags)
# 去重数据收集
def collect_unique_values(key, values):
return redis.sadd(key, *values)
注意事项：
- 自动去重，无需手动检查
- 大量成员会影响内存使用
- 常用于标签和分类系统
- 配合其他集合命令实现复杂逻辑
SREM
命令作用： SREM 命令用于从集合中删除指定的成员。这是一个原子性操作，可以同时删除多个成员，常用于数据清理、成员管理等场景。
命令语法：
SREM key member [member ...]
参数说明：
key：集合的键名member：要删除的成员，可以指定多个
命令特性：
- 原子性操作，所有成员同时删除
- 返回实际删除的成员数量
- 不存在的成员会被忽略
- 如果所有成员都被删除，集合键也会被删除
- 支持删除任意数量的成员
使用示例：
# 删除单个成员
SREM tags "redis"
# 返回: 1
# 删除多个成员
SREM tags "database" "nosql"
# 返回: 2
# 删除不存在的成员
SREM tags "nonexistent"
# 返回: 0
# 在应用中使用
def remove_user_tags(user_id, tags):
return redis.srem(f"user:{user_id}:tags", *tags)
# 清理过期标签
def cleanup_old_tags(tag_key, old_tags):
return redis.srem(tag_key, *old_tags)
# 批量移除成员
def batch_remove_members(key, members):
return redis.srem(key, *members)
注意事项：
- 删除不存在的成员不会报错
- 返回实际删除的成员数量
- 删除所有成员后集合键也会被删除
- 建议批量删除提高性能
SMEMBERS
命令作用： SMEMBERS 命令用于获取集合中所有成员的列表。这是一个只读操作，不会修改集合内容，常用于数据查询、成员遍历、数据导出等场景。
命令语法：
SMEMBERS key
参数说明：
key：集合的键名
命令特性：
- 返回所有成员的数组
- 集合不存在时返回空数组
- 时间复杂度 O(N)，N 为成员数量
- 不修改集合内容
- 成员顺序不固定
使用示例：
# 获取所有成员
SMEMBERS tags
# 返回: ["cache", "database", "nosql"]
# 集合不存在时
SMEMBERS nonexistent
# 返回: []
# 在应用中使用
def get_user_tags(user_id):
return redis.smembers(f"user:{user_id}:tags")
# 获取所有标签
def get_all_tags():
return redis.smembers("global:tags")
# 检查集合内容
def has_members(key):
members = redis.smembers(key)
return len(members) > 0
# 数据导出
def export_set_data(key):
members = redis.smembers(key)
return {"key": key, "members": list(members), "count": len(members)}
注意事项：
- 大集合会消耗大量内存和网络带宽
- 成员顺序不固定
- 考虑使用 SSCAN 遍历大集合
- 常用于数据查询和导出
SISMEMBER
命令作用： SISMEMBER 命令用于检查指定成员是否存在于集合中。这是一个轻量级的查询命令，常用于条件判断、成员验证等场景。
命令语法：
SISMEMBER key member
参数说明：
key：集合的键名member：要检查的成员
命令特性：
- 时间复杂度 O(1)，执行速度极快
- 返回 1 表示成员存在，0 表示不存在
- 不修改集合内容
- 集合不存在时返回 0
- 只检查单个成员
使用示例：
# 检查成员是否存在
SISMEMBER tags "redis"
# 返回: 1
# 检查不存在的成员
SISMEMBER tags "python"
# 返回: 0
# 检查不存在的集合
SISMEMBER nonexistent "member"
# 返回: 0
# 在应用中使用
def has_tag(user_id, tag):
return redis.sismember(f"user:{user_id}:tags", tag) == 1
# 权限检查
def has_permission(user_id, permission):
return redis.sismember(f"user:{user_id}:permissions", permission) == 1
# 条件性操作
def process_if_member(key, member, callback):
if redis.sismember(key, member) == 1:
return callback(member)
return None
注意事项：
- 只检查单个成员
- 集合不存在时返回 0
- 建议在添加成员前先检查
- 常用于权限验证和条件判断
SCARD
命令作用： SCARD 命令用于获取集合中成员的数量。这是一个轻量级的统计命令，常用于数据监控、容量检查、业务逻辑判断等场景。
命令语法：
SCARD key
参数说明：
key：集合的键名
命令特性：
- 时间复杂度 O(1)，执行速度极快
- 返回成员数量（整数）
- 集合不存在时返回 0
- 不修改集合内容
- 提供快速的数量统计
使用示例：
# 获取成员数量
SCARD tags
# 返回: 3
# 集合不存在时
SCARD nonexistent
# 返回: 0
# 在应用中使用
def get_tag_count(user_id):
return redis.scard(f"user:{user_id}:tags")
# 检查集合是否为空
def is_set_empty(key):
return redis.scard(key) == 0
# 监控集合大小
def monitor_set_size(key, max_size=1000):
current_size = redis.scard(key)
if current_size > max_size:
print(f"警告: {key} 成员数量过多: {current_size}")
return current_size
# 批量检查多个集合
def check_sets_status(set_keys):
status = {}
for key in set_keys:
status[key] = redis.scard(key)
return status
注意事项：
- 只返回数量，不返回成员内容
- 集合不存在时返回 0
- 常用于容量监控和状态检查
- 配合其他命令实现复杂逻辑
SINTER
命令作用： SINTER 命令用于计算多个集合的交集，返回同时存在于所有指定集合中的成员。这是集合运算的核心命令，常用于数据分析、权限验证、标签匹配等场景。
命令语法：
SINTER key [key ...]
参数说明：
key：集合的键名，可以指定多个
命令特性：
- 原子性操作，一次性计算所有交集
- 返回交集成员的数组
- 如果任何集合不存在，返回空数组
- 时间复杂度 O(N*M)，N 为最小集合大小，M 为集合数量
- 支持计算任意数量的集合
使用示例：
# 计算两个集合的交集
SINTER set1 set2
# 返回: ["common1", "common2"]
# 计算多个集合的交集
SINTER set1 set2 set3
# 返回: ["common"]
# 包含不存在的集合
SINTER set1 nonexistent
# 返回: []
# 在应用中使用
def find_common_tags(user_ids):
tag_keys = [f"user:{user_id}:tags" for user_id in user_ids]
return redis.sinter(*tag_keys)
# 权限交集
def get_common_permissions(user_ids):
perm_keys = [f"user:{user_id}:permissions" for user_id in user_ids]
return redis.sinter(*perm_keys)
# 标签匹配
def find_articles_with_tags(tags):
article_keys = [f"tag:{tag}:articles" for tag in tags]
return redis.sinter(*article_keys)
注意事项：
- 任何集合不存在都返回空数组
- 大集合计算会影响性能
- 常用于数据分析和权限验证
- 考虑使用管道优化多个集合操作
SUNION
命令作用： SUNION 命令用于计算多个集合的并集，返回存在于任何指定集合中的成员。这是集合运算的重要命令，常用于数据合并、标签聚合等场景。
命令语法：
SUNION key [key ...]
参数说明：
key：集合的键名，可以指定多个
命令特性：
- 原子性操作，一次性计算所有并集
- 返回并集成员的数组
- 自动去重，重复成员只保留一个
- 时间复杂度 O(N)，N 为所有集合成员总数
- 支持计算任意数量的集合
使用示例：
# 计算两个集合的并集
SUNION set1 set2
# 返回: ["member1", "member2", "member3", "member4"]
# 计算多个集合的并集
SUNION set1 set2 set3
# 返回: ["member1", "member2", "member3", "member4", "member5"]
# 包含不存在的集合
SUNION set1 nonexistent
# 返回: ["member1", "member2"]
# 在应用中使用
def get_all_user_tags(user_ids):
tag_keys = [f"user:{user_id}:tags" for user_id in user_ids]
return redis.sunion(*tag_keys)
# 合并权限
def get_all_permissions(user_ids):
perm_keys = [f"user:{user_id}:permissions" for user_id in user_ids]
return redis.sunion(*perm_keys)
# 标签聚合
def aggregate_tags(tag_sets):
return redis.sunion(*tag_sets)
注意事项：
- 自动去重，无需手动处理
- 大集合计算会影响性能
- 常用于数据合并和聚合
- 考虑使用管道优化多个集合操作
SDIFF
命令作用： SDIFF 命令用于计算多个集合的差集，返回存在于第一个集合但不存在于其他集合中的成员。这是集合运算的重要命令，常用于数据过滤、权限排除等场景。
命令语法：
SDIFF key [key ...]
参数说明：
key：集合的键名，可以指定多个- 第一个集合是基准集合，其他集合用于排除
命令特性：
- 原子性操作，一次性计算所有差集
- 返回差集成员的数组
- 如果基准集合不存在，返回空数组
- 时间复杂度 O(N)，N 为所有集合成员总数
- 支持计算任意数量的集合
使用示例：
# 计算两个集合的差集
SDIFF set1 set2
# 返回: ["member1", "member2"]
# 计算多个集合的差集
SDIFF set1 set2 set3
# 返回: ["member1"]
# 基准集合不存在
SDIFF nonexistent set2
# 返回: []
# 在应用中使用
def get_unique_tags(user_id, exclude_users):
user_tags = f"user:{user_id}:tags"
exclude_keys = [f"user:{exclude_id}:tags" for exclude_id in exclude_users]
return redis.sdiff(user_tags, *exclude_keys)
# 权限排除
def get_exclusive_permissions(user_id, exclude_users):
user_perms = f"user:{user_id}:permissions"
exclude_keys = [f"user:{exclude_id}:permissions" for exclude_id in exclude_users]
return redis.sdiff(user_perms, *exclude_keys)
# 数据过滤
def filter_data(base_set, exclude_sets):
return redis.sdiff(base_set, *exclude_sets)
注意事项：
- 第一个集合是基准，其他集合用于排除
- 基准集合不存在时返回空数组
- 大集合计算会影响性能
- 常用于数据过滤和权限排除
有序集合命令
ZADD
命令作用： ZADD 命令用于向有序集合（Sorted Set）中添加一个或多个成员。有序集合是 Redis 中唯一既支持按分数排序又支持按成员查询的数据结构，常用于排行榜、优先级队列、范围查询等场景。
命令语法：
ZADD key [NX|XX] [CH] [INCR] score member [score member ...]
参数说明：
key：有序集合的键名score：成员的分数（双精度浮点数）member：成员名称NX：仅当成员不存在时添加XX：仅当成员存在时更新CH：返回修改的成员数量INCR：增加分数而不是设置分数
命令特性：
- 原子性操作，所有成员同时添加
- 成员按分数自动排序
- 相同分数的成员按字典序排序
- 支持条件添加和更新
- 支持分数增量操作
使用示例：
# 基本添加
ZADD leaderboard 100 "player1" 200 "player2" 150 "player3"
# 返回: 3
# 条件添加（仅当成员不存在）
ZADD leaderboard NX 300 "player4"
# 返回: 1
# 条件更新（仅当成员存在）
ZADD leaderboard XX 250 "player1"
# 返回: 0
# 增量操作
ZADD leaderboard INCR 50 "player2"
# 返回: "250"
# 在应用中使用
def add_player_score(leaderboard, player, score):
return redis.zadd(leaderboard, {player: score})
def update_player_score(leaderboard, player, score):
return redis.zadd(leaderboard, "XX", {player: score})
def increment_score(leaderboard, player, increment):
return redis.zadd(leaderboard, "INCR", increment, player)
注意事项：
- 分数支持双精度浮点数
- 相同分数的成员按字典序排序
- 条件操作可以提高性能
- 常用于排行榜和优先级队列
ZREM
命令作用： ZREM 命令用于从有序集合中删除指定的成员。这是一个原子性操作，可以同时删除多个成员，常用于数据清理、成员管理等场景。
命令语法：
ZREM key member [member ...]
参数说明：
key：有序集合的键名member：要删除的成员，可以指定多个
命令特性：
- 原子性操作，所有成员同时删除
- 返回实际删除的成员数量
- 不存在的成员会被忽略
- 如果所有成员都被删除，有序集合键也会被删除
- 支持删除任意数量的成员
使用示例：
# 删除单个成员
ZREM leaderboard "player1"
# 返回: 1
# 删除多个成员
ZREM leaderboard "player2" "player3"
# 返回: 2
# 删除不存在的成员
ZREM leaderboard "nonexistent"
# 返回: 0
# 在应用中使用
def remove_player(leaderboard, player):
return redis.zrem(leaderboard, player)
def remove_players(leaderboard, players):
return redis.zrem(leaderboard, *players)
# 清理过期数据
def cleanup_expired_players(leaderboard, expired_players):
return redis.zrem(leaderboard, *expired_players)
注意事项：
- 删除不存在的成员不会报错
- 返回实际删除的成员数量
- 删除所有成员后有序集合键也会被删除
- 建议批量删除提高性能
ZRANGE
命令作用： ZRANGE 命令用于按排名获取有序集合中的成员。这是一个只读操作，不会修改有序集合内容，常用于排行榜查询、分页显示等场景。
命令语法：
ZRANGE key start stop [WITHSCORES]
参数说明：
key：有序集合的键名start：起始排名（包含）stop：结束排名（包含）WITHSCORES：同时返回分数
命令特性：
- 支持负数排名，-1 表示最后一名
- 不修改有序集合内容
- 有序集合不存在时返回空数组
- 时间复杂度 O(log(N)+M)，N 为成员数量，M 为返回数量
- 按分数升序排列
使用示例：
# 获取所有成员
ZRANGE leaderboard 0 -1
# 返回: ["player1", "player3", "player2"]
# 获取前3名
ZRANGE leaderboard 0 2
# 返回: ["player1", "player3", "player2"]
# 获取带分数的成员
ZRANGE leaderboard 0 -1 WITHSCORES
# 返回: ["player1", "100", "player3", "150", "player2", "200"]
# 在应用中使用
def get_top_players(leaderboard, count=10):
return redis.zrange(leaderboard, 0, count-1, withscores=True)
def get_players_by_rank(leaderboard, start, stop):
return redis.zrange(leaderboard, start, stop)
def get_player_rankings(leaderboard):
return redis.zrange(leaderboard, 0, -1, withscores=True)
注意事项：
- 支持负数排名
- 按分数升序排列
- 不修改有序集合内容
- 常用于排行榜查询
ZREVRANGE
命令作用： ZREVRANGE 命令用于按排名倒序获取有序集合中的成员。与 ZRANGE 相反，ZREVRANGE 按分数降序排列，常用于获取排行榜前几名等场景。
命令语法：
ZREVRANGE key start stop [WITHSCORES]
参数说明：
key：有序集合的键名start：起始排名（包含）stop：结束排名（包含）WITHSCORES：同时返回分数
命令特性：
- 支持负数排名，-1 表示最后一名
- 不修改有序集合内容
- 有序集合不存在时返回空数组
- 时间复杂度 O(log(N)+M)，N 为成员数量，M 为返回数量
- 按分数降序排列
使用示例：
# 获取所有成员（降序）
ZREVRANGE leaderboard 0 -1
# 返回: ["player2", "player3", "player1"]
# 获取前3名
ZREVRANGE leaderboard 0 2
# 返回: ["player2", "player3", "player1"]
# 获取带分数的成员
ZREVRANGE leaderboard 0 -1 WITHSCORES
# 返回: ["player2", "200", "player3", "150", "player1", "100"]
# 在应用中使用
def get_leaderboard(leaderboard, count=10):
return redis.zrevrange(leaderboard, 0, count-1, withscores=True)
def get_top_players(leaderboard, count=5):
return redis.zrevrange(leaderboard, 0, count-1)
def get_player_rankings_desc(leaderboard):
return redis.zrevrange(leaderboard, 0, -1, withscores=True)
注意事项：
- 按分数降序排列
- 支持负数排名
- 不修改有序集合内容
- 常用于获取排行榜前几名
ZRANK
命令作用： ZRANK 命令用于获取成员在有序集合中的排名。排名从 0 开始，按分数升序排列，常用于查询成员位置、排名统计等场景。
命令语法：
ZRANK key member
参数说明：
key：有序集合的键名member：要查询的成员
命令特性：
- 时间复杂度 O(log(N))，执行速度较快
- 返回排名（整数），从 0 开始
- 成员不存在时返回 nil
- 按分数升序排列
- 相同分数的成员按字典序排列
使用示例：
# 获取成员排名
ZRANK leaderboard "player2"
# 返回: 2
# 成员不存在
ZRANK leaderboard "nonexistent"
# 返回: (nil)
# 在应用中使用
def get_player_rank(leaderboard, player):
rank = redis.zrank(leaderboard, player)
return rank + 1 if rank is not None else None # 转换为从1开始的排名
def get_player_position(leaderboard, player):
rank = redis.zrank(leaderboard, player)
if rank is not None:
total = redis.zcard(leaderboard)
return {"rank": rank + 1, "total": total, "percentile": (rank / total) * 100}
return None
def is_player_in_top(leaderboard, player, top_n):
rank = redis.zrank(leaderboard, player)
return rank is not None and rank < top_n
注意事项：
- 排名从 0 开始
- 成员不存在时返回 nil
- 按分数升序排列
- 常用于排名查询和统计
ZSCORE
命令作用： ZSCORE 命令用于获取成员在有序集合中的分数。这是一个轻量级的查询命令，常用于分数查询、数据验证等场景。
命令语法：
ZSCORE key member
参数说明：
key：有序集合的键名member：要查询的成员
命令特性：
- 时间复杂度 O(1)，执行速度极快
- 返回分数（字符串）
- 成员不存在时返回 nil
- 不修改有序集合内容
- 支持双精度浮点数分数
使用示例：
# 获取成员分数
ZSCORE leaderboard "player2"
# 返回: "200"
# 成员不存在
ZSCORE leaderboard "nonexistent"
# 返回: (nil)
# 在应用中使用
def get_player_score(leaderboard, player):
score = redis.zscore(leaderboard, player)
return float(score) if score is not None else None
def check_player_score(leaderboard, player, min_score):
score = redis.zscore(leaderboard, player)
if score is not None:
return float(score) >= min_score
return False
def get_player_info(leaderboard, player):
score = redis.zscore(leaderboard, player)
rank = redis.zrank(leaderboard, player)
if score is not None and rank is not None:
return {"player": player, "score": float(score), "rank": rank + 1}
return None
注意事项：
- 返回字符串格式的分数
- 成员不存在时返回 nil
- 需要转换为数值类型使用
- 常用于分数查询和验证
ZCARD
命令作用： ZCARD 命令用于获取有序集合中成员的数量。这是一个轻量级的统计命令，常用于数据监控、容量检查、业务逻辑判断等场景。
命令语法：
ZCARD key
参数说明：
key：有序集合的键名
命令特性：
- 时间复杂度 O(1)，执行速度极快
- 返回成员数量（整数）
- 有序集合不存在时返回 0
- 不修改有序集合内容
- 提供快速的数量统计
使用示例：
# 获取成员数量
ZCARD leaderboard
# 返回: 3
# 有序集合不存在时
ZCARD nonexistent
# 返回: 0
# 在应用中使用
def get_leaderboard_size(leaderboard):
return redis.zcard(leaderboard)
def is_leaderboard_empty(leaderboard):
return redis.zcard(leaderboard) == 0
def monitor_leaderboard_size(leaderboard, max_size=1000):
current_size = redis.zcard(leaderboard)
if current_size > max_size:
print(f"警告: {leaderboard} 成员数量过多: {current_size}")
return current_size
def get_leaderboard_stats(leaderboard):
size = redis.zcard(leaderboard)
if size > 0:
top_player = redis.zrevrange(leaderboard, 0, 0, withscores=True)
return {"size": size, "top_player": top_player[0] if top_player else None}
return {"size": 0, "top_player": None}
注意事项：
- 只返回数量，不返回成员内容
- 有序集合不存在时返回 0
- 常用于容量监控和状态检查
- 配合其他命令实现复杂逻辑
键管理命令
EXISTS
命令作用： EXISTS 命令用于检查一个或多个键是否存在于 Redis 数据库中。这是一个轻量级的查询命令，常用于条件判断、数据验证、缓存检查等场景。
命令语法：
EXISTS key [key ...]
参数说明：
key：要检查的键名，可以指定多个
命令特性：
- 时间复杂度 O(1)，执行速度极快
- 返回存在的键数量（整数）
- 支持检查多个键
- 不修改键的内容
- 键不存在时返回 0
使用示例：
# 检查单个键
EXISTS name
# 返回: 1
# 检查多个键
EXISTS name age city
# 返回: 2
# 检查不存在的键
EXISTS nonexistent
# 返回: 0
# 在应用中使用
def check_cache_keys(keys):
return redis.exists(*keys)
def is_user_data_cached(user_id):
return redis.exists(f"user:{user_id}:profile") == 1
def check_required_keys(required_keys):
existing_count = redis.exists(*required_keys)
return existing_count == len(required_keys)
def get_available_keys(keys):
results = []
for key in keys:
if redis.exists(key) == 1:
results.append(key)
return results
注意事项：
- 返回存在的键数量，不是布尔值
- 支持检查多个键
- 常用于条件判断和缓存检查
- 配合其他命令实现复杂逻辑
DEL
命令作用： DEL 命令用于删除一个或多个键。这是一个原子性操作，可以同时删除多个键，常用于数据清理、缓存失效、数据迁移等场景。
命令语法：
DEL key [key ...]
参数说明：
key：要删除的键名，可以指定多个
命令特性：
- 原子性操作，所有键同时删除
- 返回实际删除的键数量
- 不存在的键会被忽略
- 支持删除任意数量的键
- 删除后键及其数据永久消失
使用示例：
# 删除单个键
DEL name
# 返回: 1
# 删除多个键
DEL name age city
# 返回: 3
# 删除不存在的键
DEL nonexistent
# 返回: 0
# 在应用中使用
def clear_user_cache(user_id):
keys = [f"user:{user_id}:profile", f"user:{user_id}:settings"]
return redis.delete(*keys)
def cleanup_expired_data(expired_keys):
return redis.delete(*expired_keys)
def batch_delete_keys(key_patterns):
total_deleted = 0
for pattern in key_patterns:
keys = redis.keys(pattern)
if keys:
deleted = redis.delete(*keys)
total_deleted += deleted
return total_deleted
注意事项：
- 删除操作不可逆
- 返回实际删除的键数量
- 不存在的键不会报错
- 建议批量删除提高性能
EXPIRE
命令作用： EXPIRE 命令用于设置键的过期时间（秒）。这是 Redis 中实现自动数据清理的重要机制，常用于缓存管理、会话控制、临时数据存储等场景。
命令语法：
EXPIRE key seconds
参数说明：
key：要设置过期时间的键名seconds：过期时间（秒），必须为正整数
命令特性：
- 原子性操作
- 返回 1 表示设置成功，0 表示键不存在
- 过期时间精度为秒级
- 键过期后会自动删除
- 可以重复设置过期时间
使用示例：
# 设置过期时间（1小时）
EXPIRE name 3600
# 返回: 1
# 设置短期过期时间（5分钟）
EXPIRE temp_data 300
# 返回: 1
# 对不存在的键设置过期时间
EXPIRE nonexistent 60
# 返回: 0
# 在应用中使用
def set_cache_with_expiry(key, value, seconds):
redis.set(key, value)
return redis.expire(key, seconds)
def extend_session(session_id, additional_seconds):
return redis.expire(f"session:{session_id}", additional_seconds)
def set_temporary_data(key, data, ttl):
redis.set(key, data)
return redis.expire(key, ttl)
注意事项：
- 过期时间必须为正整数
- 键不存在时返回 0
- 可以重复设置过期时间
- 常用于缓存和会话管理
TTL
命令作用： TTL 命令用于获取键的剩余生存时间（秒）。这是一个轻量级的查询命令，常用于监控、调试、业务逻辑判断等场景。
命令语法：
TTL key
参数说明：
key：要查询的键名
命令特性：
- 时间复杂度 O(1)，执行速度极快
- 返回剩余时间（秒）
- 键不存在时返回 -2
- 键存在但没有过期时间时返回 -1
- 不修改键的内容
使用示例：
# 获取剩余时间
TTL name
# 返回: 3599
# 键不存在
TTL nonexistent
# 返回: -2
# 键存在但没有过期时间
TTL permanent_key
# 返回: -1
# 在应用中使用
def check_cache_ttl(key):
ttl = redis.ttl(key)
if ttl == -2:
return "键不存在"
elif ttl == -1:
return "永不过期"
else:
return f"剩余 {ttl} 秒"
def is_cache_expiring_soon(key, threshold=300):
ttl = redis.ttl(key)
return ttl > 0 and ttl < threshold
def get_cache_status(key):
ttl = redis.ttl(key)
if ttl == -2:
return {"status": "not_found", "ttl": None}
elif ttl == -1:
return {"status": "permanent", "ttl": None}
else:
return {"status": "expiring", "ttl": ttl}
注意事项：
- 返回剩余时间（秒）
- 键不存在时返回 -2
- 永不过期的键返回 -1
- 常用于监控和调试
PERSIST
命令作用： PERSIST 命令用于移除键的过期时间，使键变为永不过期。这是一个原子性操作，常用于数据持久化、取消自动清理等场景。
命令语法：
PERSIST key
参数说明：
key：要移除过期时间的键名
命令特性：
- 原子性操作
- 返回 1 表示成功移除，0 表示键不存在或没有过期时间
- 移除后键变为永不过期
- 不修改键的内容
- 只能移除过期时间，不能设置
使用示例：
# 移除过期时间
PERSIST name
# 返回: 1
# 对没有过期时间的键操作
PERSIST permanent_key
# 返回: 0
# 对不存在的键操作
PERSIST nonexistent
# 返回: 0
# 在应用中使用
def make_data_permanent(key):
return redis.persist(key)
def convert_temp_to_permanent(key):
if redis.exists(key) == 1:
return redis.persist(key)
return 0
def handle_important_data(key):
# 检查是否即将过期
ttl = redis.ttl(key)
if ttl > 0 and ttl < 60: # 剩余时间少于1分钟
return redis.persist(key)
return 0
注意事项：
- 只能移除过期时间，不能设置
- 键不存在时返回 0
- 没有过期时间的键返回 0
- 常用于数据持久化
RENAME
命令作用： RENAME 命令用于重命名键。这是一个原子性操作，如果新键名已存在，会覆盖原键，常用于数据迁移、键名规范化等场景。
命令语法：
RENAME key newkey
参数说明：
key：原键名newkey：新键名
命令特性：
- 原子性操作
- 如果新键名已存在，会覆盖原键
- 原键不存在时返回错误
- 新键名不能与原键名相同
- 保持原键的所有属性和数据
使用示例：
# 重命名键
RENAME oldname newname
# 返回: OK
# 新键名已存在
RENAME name age
# 返回: OK (age 被覆盖)
# 原键不存在
RENAME nonexistent newname
# 返回: (error) ERR no such key
# 在应用中使用
def rename_user_data(old_user_id, new_user_id):
old_key = f"user:{old_user_id}:profile"
new_key = f"user:{new_user_id}:profile"
return redis.rename(old_key, new_key)
def standardize_key_name(key, new_name):
if redis.exists(key) == 1:
return redis.rename(key, new_name)
return False
def migrate_data(old_key, new_key):
if redis.exists(old_key) == 1:
return redis.rename(old_key, new_key)
return False
注意事项：
- 原键不存在时返回错误
- 新键名已存在会覆盖
- 新键名不能与原键名相同
- 常用于数据迁移和重命名
TYPE
命令作用： TYPE 命令用于获取键的数据类型。这是一个轻量级的查询命令，常用于数据验证、类型检查、调试等场景。
命令语法：
TYPE key
参数说明：
key：要查询的键名
命令特性：
- 时间复杂度 O(1)，执行速度极快
- 返回数据类型名称
- 键不存在时返回 "none"
- 不修改键的内容
- 支持所有 Redis 数据类型
使用示例：
# 查询字符串类型
TYPE name
# 返回: string
# 查询列表类型
TYPE mylist
# 返回: list
# 查询哈希类型
TYPE user:1
# 返回: hash
# 键不存在
TYPE nonexistent
# 返回: none
# 在应用中使用
def validate_data_type(key, expected_type):
actual_type = redis.type(key)
return actual_type == expected_type
def get_key_info(key):
if redis.exists(key) == 1:
return {
"key": key,
"type": redis.type(key),
"ttl": redis.ttl(key)
}
return None
def process_by_type(key):
data_type = redis.type(key)
if data_type == "string":
return redis.get(key)
elif data_type == "list":
return redis.lrange(key, 0, -1)
elif data_type == "hash":
return redis.hgetall(key)
# ... 其他类型处理
return None
注意事项：
- 返回数据类型名称
- 键不存在时返回 "none"
- 常用于数据验证和类型检查
- 配合其他命令实现复杂逻辑
KEYS
命令作用： KEYS 命令用于查找匹配指定模式的所有键。这是一个强大的查询命令，常用于数据探索、批量操作、调试等场景。
命令语法：
KEYS pattern
参数说明：
pattern：匹配模式，支持通配符*：匹配任意字符?：匹配单个字符[abc]：匹配括号内的任意字符[a-z]：匹配字符范围
命令特性：
- 时间复杂度 O(N)，N 为数据库中的键数量
- 返回匹配的键数组
- 支持多种通配符模式
- 不修改键的内容
- 在生产环境中慎用
使用示例：
# 查找所有键
KEYS *
# 返回: ["name", "age", "city", "user:1", "user:2"]
# 查找特定前缀的键
KEYS user:*
# 返回: ["user:1", "user:2"]
# 查找特定模式的键
KEYS user:1:*
# 返回: ["user:1:profile", "user:1:settings"]
# 使用字符范围
KEYS user:[1-9]
# 返回: ["user:1", "user:2", "user:3"]
# 在应用中使用
def find_user_keys(user_id):
return redis.keys(f"user:{user_id}:*")
def cleanup_old_sessions():
session_keys = redis.keys("session:*")
for key in session_keys:
if redis.ttl(key) == -1: # 永不过期
redis.expire(key, 3600) # 设置1小时过期
return len(session_keys)
def get_cache_stats():
cache_keys = redis.keys("cache:*")
total_size = 0
for key in cache_keys:
total_size += redis.memory_usage(key)
return {"count": len(cache_keys), "total_size": total_size}
注意事项：
- 时间复杂度 O(N)，大数据库会影响性能
- 在生产环境中建议使用 SCAN
- 支持多种通配符模式
- 常用于数据探索和批量操作
服务器管理命令
INFO
命令作用： INFO 命令用于获取 Redis 服务器的详细信息和统计数据。这是监控 Redis 服务器状态、性能分析和故障排查的重要命令，常用于运维监控、性能调优等场景。
命令语法：
INFO [section]
参数说明：
section（可选）：指定要获取的信息部分server：服务器信息clients：客户端信息memory：内存使用情况persistence：持久化信息stats：统计信息replication：主从复制信息cpu：CPU 使用情况commandstats：命令统计cluster：集群信息keyspace：键空间信息
命令特性：
- 返回详细的服务器信息
- 支持按部分获取信息
- 不修改服务器状态
- 信息实时更新
- 包含大量监控指标
使用示例：
# 获取所有信息
INFO
# 返回: 完整的服务器信息
# 获取内存信息
INFO memory
# 返回: 内存使用情况
# 获取统计信息
INFO stats
# 返回: 服务器统计信息
# 在应用中使用
def get_redis_info():
return redis.info()
def get_memory_usage():
info = redis.info("memory")
return {
"used_memory": info["used_memory"],
"used_memory_human": info["used_memory_human"],
"maxmemory": info["maxmemory"]
}
def get_connection_count():
info = redis.info("clients")
return info["connected_clients"]
def monitor_redis_health():
info = redis.info()
return {
"uptime": info["uptime_in_seconds"],
"connected_clients": info["connected_clients"],
"used_memory": info["used_memory_human"],
"keyspace_hits": info["keyspace_hits"],
"keyspace_misses": info["keyspace_misses"]
}
注意事项：
- 返回大量信息，注意网络传输
- 支持按部分获取，减少传输量
- 常用于监控和故障排查
- 信息格式为键值对
CONFIG GET
命令作用： CONFIG GET 命令用于获取 Redis 服务器的配置参数。这是一个只读操作，不会修改配置，常用于配置检查、参数验证等场景。
命令语法：
CONFIG GET parameter
参数说明：
parameter：要获取的配置参数名- 支持通配符
*获取所有参数 - 支持部分匹配，如
max*获取所有以 max 开头的参数
- 支持通配符
命令特性：
- 只读操作，不修改配置
- 支持通配符匹配
- 返回参数名和值的数组
- 包含所有可配置参数
- 实时获取当前配置
使用示例：
# 获取特定参数
CONFIG GET maxmemory
# 返回: ["maxmemory", "0"]
# 获取所有参数
CONFIG GET "*"
# 返回: 所有配置参数的数组
# 获取匹配的参数
CONFIG GET max*
# 返回: 所有以 max 开头的参数
# 在应用中使用
def get_redis_config():
config = redis.config_get("*")
return dict(zip(config[::2], config[1::2]))
def check_memory_config():
config = redis.config_get("maxmemory")
return int(config[1]) if config[1] != "0" else None
def validate_config(required_params):
config = redis.config_get("*")
config_dict = dict(zip(config[::2], config[1::2]))
missing = [param for param in required_params if param not in config_dict]
return missing == []
def get_config_value(param_name):
config = redis.config_get(param_name)
return config[1] if config else None
注意事项：
- 只读操作，不修改配置
- 支持通配符匹配
- 返回数组格式，需要转换为字典
- 常用于配置检查和验证
CONFIG SET
命令作用： CONFIG SET 命令用于动态设置 Redis 服务器的配置参数。这是一个强大的管理命令，可以在不重启服务器的情况下修改配置，常用于性能调优、参数调整等场景。
命令语法：
CONFIG SET parameter value
参数说明：
parameter：要设置的配置参数名value：要设置的值
命令特性：
- 动态修改配置，无需重启
- 立即生效
- 支持大部分配置参数
- 某些参数需要重启才能生效
- 返回 OK 表示设置成功
使用示例：
# 设置内存限制
CONFIG SET maxmemory 100mb
# 返回: OK
# 设置超时时间
CONFIG SET timeout 300
# 返回: OK
# 设置日志级别
CONFIG SET loglevel notice
# 返回: OK
# 在应用中使用
def set_memory_limit(size_mb):
return redis.config_set("maxmemory", f"{size_mb}mb")
def configure_timeout(seconds):
return redis.config_set("timeout", str(seconds))
def optimize_redis():
configs = {
"maxmemory-policy": "allkeys-lru",
"tcp-keepalive": "60",
"timeout": "300"
}
results = {}
for param, value in configs.items():
try:
result = redis.config_set(param, value)
results[param] = result
except Exception as e:
results[param] = str(e)
return results
def set_log_level(level):
return redis.config_set("loglevel", level)
注意事项：
- 某些参数需要重启才能生效
- 设置错误的值会返回错误
- 动态修改可能影响性能
- 常用于性能调优和参数调整
FLUSHDB
命令作用： FLUSHDB 命令用于清空当前数据库中的所有键。这是一个危险的操作，会永久删除所有数据，常用于测试环境、数据清理等场景。
命令语法：
FLUSHDB [ASYNC]
参数说明：
ASYNC（可选）：异步清空，不阻塞服务器
命令特性：
- 清空当前数据库的所有键
- 操作不可逆
- 支持同步和异步模式
- 不影响其他数据库
- 返回 OK 表示清空成功
使用示例：
# 同步清空
FLUSHDB
# 返回: OK
# 异步清空
FLUSHDB ASYNC
# 返回: OK
# 在应用中使用
def clear_current_database():
return redis.flushdb()
def clear_database_async():
return redis.flushdb(async=True)
def reset_test_environment():
# 清空测试数据
redis.flushdb()
# 重新初始化测试数据
initialize_test_data()
return "测试环境已重置"
def cleanup_database():
# 检查数据库大小
size = redis.dbsize()
if size > 10000: # 如果键数量过多
return redis.flushdb()
return "数据库大小正常，无需清空"
注意事项：
- 操作不可逆，会永久删除数据
- 在生产环境中慎用
- 支持异步模式，避免阻塞
- 常用于测试环境清理
FLUSHALL
命令作用： FLUSHALL 命令用于清空所有数据库中的所有键。这是一个极其危险的操作，会永久删除所有数据，常用于测试环境、数据迁移等场景。
命令语法：
FLUSHALL [ASYNC]
参数说明：
ASYNC（可选）：异步清空，不阻塞服务器
命令特性：
- 清空所有数据库的所有键
- 操作不可逆
- 支持同步和异步模式
- 影响所有数据库
- 返回 OK 表示清空成功
使用示例：
# 同步清空所有数据库
FLUSHALL
# 返回: OK
# 异步清空所有数据库
FLUSHALL ASYNC
# 返回: OK
# 在应用中使用
def clear_all_databases():
return redis.flushall()
def clear_all_databases_async():
return redis.flushall(async=True)
def reset_redis_server():
# 清空所有数据
redis.flushall()
# 重新初始化配置
initialize_redis_config()
return "Redis 服务器已重置"
def emergency_cleanup():
# 紧急情况下的数据清理
try:
result = redis.flushall()
return f"紧急清理完成: {result}"
except Exception as e:
return f"清理失败: {e}"
注意事项：
- 操作不可逆，会永久删除所有数据
- 在生产环境中极其危险
- 支持异步模式，避免阻塞
- 常用于测试环境或紧急情况
DBSIZE
命令作用： DBSIZE 命令用于获取当前数据库中的键数量。这是一个轻量级的统计命令，常用于数据监控、容量检查、业务逻辑判断等场景。
命令语法：
DBSIZE
参数说明：
- 无参数
命令特性：
- 时间复杂度 O(1)，执行速度极快
- 返回键数量（整数）
- 不修改数据库内容
- 只统计当前数据库
- 提供快速的数量统计
使用示例：
# 获取键数量
DBSIZE
# 返回: 1500
# 在应用中使用
def get_database_size():
return redis.dbsize()
def check_database_health():
size = redis.dbsize()
if size > 100000:
return {"status": "warning", "message": "数据库键数量过多", "size": size}
elif size > 50000:
return {"status": "caution", "message": "数据库键数量较多", "size": size}
else:
return {"status": "normal", "message": "数据库大小正常", "size": size}
def monitor_database_growth():
current_size = redis.dbsize()
# 记录到监控系统
log_metric("database_size", current_size)
return current_size
def get_database_stats():
size = redis.dbsize()
info = redis.info("memory")
return {
"key_count": size,
"memory_usage": info["used_memory_human"],
"memory_peak": info["used_memory_peak_human"]
}
注意事项：
- 只统计当前数据库
- 返回键数量，不是字节数
- 常用于容量监控和状态检查
- 配合其他命令实现复杂逻辑
事务命令
MULTI
命令作用： MULTI 命令用于开始一个 Redis 事务。事务是 Redis 中实现原子性操作的重要机制，允许将多个命令打包成一个原子操作，要么全部执行成功，要么全部不执行。
命令语法：
MULTI
参数说明：
- 无参数
命令特性：
- 开始事务模式
- 后续命令进入队列，不立即执行
- 返回 OK 表示事务开始
- 支持嵌套事务（Redis 6.0+）
- 与 EXEC、DISCARD 配合使用
使用示例：
# 开始事务
MULTI
# 返回: OK
# 在应用中使用
def start_transaction():
return redis.multi()
def batch_operations():
# 开始事务
redis.multi()
# 添加多个操作
redis.set("key1", "value1")
redis.set("key2", "value2")
redis.incr("counter")
# 执行事务
return redis.exec()
def conditional_transaction():
# 开始事务
redis.multi()
# 条件性操作
if redis.exists("user:1001"):
redis.hset("user:1001", "last_login", "2024-01-01")
# 执行事务
return redis.exec()
注意事项：
- 事务开始后命令进入队列
- 需要配合 EXEC 或 DISCARD 使用
- 支持嵌套事务
- 常用于批量操作和原子性保证
EXEC
命令作用： EXEC 命令用于执行事务中的所有命令。这是事务的核心命令，将队列中的所有命令原子性地执行，要么全部成功，要么全部失败。
命令语法：
EXEC
参数说明：
- 无参数
命令特性：
- 原子性执行所有队列中的命令
- 返回每个命令的执行结果数组
- 如果任何命令执行失败，整个事务失败
- 执行后自动退出事务模式
- 支持部分命令失败的情况
使用示例：
# 执行事务
MULTI
SET name "张三"
SET age 25
EXEC
# 返回: [True, True]
# 在应用中使用
def execute_transaction():
redis.multi()
redis.set("user:1001:name", "张三")
redis.set("user:1001:age", "25")
redis.hset("user:1001:profile", "city", "北京")
return redis.exec()
def atomic_counter_update():
redis.multi()
redis.incr("page:views")
redis.incr("total:views")
redis.expire("page:views", 3600)
return redis.exec()
def batch_user_creation(users):
redis.multi()
for user in users:
redis.hset(f"user:{user['id']}", mapping=user)
return redis.exec()
注意事项：
- 原子性执行所有命令
- 返回每个命令的执行结果
- 部分命令失败可能导致整个事务失败
- 执行后自动退出事务模式
DISCARD
命令作用： DISCARD 命令用于取消事务，清空命令队列。这是一个安全机制，允许在事务执行前取消所有操作，常用于错误处理、条件判断等场景。
命令语法：
DISCARD
参数说明：
- 无参数
命令特性：
- 取消当前事务
- 清空命令队列
- 返回 OK 表示取消成功
- 自动退出事务模式
- 不执行任何命令
使用示例：
# 取消事务
MULTI
SET name "张三"
DISCARD
# 返回: OK
# 在应用中使用
def conditional_transaction(condition):
redis.multi()
redis.set("key1", "value1")
redis.set("key2", "value2")
if not condition:
# 条件不满足，取消事务
return redis.discard()
else:
# 条件满足，执行事务
return redis.exec()
def safe_batch_operations(operations):
redis.multi()
for op in operations:
if op["type"] == "set":
redis.set(op["key"], op["value"])
elif op["type"] == "delete":
redis.delete(op["key"])
# 检查是否有错误
if has_errors(operations):
return redis.discard()
else:
return redis.exec()
def rollback_transaction():
# 发生错误时回滚
return redis.discard()
注意事项：
- 取消事务，不执行任何命令
- 清空命令队列
- 自动退出事务模式
- 常用于错误处理和条件判断
WATCH
命令作用： WATCH 命令用于监视一个或多个键，实现乐观锁机制。当被监视的键被其他客户端修改时，事务会失败，常用于并发控制和数据一致性保证。
命令语法：
WATCH key [key ...]
参数说明：
key：要监视的键名，可以指定多个
命令特性：
- 监视键的变化
- 支持监视多个键
- 键被修改时事务失败
- 与 MULTI/EXEC 配合使用
- 实现乐观锁机制
使用示例：
# 监视单个键
WATCH mykey
MULTI
SET mykey "newvalue"
EXEC
# 如果 mykey 被其他客户端修改，EXEC 返回 nil
# 监视多个键
WATCH key1 key2 key3
MULTI
SET key1 "value1"
SET key2 "value2"
EXEC
# 在应用中使用
def optimistic_update(key, new_value):
# 监视键
redis.watch(key)
# 获取当前值
current_value = redis.get(key)
# 开始事务
redis.multi()
redis.set(key, new_value)
# 执行事务
result = redis.exec()
if result is None:
return "键被其他客户端修改，事务失败"
else:
return "更新成功"
def atomic_counter_increment(counter_key, increment):
redis.watch(counter_key)
current_value = int(redis.get(counter_key) or 0)
redis.multi()
redis.set(counter_key, str(current_value + increment))
result = redis.exec()
if result is None:
return "并发冲突，操作失败"
else:
return "操作成功"
def safe_data_transfer(from_key, to_key, amount):
redis.watch(from_key, to_key)
from_value = int(redis.get(from_key) or 0)
to_value = int(redis.get(to_key) or 0)
if from_value < amount:
redis.unwatch()
return "余额不足"
redis.multi()
redis.set(from_key, str(from_value - amount))
redis.set(to_key, str(to_value + amount))
result = redis.exec()
if result is None:
return "并发冲突，转账失败"
else:
return "转账成功"
注意事项：
- 监视键的变化
- 键被修改时事务失败
- 支持监视多个键
- 常用于并发控制
- 需要配合 MULTI/EXEC 使用
发布订阅命令
PUBLISH
命令作用： PUBLISH 命令用于向指定的频道发布消息。这是 Redis 发布订阅系统的核心命令，常用于消息通知、事件广播、实时通信等场景。
命令语法：
PUBLISH channel message
参数说明：
channel：频道名称message：要发布的消息内容
命令特性：
- 向指定频道发布消息
- 返回接收到消息的订阅者数量
- 消息会发送给所有订阅该频道的客户端
- 支持任意长度的消息
- 不持久化消息
使用示例：
# 发布消息
PUBLISH news "Hello World"
# 返回: 3 (有3个订阅者)
# 发布到不存在的频道
PUBLISH empty_channel "test"
# 返回: 0 (没有订阅者)
# 在应用中使用
def publish_news(title, content):
message = f"{title}: {content}"
return redis.publish("news", message)
def notify_users(event_type, data):
message = json.dumps({"type": event_type, "data": data})
return redis.publish("notifications", message)
def broadcast_system_message(message):
return redis.publish("system", message)
def publish_to_multiple_channels(channels, message):
results = {}
for channel in channels:
results[channel] = redis.publish(channel, message)
return results
注意事项：
- 返回订阅者数量
- 消息不持久化
- 支持任意长度的消息
- 常用于实时通信和事件通知
SUBSCRIBE
命令作用： SUBSCRIBE 命令用于订阅一个或多个频道。这是 Redis 发布订阅系统的核心命令，客户端订阅频道后会接收到该频道的所有消息。
命令语法：
SUBSCRIBE channel [channel ...]
参数说明：
channel：要订阅的频道名称，可以指定多个
命令特性：
- 订阅指定频道
- 支持订阅多个频道
- 客户端进入订阅模式
- 会接收到频道的所有消息
- 需要配合 UNSUBSCRIBE 取消订阅
使用示例：
# 订阅单个频道
SUBSCRIBE news
# 返回: ["subscribe", "news", 1]
# 订阅多个频道
SUBSCRIBE news sports weather
# 返回: ["subscribe", "news", 1]
# 返回: ["subscribe", "sports", 2]
# 返回: ["subscribe", "weather", 3]
# 在应用中使用
def subscribe_to_news():
pubsub = redis.pubsub()
pubsub.subscribe("news")
return pubsub
def subscribe_to_multiple_channels(channels):
pubsub = redis.pubsub()
pubsub.subscribe(*channels)
return pubsub
def listen_for_messages(channel):
pubsub = redis.pubsub()
pubsub.subscribe(channel)
for message in pubsub.listen():
if message["type"] == "message":
print(f"收到消息: {message['data']}")
return pubsub
注意事项：
- 客户端进入订阅模式
- 支持订阅多个频道
- 需要配合 UNSUBSCRIBE 取消订阅
- 常用于实时消息接收
UNSUBSCRIBE
命令作用： UNSUBSCRIBE 命令用于取消订阅一个或多个频道。这是 Redis 发布订阅系统的重要命令，允许客户端动态管理订阅关系。
命令语法：
UNSUBSCRIBE [channel [channel ...]]
参数说明：
channel（可选）：要取消订阅的频道名称，可以指定多个- 不指定频道时取消所有订阅
命令特性：
- 取消订阅指定频道
- 支持取消订阅多个频道
- 不指定频道时取消所有订阅
- 返回取消订阅的频道数量
- 客户端退出订阅模式
使用示例：
# 取消订阅单个频道
UNSUBSCRIBE news
# 返回: ["unsubscribe", "news", 0]
# 取消订阅多个频道
UNSUBSCRIBE news sports
# 返回: ["unsubscribe", "news", 1]
# 返回: ["unsubscribe", "sports", 0]
# 取消所有订阅
UNSUBSCRIBE
# 返回: ["unsubscribe", "news", 0]
# 返回: ["unsubscribe", "sports", 0]
# 返回: ["unsubscribe", "weather", 0]
# 在应用中使用
def unsubscribe_from_news():
pubsub = redis.pubsub()
pubsub.subscribe("news")
# 处理消息...
return pubsub.unsubscribe("news")
def unsubscribe_from_multiple_channels(channels):
pubsub = redis.pubsub()
pubsub.subscribe(*channels)
# 处理消息...
return pubsub.unsubscribe(*channels)
def stop_listening():
pubsub = redis.pubsub()
pubsub.subscribe("news", "sports")
# 处理消息...
return pubsub.unsubscribe() # 取消所有订阅
注意事项：
- 支持取消订阅多个频道
- 不指定频道时取消所有订阅
- 返回取消订阅的频道数量
- 常用于动态管理订阅关系
PSUBSCRIBE
命令作用： PSUBSCRIBE 命令用于订阅匹配指定模式的所有频道。这是 Redis 发布订阅系统的高级功能，支持模式匹配订阅，常用于动态频道管理。
命令语法：
PSUBSCRIBE pattern [pattern ...]
参数说明：
pattern：匹配模式，支持通配符*：匹配任意字符?：匹配单个字符[abc]：匹配括号内的任意字符[a-z]：匹配字符范围
命令特性：
- 订阅匹配模式的所有频道
- 支持多个模式匹配
- 客户端进入订阅模式
- 会接收到匹配频道的所有消息
- 需要配合 PUNSUBSCRIBE 取消订阅
使用示例：
# 订阅匹配模式
PSUBSCRIBE news.*
# 返回: ["psubscribe", "news.*", 1]
# 订阅多个模式
PSUBSCRIBE news.* sports.*
# 返回: ["psubscribe", "news.*", 1]
# 返回: ["psubscribe", "sports.*", 2]
# 在应用中使用
def subscribe_to_news_categories():
pubsub = redis.pubsub()
pubsub.psubscribe("news.*")
return pubsub
def subscribe_to_user_channels():
pubsub = redis.pubsub()
pubsub.psubscribe("user:*")
return pubsub
def listen_for_system_events():
pubsub = redis.pubsub()
pubsub.psubscribe("system:*")
for message in pubsub.listen():
if message["type"] == "pmessage":
channel = message["channel"]
pattern = message["pattern"]
data = message["data"]
print(f"频道 {channel} 匹配模式 {pattern}: {data}")
return pubsub
def subscribe_to_multiple_patterns(patterns):
pubsub = redis.pubsub()
pubsub.psubscribe(*patterns)
return pubsub
注意事项：
- 支持模式匹配订阅
- 支持多个模式匹配
- 需要配合 PUNSUBSCRIBE 取消订阅
- 常用于动态频道管理
高级命令
SCAN
命令作用： SCAN 命令用于迭代遍历数据库中的键，是 KEYS 命令的安全替代方案。SCAN 是一个非阻塞的、渐进式的迭代命令，不会阻塞 Redis 服务器，适合在生产环境中使用。
命令语法：
SCAN cursor [MATCH pattern] [COUNT count] [TYPE type]
参数说明：
cursor：游标，从 0 开始，返回 0 表示遍历完成MATCH pattern：匹配模式，支持通配符COUNT count：每次返回的键数量（建议值）TYPE type：只返回指定类型的键
命令特性：
- 非阻塞操作，不会阻塞 Redis 服务器
- 渐进式迭代，每次返回少量键
- 支持模式匹配和类型过滤
- 返回的键可能重复，需要客户端去重
- 在遍历过程中键可能被修改或删除
使用示例：
# 基本用法
SCAN 0
# 返回: ["0", ["key1", "key2", "key3"]]
# 匹配模式
SCAN 0 MATCH user:*
# 返回: ["0", ["user:1", "user:2"]]
# 指定返回数量
SCAN 0 COUNT 100
# 返回: ["0", ["key1", "key2", "key3", "key4", "key5"]]
# 只返回字符串类型
SCAN 0 TYPE string
# 返回: ["0", ["string_key1", "string_key2"]]
# 组合使用
SCAN 0 MATCH user:* COUNT 50 TYPE string
# 返回: ["0", ["user:1", "user:2"]]
# 在应用中使用
def scan_all_keys():
cursor = 0
all_keys = []
while True:
cursor, keys = redis.scan(cursor)
all_keys.extend(keys)
if cursor == 0:
break
return all_keys
def scan_keys_by_pattern(pattern):
cursor = 0
matching_keys = []
while True:
cursor, keys = redis.scan(cursor, match=pattern)
matching_keys.extend(keys)
if cursor == 0:
break
return matching_keys
def scan_keys_by_type(data_type):
cursor = 0
typed_keys = []
while True:
cursor, keys = redis.scan(cursor, type=data_type)
typed_keys.extend(keys)
if cursor == 0:
break
return typed_keys
def safe_scan_with_deduplication(pattern="*"):
cursor = 0
seen_keys = set()
unique_keys = []
while True:
cursor, keys = redis.scan(cursor, match=pattern)
for key in keys:
if key not in seen_keys:
seen_keys.add(key)
unique_keys.append(key)
if cursor == 0:
break
return unique_keys
注意事项：
- 返回的键可能重复，需要客户端去重
- 在遍历过程中键可能被修改或删除
- 建议在客户端实现去重逻辑
- 比 KEYS 命令更安全，适合生产环境
SSCAN
命令作用： SSCAN 命令用于迭代遍历集合中的成员。这是 SCAN 命令的集合版本，提供安全的集合成员遍历功能，不会阻塞 Redis 服务器。
命令语法：
SSCAN key cursor [MATCH pattern] [COUNT count]
参数说明：
key：集合的键名cursor：游标，从 0 开始，返回 0 表示遍历完成MATCH pattern：匹配模式，支持通配符COUNT count：每次返回的成员数量（建议值）
命令特性：
- 非阻塞操作，不会阻塞 Redis 服务器
- 渐进式迭代，每次返回少量成员
- 支持模式匹配过滤
- 返回的成员可能重复，需要客户端去重
- 在遍历过程中成员可能被修改或删除
使用示例：
# 遍历集合所有成员
SSCAN myset 0
# 返回: ["0", ["member1", "member2", "member3"]]
# 匹配模式
SSCAN myset 0 MATCH user:*
# 返回: ["0", ["user:1", "user:2"]]
# 指定返回数量
SSCAN myset 0 COUNT 100
# 返回: ["0", ["member1", "member2", "member3", "member4", "member5"]]
# 在应用中使用
def scan_set_members(key):
cursor = 0
all_members = []
while True:
cursor, members = redis.sscan(key, cursor)
all_members.extend(members)
if cursor == 0:
break
return all_members
def scan_set_members_by_pattern(key, pattern):
cursor = 0
matching_members = []
while True:
cursor, members = redis.sscan(key, cursor, match=pattern)
matching_members.extend(members)
if cursor == 0:
break
return matching_members
注意事项：
- 返回的成员可能重复，需要客户端去重
- 在遍历过程中成员可能被修改或删除
- 建议在客户端实现去重逻辑
- 比 SMEMBERS 命令更安全，适合大集合
HSCAN
命令作用： HSCAN 命令用于迭代遍历哈希中的字段。这是 SCAN 命令的哈希版本，提供安全的哈希字段遍历功能，不会阻塞 Redis 服务器。
命令语法：
HSCAN key cursor [MATCH pattern] [COUNT count]
参数说明：
key：哈希的键名cursor：游标，从 0 开始，返回 0 表示遍历完成MATCH pattern：匹配模式，支持通配符COUNT count：每次返回的字段数量（建议值）
命令特性：
- 非阻塞操作，不会阻塞 Redis 服务器
- 渐进式迭代，每次返回少量字段
- 支持模式匹配过滤
- 返回的字段可能重复，需要客户端去重
- 在遍历过程中字段可能被修改或删除
使用示例：
# 遍历哈希所有字段
HSCAN user:1 0
# 返回: ["0", ["name", "张三", "age", "25", "email", "zhangsan@example.com"]]
# 匹配字段名模式
HSCAN user:1 0 MATCH name*
# 返回: ["0", ["name", "张三"]]
# 指定返回数量
HSCAN user:1 0 COUNT 50
# 返回: ["0", ["name", "张三", "age", "25", "email", "zhangsan@example.com"]]
# 在应用中使用
def scan_hash_fields(key):
cursor = 0
all_fields = []
while True:
cursor, fields = redis.hscan(key, cursor)
all_fields.extend(fields)
if cursor == 0:
break
return all_fields
def scan_hash_fields_by_pattern(key, pattern):
cursor = 0
matching_fields = []
while True:
cursor, fields = redis.hscan(key, cursor, match=pattern)
matching_fields.extend(fields)
if cursor == 0:
break
return matching_fields
注意事项：
- 返回的字段可能重复，需要客户端去重
- 在遍历过程中字段可能被修改或删除
- 建议在客户端实现去重逻辑
- 比 HGETALL 命令更安全，适合大哈希
ZSCAN
命令作用： ZSCAN 命令用于迭代遍历有序集合中的成员。这是 SCAN 命令的有序集合版本，提供安全的有序集合成员遍历功能，不会阻塞 Redis 服务器。
命令语法：
ZSCAN key cursor [MATCH pattern] [COUNT count]
参数说明：
key：有序集合的键名cursor：游标，从 0 开始，返回 0 表示遍历完成MATCH pattern：匹配模式，支持通配符COUNT count：每次返回的成员数量（建议值）
命令特性：
- 非阻塞操作，不会阻塞 Redis 服务器
- 渐进式迭代，每次返回少量成员
- 支持模式匹配过滤
- 返回的成员可能重复，需要客户端去重
- 在遍历过程中成员可能被修改或删除
使用示例：
# 遍历有序集合所有成员
ZSCAN leaderboard 0
# 返回: ["0", ["player1", "100", "player2", "200", "player3", "150"]]
# 匹配模式
ZSCAN leaderboard 0 MATCH player*
# 返回: ["0", ["player1", "100", "player2", "200", "player3", "150"]]
# 指定返回数量
ZSCAN leaderboard 0 COUNT 100
# 返回: ["0", ["player1", "100", "player2", "200", "player3", "150"]]
# 在应用中使用
def scan_sorted_set_members(key):
cursor = 0
all_members = []
while True:
cursor, members = redis.zscan(key, cursor)
all_members.extend(members)
if cursor == 0:
break
return all_members
def scan_sorted_set_members_by_pattern(key, pattern):
cursor = 0
matching_members = []
while True:
cursor, members = redis.zscan(key, cursor, match=pattern)
matching_members.extend(members)
if cursor == 0:
break
return matching_members
注意事项：
- 返回的成员可能重复，需要客户端去重
- 在遍历过程中成员可能被修改或删除
- 建议在客户端实现去重逻辑
- 比 ZRANGE 命令更安全，适合大有序集合 ZSCAN leaderboard 0
匹配成员名模式
ZSCAN leaderboard 0 MATCH player*
指定返回数量
ZSCAN leaderboard 0 COUNT 100
### EVAL
**语法**: `EVAL script numkeys key [key ...] arg [arg ...]`
**作用**: 执行 Lua 脚本
**参数**:
- `script`: Lua 脚本内容
- `numkeys`: 键的数量
- `key`: 键名
- `arg`: 参数
**示例**:
```redis
# 简单的 Lua 脚本
EVAL "return redis.call('GET', KEYS[1])" 1 mykey
# 带参数的脚本
EVAL "return redis.call('SET', KEYS[1], ARGV[1])" 1 mykey "hello"
# 复杂脚本：原子性操作
EVAL "
local current = redis.call('GET', KEYS[1])
if current == false then
return redis.call('SET', KEYS[1], ARGV[1])
else
return redis.call('INCR', KEYS[1])
end
" 1 counter 1
EVALSHA
语法: EVALSHA sha1 numkeys key [key ...] arg [arg ...]作用: 使用脚本的 SHA1 值执行 Lua 脚本 示例:
# 先加载脚本
SCRIPT LOAD "return redis.call('GET', KEYS[1])"
# 使用 SHA1 执行
EVALSHA a1b2c3d4e5f6... 1 mykey
SCRIPT LOAD
语法: SCRIPT LOAD script作用: 加载 Lua 脚本到服务器 示例:
SCRIPT LOAD "return redis.call('GET', KEYS[1])"
SCRIPT EXISTS
语法: SCRIPT EXISTS script [script ...]作用: 检查脚本是否已加载 示例:
SCRIPT EXISTS a1b2c3d4e5f6... b2c3d4e5f6a1...
SCRIPT FLUSH
语法: SCRIPT FLUSH [ASYNC|SYNC]作用: 清空所有已加载的脚本 示例:
SCRIPT FLUSH
SCRIPT FLUSH ASYNC
BITCOUNT
语法: BITCOUNT key [start end]作用: 计算字符串中设置位的数量 示例:
# 设置位图
SETBIT mybitmap 0 1
SETBIT mybitmap 1 1
SETBIT mybitmap 2 0
SETBIT mybitmap 3 1
# 计算设置位的数量
BITCOUNT mybitmap
# 计算指定范围的位数
BITCOUNT mybitmap 0 1
BITOP
语法: BITOP operation destkey key [key ...]作用: 对多个字符串进行位运算 操作:
AND: 按位与OR: 按位或XOR: 按位异或NOT: 按位非
示例:
# 设置两个位图
SETBIT bitmap1 0 1
SETBIT bitmap1 1 0
SETBIT bitmap2 0 0
SETBIT bitmap2 1 1
# 按位与运算
BITOP AND result bitmap1 bitmap2
# 按位或运算
BITOP OR result bitmap1 bitmap2
SETBIT
语法: SETBIT key offset value作用: 设置字符串指定位置的位值 示例:
# 设置第 0 位为 1
SETBIT mybitmap 0 1
# 设置第 100 位为 0
SETBIT mybitmap 100 0
GETBIT
语法: GETBIT key offset作用: 获取字符串指定位置的位值 示例:
# 获取第 0 位的值
GETBIT mybitmap 0
# 获取第 100 位的值
GETBIT mybitmap 100
BITPOS
语法: BITPOS key bit [start] [end]作用: 查找第一个设置为指定值的位的位置 示例:
# 查找第一个设置为 1 的位
BITPOS mybitmap 1
# 在指定范围内查找
BITPOS mybitmap 1 0 10
PFADD
语法: PFADD key element [element ...]作用: 向 HyperLogLog 添加元素 示例:
# 添加元素到 HyperLogLog
PFADD visitors user1 user2 user3
# 添加单个元素
PFADD visitors user4
PFCOUNT
语法: PFCOUNT key [key ...]作用: 计算 HyperLogLog 的近似基数 示例:
# 计算单个 HyperLogLog 的基数
PFCOUNT visitors
# 计算多个 HyperLogLog 的并集基数
PFCOUNT visitors1 visitors2 visitors3
PFMERGE
语法: PFMERGE destkey sourcekey [sourcekey ...]作用: 合并多个 HyperLogLog 示例:
# 合并两个 HyperLogLog
PFMERGE all_visitors visitors1 visitors2
# 合并多个 HyperLogLog
PFMERGE total visitors1 visitors2 visitors3
GEOADD
语法: GEOADD key longitude latitude member [longitude latitude member ...]作用: 添加地理位置信息 示例:
# 添加城市坐标
GEOADD cities 116.3974 39.9093 "北京"
GEOADD cities 121.4737 31.2304 "上海"
GEOADD cities 113.2644 23.1291 "广州"
GEODIST
语法: GEODIST key member1 member2 [unit]作用: 计算两个地理位置之间的距离 单位: m(米), km(千米), mi(英里), ft(英尺) 示例:
# 计算北京到上海的距离（千米）
GEODIST cities "北京" "上海" km
# 计算北京到广州的距离（米）
GEODIST cities "北京" "广州" m
GEORADIUS
语法: GEORADIUS key longitude latitude radius unit [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count] [ASC|DESC]作用: 查找指定半径内的地理位置 示例:
# 查找北京 500km 内的城市
GEORADIUS cities 116.3974 39.9093 500 km
# 带坐标和距离信息
GEORADIUS cities 116.3974 39.9093 500 km WITHCOORD WITHDIST
# 限制返回数量
GEORADIUS cities 116.3974 39.9093 1000 km COUNT 5
GEORADIUSBYMEMBER
语法: GEORADIUSBYMEMBER key member radius unit [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count] [ASC|DESC]作用: 查找指定成员周围指定半径内的地理位置 示例:
# 查找北京周围 500km 内的城市
GEORADIUSBYMEMBER cities "北京" 500 km
# 带坐标和距离信息
GEORADIUSBYMEMBER cities "北京" 500 km WITHCOORD WITHDIST
GEOPOS
语法: GEOPOS key member [member ...]作用: 获取地理位置的坐标 示例:
# 获取单个城市的坐标
GEOPOS cities "北京"
# 获取多个城市的坐标
GEOPOS cities "北京" "上海" "广州"
GEOHASH
语法: GEOHASH key member [member ...]作用: 获取地理位置的 Geohash 值 示例:
# 获取城市的 Geohash 值
GEOHASH cities "北京" "上海"
常用命令组合示例
缓存模式
# 设置缓存
SET user:1001:profile '{"name":"张三","age":25}' EX 3600
# 获取缓存
GET user:1001:profile
# 检查缓存是否存在
EXISTS user:1001:profile
计数器模式
# 页面访问计数
INCR page:views:homepage
# 用户点赞计数
INCRBY post:123:likes 1
# 获取计数
GET page:views:homepage
排行榜模式
# 添加分数
ZADD leaderboard 100 "player1" 200 "player2" 150 "player3"
# 获取前3名
ZREVRANGE leaderboard 0 2 WITHSCORES
# 获取玩家排名
ZRANK leaderboard "player1"
消息队列模式
# 生产者：添加消息
LPUSH task:queue "task1" "task2" "task3"
# 消费者：获取消息
RPOP task:queue
# 查看队列长度
LLEN task:queue
位图统计模式
# 用户签到统计
SETBIT user:signin:2024:01:01 1001 1
SETBIT user:signin:2024:01:01 1002 1
SETBIT user:signin:2024:01:01 1003 1
# 统计签到人数
BITCOUNT user:signin:2024:01:01
# 检查用户是否签到
GETBIT user:signin:2024:01:01 1001
HyperLogLog 统计模式
# 统计页面访问用户数
PFADD page:home:visitors user1 user2 user3
PFADD page:home:visitors user2 user4 user5
# 获取独立访客数
PFCOUNT page:home:visitors
# 合并多个页面的访客统计
PFMERGE total:visitors page:home:visitors page:about:visitors
地理位置服务模式
# 添加商店位置
GEOADD stores 116.3974 39.9093 "王府井店"
GEOADD stores 121.4737 31.2304 "南京路店"
# 查找附近 5km 内的商店
GEORADIUS stores 116.4 39.9 5 km WITHCOORD WITHDIST
# 计算两个商店的距离
GEODIST stores "王府井店" "南京路店" km
Lua 脚本原子操作模式
# 原子性计数器（带过期时间）
EVAL "
local current = redis.call('GET', KEYS[1])
if current == false then
redis.call('SET', KEYS[1], 1)
redis.call('EXPIRE', KEYS[1], ARGV[1])
return 1
else
return redis.call('INCR', KEYS[1])
end
" 1 page:views:homepage 3600
# 分布式锁实现
EVAL "
if redis.call('GET', KEYS[1]) == ARGV[1] then
return redis.call('DEL', KEYS[1])
else
return 0
end
" 1 lock:resource "unique_value"
SCAN 安全遍历模式
# 安全遍历所有用户键
SCAN 0 MATCH user:* COUNT 100
# 遍历特定类型的键
SCAN 0 TYPE string COUNT 50
# 遍历哈希字段
HSCAN user:1001 0 MATCH name* COUNT 10
注意事项
- 性能考虑: 避免使用
KEYS *命令，在生产环境中使用SCAN命令 - 内存管理: 合理设置过期时间，避免内存泄漏
- 事务限制: Redis 事务不支持回滚，只能取消
- 数据类型: 选择合适的数据类型可以提高性能和减少内存使用
- 命令复杂度: 注意命令的时间复杂度，避免阻塞操作
- SCAN 命令: 使用 SCAN 系列命令时要注意游标管理，避免无限循环
- Lua 脚本: 脚本执行时间过长会阻塞 Redis，建议脚本执行时间控制在 5ms 以内
- 位图操作: 位图操作适合大量数据的统计，但要注意内存使用
- HyperLogLog: 适合基数统计，但存在一定误差（约 0.81%）
- 地理位置: GEO 命令基于球面距离计算，适合地理位置相关应用
总结
Redis 提供了丰富的数据类型和命令，可以满足各种应用场景的需求。掌握这些常用命令是使用 Redis 的基础，合理使用这些命令可以构建高性能的应用程序。
建议在实际使用中：
- 根据业务需求选择合适的数据类型
- 注意命令的性能特征
- 合理设置过期时间
- 使用连接池管理连接
- 监控 Redis 的性能指标